вапвап

Author: XrayFluent Dev

.github/workflows/build.yml

@@ -132,8 +132,8 @@ jobs:
         run: |
           cd dist/ZapretKVN
 
-          7z a -tzip -mx=9 -mfb=258 -mpass=15 "../ZapretKVN-v$env:VERSION-windows-x64.zip" *
-          7z a -t7z -mx=9 -mfb=273 -ms=on -md=64m -mmt=on "../ZapretKVN-v$env:VERSION-windows-x64.7z" *
+          7z a -tzip -mx=5 "../ZapretKVN-v$env:VERSION-windows-x64.zip" *
+          7z a -t7z -mx=5 "../ZapretKVN-v$env:VERSION-windows-x64.7z" *
 
           cd ..
           Write-Host "Release archives:"

xray_fluent/app_updater.py

@@ -0,0 +1,146 @@
+"""Self-update: check GitHub releases, download, extract, restart."""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import zipfile
+from dataclasses import dataclass
+from pathlib import Path
+from urllib.request import Request, urlopen
+
+from PyQt6.QtCore import QThread, pyqtSignal
+
+from .constants import APP_VERSION, BASE_DIR
+
+GITHUB_REPO = "youtubediscord/zapret-kvn"
+GITHUB_API = f"https://api.github.com/repos/{GITHUB_REPO}/releases/latest"
+USER_AGENT = f"ZapretKVN/{APP_VERSION}"
+
+
+@dataclass(slots=True)
+class AppUpdate:
+    version: str
+    tag: str
+    download_url: str
+    size: int
+    notes: str
+
+
+def _parse_version(v: str) -> tuple[int, ...]:
+    clean = v.lstrip("v").split("-")[0]
+    return tuple(int(x) for x in clean.split(".") if x.isdigit())
+
+
+class UpdateChecker(QThread):
+    """Check GitHub for a newer release."""
+
+    result = pyqtSignal(object)  # AppUpdate | None
+
+    def run(self) -> None:
+        try:
+            req = Request(GITHUB_API, headers={"User-Agent": USER_AGENT})
+            with urlopen(req, timeout=10) as resp:
+                data = json.loads(resp.read())
+
+            tag = data.get("tag_name", "")
+            remote = _parse_version(tag)
+            local = _parse_version(APP_VERSION)
+
+            if remote <= local:
+                self.result.emit(None)
+                return
+
+            asset = None
+            for a in data.get("assets", []):
+                name = a.get("name", "").lower()
+                if name.endswith(".zip") and "windows" in name and "x64" in name:
+                    asset = a
+                    break
+
+            if not asset:
+                self.result.emit(None)
+                return
+
+            self.result.emit(AppUpdate(
+                version=tag.lstrip("v"),
+                tag=tag,
+                download_url=asset["browser_download_url"],
+                size=asset.get("size", 0),
+                notes=data.get("body", ""),
+            ))
+        except Exception:
+            self.result.emit(None)
+
+
+class UpdateDownloader(QThread):
+    """Download and extract update, then launch restart script."""
+
+    progress = pyqtSignal(int)  # percent 0-100
+    finished_ok = pyqtSignal()
+    error = pyqtSignal(str)
+
+    def __init__(self, update: AppUpdate, parent=None):
+        super().__init__(parent)
+        self._update = update
+
+    def run(self) -> None:
+        try:
+            tmp_dir = Path(tempfile.mkdtemp(prefix="zapretkvn_update_"))
+            zip_path = tmp_dir / "update.zip"
+
+            # Download
+            req = Request(self._update.download_url, headers={"User-Agent": USER_AGENT})
+            with urlopen(req, timeout=120) as resp:
+                total = int(resp.headers.get("Content-Length", 0))
+                downloaded = 0
+                with open(zip_path, "wb") as f:
+                    while True:
+                        chunk = resp.read(256 * 1024)
+                        if not chunk:
+                            break
+                        f.write(chunk)
+                        downloaded += len(chunk)
+                        if total > 0:
+                            self.progress.emit(int(downloaded * 100 / total))
+
+            self.progress.emit(100)
+
+            # Extract
+            extract_dir = tmp_dir / "extracted"
+            with zipfile.ZipFile(zip_path, "r") as zf:
+                zf.extractall(extract_dir)
+
+            # Write restart script
+            exe_name = "ZapretKVN.exe"
+            app_dir = str(BASE_DIR)
+            src_dir = str(extract_dir)
+            script = tmp_dir / "_update.bat"
+            script.write_text(
+                "@echo off\r\n"
+                "echo Updating zapret kvn...\r\n"
+                "timeout /t 2 /nobreak >nul\r\n"
+                f'taskkill /F /IM {exe_name} 2>nul\r\n'
+                "timeout /t 1 /nobreak >nul\r\n"
+                f'xcopy /E /Y /Q "{src_dir}\\*" "{app_dir}\\"\r\n'
+                "echo Update complete. Restarting...\r\n"
+                f'start "" "{app_dir}\\{exe_name}"\r\n'
+                f'rmdir /S /Q "{str(tmp_dir)}"\r\n',
+                encoding="ascii",
+            )
+
+            # Launch script and exit
+            subprocess.Popen(
+                ["cmd", "/c", str(script)],
+                creationflags=0x08000000,
+                close_fds=True,
+            )
+
+            self.finished_ok.emit()
+
+        except Exception as exc:
+            self.error.emit(str(exc))

xray_fluent/ui/main_window.py

@@ -16,9 +16,9 @@
 
 from ..app_controller import AppController
 from ..storage import PassphraseRequired
-from ..constants import APP_NAME
+from ..constants import APP_NAME, APP_VERSION
 from ..models import AppSettings, Node, RoutingSettings
-from ..update_checker import check_update
+from ..app_updater import AppUpdate, UpdateChecker, UpdateDownloader
 from ..xray_core_updater import XrayCoreUpdateResult
 from .bulk_edit_dialog import BulkEditDialog
 from .dashboard_page import DashboardPage
@@ -28,6 +28,7 @@
 from .nodes_page import NodesPage
 from .routing_page import RoutingPage
 from .settings_page import SettingsPage
+from .updates_page import UpdatesPage
 
 
 class MainWindow(FluentWindow):
@@ -56,6 +57,7 @@ def initialize(self) -> None:
         self.routing_page = RoutingPage(self)
         self.logs_page = LogsPage(self)
         self.settings_page = SettingsPage(self)
+        self.updates_page = UpdatesPage(self)
 
         self._create_navigation()
         self._create_tray()
@@ -72,6 +74,11 @@ def initialize(self) -> None:
         if loaded and unlocked:
             self.controller.auto_connect_if_needed()
 
+        # Set Xray version on updates page
+        from ..xray_manager import get_xray_version
+        xv = get_xray_version(self.controller.state.settings.xray_path)
+        self.updates_page.set_xray_version(xv or "")
+
         if self.controller.state.settings.check_updates:
             QTimer.singleShot(2500, lambda: self._check_updates(silent=True))
 
@@ -85,6 +92,7 @@ def _create_navigation(self) -> None:
         self.addSubInterface(self.nodes_page, FIF.LINK, "Nodes")
         self.addSubInterface(self.routing_page, FIF.GLOBE, "Routing")
         self.addSubInterface(self.logs_page, FIF.DOCUMENT, "Logs")
+        self.addSubInterface(self.updates_page, FIF.UPDATE, "Updates", NavigationItemPosition.BOTTOM)
         self.addSubInterface(self.settings_page, FIF.SETTING, "Settings", NavigationItemPosition.BOTTOM)
 
     def _create_tray(self) -> None:
@@ -166,9 +174,9 @@ def _connect_signals(self) -> None:
         self.settings_page.set_password_requested.connect(self._set_password)
         self.settings_page.disable_password_requested.connect(self.controller.disable_master_password)
         self.settings_page.lock_now_requested.connect(self.controller.lock)
-        self.settings_page.check_updates_requested.connect(self._check_updates)
-        self.settings_page.check_xray_updates_requested.connect(lambda: self.controller.run_xray_core_update(False, silent=False))
-        self.settings_page.update_xray_requested.connect(lambda: self.controller.run_xray_core_update(True, silent=False))
+        self.updates_page.check_app_requested.connect(self._check_updates)
+        self.updates_page.check_xray_requested.connect(lambda: self.controller.run_xray_core_update(False, silent=False))
+        self.updates_page.update_xray_requested.connect(lambda: self.controller.run_xray_core_update(True, silent=False))
         self.settings_page.export_backup_requested.connect(self._export_backup)
         self.settings_page.import_backup_requested.connect(self._import_backup)
         self.settings_page.set_encryption_requested.connect(self._set_encryption)
@@ -372,29 +380,57 @@ def _export_diagnostics(self) -> None:
         self._show_status("success", f"Diagnostics exported: {path}")
 
     def _check_updates(self, silent: bool = False) -> None:
-        settings = self.controller.state.settings
-        if not settings.allow_updates:
-            if not silent:
-                self._show_status("info", "Updates disabled in settings")
-            return
-        if not settings.update_feed_url:
+        self._pending_update: AppUpdate | None = None
+        self._update_checker = UpdateChecker(parent=self)
+        self._update_checker.result.connect(lambda u: self._on_update_check_result(u, silent))
+        self._update_checker.start()
+        if not silent:
+            self.updates_page.show_checking()
+
+    def _on_update_check_result(self, update: AppUpdate | None, silent: bool) -> None:
+        if update is None:
+            self.updates_page.show_up_to_date()
             if not silent:
-                self._show_status("warning", "Update feed URL is empty")
+                self._show_status("info", "You are on the latest version")
             return
 
-        try:
-            info = check_update(settings.update_feed_url, channel=settings.release_channel)
-        except Exception as exc:
-            if not silent:
-                self._show_status("error", f"Update check failed: {exc}")
-            else:
-                self.logs_page.append_line(f"[update] check failed: {exc}")
-            return
+        self._pending_update = update
+        self.updates_page.show_update_available(update.version)
+        self.updates_page.download_btn.clicked.connect(
+            lambda: self._start_update_download(self._pending_update)
+        )
 
-        if info:
-            self._show_status("success", f"Latest {info.channel}: {info.version}")
-        elif not silent:
-            self._show_status("info", "No update info available")
+        # Blocking dialog
+        from qfluentwidgets import MessageBox
+        box = MessageBox(
+            "Update available",
+            f"New version v{update.version} is available.\n"
+            f"Current: v{APP_VERSION}\n\n"
+            f"The app will download, close, and restart automatically.",
+            self,
+        )
+        box.yesButton.setText("Download && Install")
+        box.cancelButton.setText("Later")
+        if box.exec():
+            self._start_update_download(update)
+
+    def _start_update_download(self, update: AppUpdate) -> None:
+        self.updates_page.show_download_progress(0)
+        self._update_downloader = UpdateDownloader(update, parent=self)
+        self._update_downloader.progress.connect(self.updates_page.show_download_progress)
+        self._update_downloader.finished_ok.connect(self._on_update_ready)
+        self._update_downloader.error.connect(self._on_update_error)
+        self._update_downloader.start()
+
+    def _on_update_ready(self) -> None:
+        self.updates_page.set_app_status("Update downloaded. Restarting...")
+        self._show_status("success", "Update downloaded. Restarting...")
+        QTimer.singleShot(1500, lambda: QApplication.quit())
+
+    def _on_update_error(self, err: str) -> None:
+        self.updates_page.show_idle()
+        self.updates_page.set_app_status(f"Update failed: {err}")
+        self._show_status("error", f"Update failed: {err}")
 
     def _apply_theme(self, theme_name: str, accent_color: str) -> None:
         normalized = theme_name.lower().strip()