synodic-client 0.0.1.dev41__tar.gz → 0.0.1.dev44__tar.gz

{synodic_client-0.0.1.dev41 → synodic_client-0.0.1.dev44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: synodic_client
-Version: 0.0.1.dev41
+Version: 0.0.1.dev44
 Author-Email: Synodic Software <contact@synodic.software>
 License: LGPL-3.0-or-later
 Project-URL: homepage, https://github.com/synodic/synodic-client

{synodic_client-0.0.1.dev41 → synodic_client-0.0.1.dev44}/pyproject.toml

@@ -15,7 +15,7 @@ dependencies = [
     "velopack>=0.0.1444.dev49733",
     "typer>=0.24.1",
 ]
-version = "0.0.1.dev41"
+version = "0.0.1.dev44"
 
 [project.license]
 text = "LGPL-3.0-or-later"

synodic_client-0.0.1.dev44/synodic_client/_version.py

@@ -0,0 +1 @@
+__version__ = '0.0.1.dev44'

{synodic_client-0.0.1.dev41 → synodic_client-0.0.1.dev44}/synodic_client/application/bootstrap.py

@@ -9,7 +9,7 @@ Import order matters:
     1. stdlib + config (pure-Python, fast)
     2. configure_logging() — now Qt-free
     3. initialize_velopack() — hooks run with logging active
-    4. register_protocol() — stdlib only
+    4. run_startup_preamble() — protocol, config seed, auto-startup
     5. import qt.application — PySide6 / porringer loaded here
 """
 
@@ -17,9 +17,6 @@ import sys
 
 from synodic_client.config import set_dev_mode
 from synodic_client.logging import configure_logging
-from synodic_client.protocol import register_protocol
-from synodic_client.resolution import resolve_config, seed_user_config_from_build
-from synodic_client.startup import register_startup, remove_startup
 from synodic_client.updater import initialize_velopack
 
 _PROTOCOL_SCHEME = 'synodic'
@@ -32,16 +29,9 @@ configure_logging()
 initialize_velopack()
 
 if not _dev_mode:
-    # Seed user config from the build config (one-time propagation).
-    seed_user_config_from_build()
+    from synodic_client.application.init import run_startup_preamble
 
-    register_protocol(sys.executable)
-
-    _config = resolve_config()
-    if _config.auto_start:
-        register_startup(sys.executable)
-    else:
-        remove_startup()
+    run_startup_preamble(sys.executable)
 
 # Heavy imports happen here — PySide6, porringer, etc.
 from synodic_client.application.qt import application

synodic_client-0.0.1.dev44/synodic_client/application/init.py

@@ -0,0 +1,61 @@
+"""Shared startup preamble for frozen and CLI entry points.
+
+Encapsulates the one-time initialisation that both
+:mod:`synodic_client.application.bootstrap` (PyInstaller) and
+:mod:`synodic_client.application.qt` (CLI / dev-script) need to
+perform before the GUI event loop starts:
+
+1. Seed user config from the build config (one-time propagation).
+2. Register the ``synodic://`` URI protocol handler.
+3. Synchronise the Windows auto-startup registry entry with the
+   persisted ``auto_start`` preference.
+
+Heavy dependencies (PySide6, porringer) are **not** imported here so
+that the bootstrap path can call this before loading them.
+"""
+
+import logging
+import sys
+
+from synodic_client.protocol import register_protocol
+from synodic_client.resolution import resolve_config, seed_user_config_from_build
+from synodic_client.startup import register_startup, remove_startup
+
+logger = logging.getLogger(__name__)
+
+_preamble_done = False
+
+
+def run_startup_preamble(exe_path: str | None = None) -> None:
+    """Run the shared startup preamble for non-dev-mode launches.
+
+    Both the frozen entry point
+    (:mod:`~synodic_client.application.bootstrap`) and the CLI entry
+    point (:func:`~synodic_client.application.qt.application`) call
+    this unconditionally.  An internal guard ensures the work only
+    executes once per process.
+
+    Args:
+        exe_path: Absolute path to the application executable.  Defaults
+            to ``sys.executable`` when not supplied.
+    """
+    global _preamble_done  # noqa: PLW0603
+    if _preamble_done:
+        return
+    _preamble_done = True
+
+    if exe_path is None:
+        exe_path = sys.executable
+
+    # Seed user config from the build config (one-time propagation).
+    seed_user_config_from_build()
+
+    register_protocol(exe_path)
+
+    config = resolve_config()
+    if config.auto_start:
+        register_startup(exe_path)
+    else:
+        remove_startup()
+
+    logger.info('Startup preamble complete (auto_start=%s)', config.auto_start)

{synodic_client-0.0.1.dev41 → synodic_client-0.0.1.dev44}/synodic_client/application/qt.py

@@ -15,6 +15,7 @@ from PySide6.QtCore import Qt, QTimer
 from PySide6.QtWidgets import QApplication
 
 from synodic_client.application.icon import app_icon
+from synodic_client.application.init import run_startup_preamble
 from synodic_client.application.instance import SingleInstance
 from synodic_client.application.screen.install import InstallPreviewWindow
 from synodic_client.application.screen.screen import Screen
@@ -23,15 +24,12 @@ from synodic_client.application.uri import parse_uri
 from synodic_client.client import Client
 from synodic_client.config import set_dev_mode
 from synodic_client.logging import configure_logging
-from synodic_client.protocol import register_protocol
 from synodic_client.resolution import (
     ResolvedConfig,
     resolve_config,
     resolve_update_config,
     resolve_version,
-    seed_user_config_from_build,
 )
-from synodic_client.startup import register_startup, remove_startup
 from synodic_client.updater import initialize_velopack
 
 
@@ -139,20 +137,10 @@ def application(*, uri: str | None = None, dev_mode: bool = False) -> None:
     _install_exception_hook(logger)
 
     if not dev_mode:
-        # Initialize Velopack early, before any UI.
-        # Console window suppression for subprocesses is handled by the
-        # PyInstaller runtime hook (rthook_no_console.py).
+        # All three functions are idempotent — safe to call even when
+        # bootstrap.py has already executed them before heavy imports.
         initialize_velopack()
-        register_protocol(sys.executable)
-
-        # Seed user config from build config (one-time propagation).
-        seed_user_config_from_build()
-
-        startup_config = resolve_config()
-        if startup_config.auto_start:
-            register_startup(sys.executable)
-        else:
-            remove_startup()
+        run_startup_preamble(sys.executable)
 
     if uri:
         logger.info('Received URI: %s', uri)

{synodic_client-0.0.1.dev41 → synodic_client-0.0.1.dev44}/synodic_client/application/screen/settings.py

@@ -27,9 +27,10 @@ from PySide6.QtWidgets import (
     QWidget,
 )
 
+from synodic_client._version import __version__
 from synodic_client.application.icon import app_icon
 from synodic_client.application.screen.card import CardFrame
-from synodic_client.application.theme import SETTINGS_WINDOW_MIN_SIZE
+from synodic_client.application.theme import SETTINGS_WINDOW_MIN_SIZE, UPDATE_STATUS_CHECKING_STYLE
 from synodic_client.logging import log_path
 from synodic_client.resolution import ResolvedConfig, update_user_config
 from synodic_client.startup import is_startup_registered, register_startup, remove_startup
@@ -92,6 +93,11 @@ class SettingsWindow(QMainWindow):
         layout.addWidget(self._build_advanced_section())
         layout.addStretch()
 
+        version_label = QLabel(f'Version {__version__}')
+        version_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        version_label.setStyleSheet('color: rgba(255, 255, 255, 0.4); font-size: 11px;')
+        layout.addWidget(version_label)
+
         scroll.setWidget(container)
         self.setCentralWidget(scroll)
 
@@ -163,6 +169,11 @@ class SettingsWindow(QMainWindow):
         self._detect_updates_check.toggled.connect(self._on_detect_updates_changed)
         content.addWidget(self._detect_updates_check)
 
+        # Automatically apply updates
+        self._auto_apply_check = QCheckBox('Automatically apply updates')
+        self._auto_apply_check.toggled.connect(self._on_auto_apply_changed)
+        content.addWidget(self._auto_apply_check)
+
         # Check for Updates
         row = QHBoxLayout()
         self._check_updates_btn = QPushButton('Check for Updates\u2026')
@@ -218,16 +229,24 @@ class SettingsWindow(QMainWindow):
 
             # Checkboxes
             self._detect_updates_check.setChecked(config.detect_updates)
+            self._auto_apply_check.setChecked(config.auto_apply)
             self._auto_start_check.setChecked(is_startup_registered())
 
-    def set_update_status(self, text: str) -> None:
-        """Set the inline status text next to the *Check for Updates* button."""
+    def set_update_status(self, text: str, style: str = '') -> None:
+        """Set the inline status text next to the *Check for Updates* button.
+
+        Args:
+            text: The status message.
+            style: Optional stylesheet for the label (e.g. color).
+        """
         self._update_status_label.setText(text)
+        self._update_status_label.setStyleSheet(style)
 
     def set_checking(self) -> None:
         """Enter the *checking* state — disable button and show status."""
         self._check_updates_btn.setEnabled(False)
         self._update_status_label.setText('Checking\u2026')
+        self._update_status_label.setStyleSheet(UPDATE_STATUS_CHECKING_STYLE)
 
     def reset_check_updates_button(self) -> None:
         """Re-enable the *Check for Updates* button after a check completes."""
@@ -262,6 +281,7 @@ class SettingsWindow(QMainWindow):
             self._auto_update_spin,
             self._tool_update_spin,
             self._detect_updates_check,
+            self._auto_apply_check,
             self._auto_start_check,
             self._check_updates_btn,
         )
@@ -301,6 +321,9 @@ class SettingsWindow(QMainWindow):
     def _on_detect_updates_changed(self, checked: bool) -> None:
         self._persist(detect_updates=checked)
 
+    def _on_auto_apply_changed(self, checked: bool) -> None:
+        self._persist(auto_apply=checked)
+
     def _on_auto_start_changed(self, checked: bool) -> None:
         self._config = update_user_config(auto_start=checked)
         if checked:

{synodic_client-0.0.1.dev41 → synodic_client-0.0.1.dev44}/synodic_client/application/screen/tray.py

@@ -17,10 +17,9 @@ from PySide6.QtWidgets import (
 from synodic_client.application.icon import app_icon
 from synodic_client.application.screen.screen import MainWindow, ToolsView
 from synodic_client.application.screen.settings import SettingsWindow
+from synodic_client.application.update_controller import UpdateController
 from synodic_client.application.workers import (
     ToolUpdateResult,
-    check_for_update,
-    download_update,
     run_package_remove,
     run_tool_updates,
 )
@@ -31,7 +30,6 @@ from synodic_client.resolution import (
     resolve_config,
     resolve_update_config,
 )
-from synodic_client.updater import UpdateInfo
 
 logger = logging.getLogger(__name__)
 
@@ -59,7 +57,6 @@ class TrayScreen:
         self._client = client
         self._window = window
         self._config = config
-        self._update_task: asyncio.Task[None] | None = None
         self._tool_task: asyncio.Task[None] | None = None
 
         self.tray_icon = app_icon()
@@ -74,14 +71,19 @@ class TrayScreen:
         # Settings window (created once, shown/hidden on demand)
         self._settings_window = SettingsWindow(self._resolve_config())
         self._settings_window.settings_changed.connect(self._on_settings_changed)
-        self._settings_window.check_updates_requested.connect(self._on_check_updates)
 
         # MainWindow gear button → open settings
         window.settings_requested.connect(self._show_settings)
 
-        # Periodic auto-update checking
-        self._auto_update_timer: QTimer | None = None
-        self._restart_auto_update_timer()
+        # Update controller — owns the self-update lifecycle & timer
+        self._banner = window.update_banner
+        self._update_controller = UpdateController(
+            app,
+            client,
+            self._banner,
+            self._settings_window,
+            config,
+        )
 
         # Periodic tool update checking
         self._tool_update_timer: QTimer | None = None
@@ -90,11 +92,6 @@ class TrayScreen:
         # Connect ToolsView signals — deferred because ToolsView is created lazily
         window.tools_view_created.connect(self._connect_tools_view)
 
-        # Connect update banner signals
-        self._banner = window.update_banner
-        self._banner.restart_requested.connect(self._apply_update)
-        self._banner.retry_requested.connect(lambda: self._do_check_updates(silent=True))
-
     def _build_menu(self, app: QApplication, window: MainWindow) -> None:
         """Build the tray context menu."""
         self.menu = QMenu()
@@ -105,12 +102,6 @@ class TrayScreen:
 
         self.menu.addSeparator()
 
-        self.update_action = QAction('Check for Updates...', self.menu)
-        self.update_action.triggered.connect(self._on_check_updates)
-        self.menu.addAction(self.update_action)
-
-        self.menu.addSeparator()
-
         self.settings_action = QAction('Settings\u2026', self.menu)
         self.settings_action.triggered.connect(self._show_settings)
         self.menu.addAction(self.settings_action)
@@ -172,16 +163,6 @@ class TrayScreen:
         logger.info('%s enabled (every %d minute(s))', label, interval_minutes)
         return timer
 
-    def _restart_auto_update_timer(self) -> None:
-        """Start (or restart) the periodic auto-update timer from config."""
-        config = resolve_update_config(self._resolve_config())
-        self._auto_update_timer = self._restart_timer(
-            self._auto_update_timer,
-            config.auto_update_interval_minutes,
-            self._on_auto_check_updates,
-            'Automatic update checking',
-        )
-
     def _restart_tool_update_timer(self) -> None:
         """Start (or restart) the periodic tool update timer from config."""
         config = resolve_update_config(self._resolve_config())
@@ -206,116 +187,10 @@ class TrayScreen:
     def _on_settings_changed(self, config: ResolvedConfig) -> None:
         """React to a change made in the settings window."""
         self._config = config
-        self._reinitialize_updater(config)
-
-    def _reinitialize_updater(self, config: ResolvedConfig) -> None:
-        """Re-derive update settings and restart the updater and timers.
-
-        The new ``Updater`` starts with the ``importlib.metadata``
-        version which may be stale after a Velopack update.  The
-        authoritative Velopack version is recovered automatically on
-        the first ``_get_velopack_manager()`` call (i.e. the next
-        update check), so no special handling is required here.
-        """
-        update_cfg = resolve_update_config(config)
-        self._client.initialize_updater(update_cfg)
-        self._restart_auto_update_timer()
+        # Delegate updater reinit + immediate check to the controller
+        self._update_controller.on_settings_changed(config)
+        # Restart tool-update timer with new config
         self._restart_tool_update_timer()
-        logger.info('Updater re-initialized (channel: %s, source: %s)', update_cfg.channel.name, update_cfg.repo_url)
-
-    def _reset_update_action(self) -> None:
-        """Restore the 'Check for Updates' action to its idle state."""
-        self.update_action.setEnabled(True)
-        self.update_action.setText('Check for Updates...')
-
-    def _on_check_updates(self) -> None:
-        """Handle manual check for updates action."""
-        self._do_check_updates(silent=False)
-
-    def _on_auto_check_updates(self) -> None:
-        """Handle automatic (periodic) check for updates.
-
-        Failures and no-update results are logged silently without
-        showing the in-app error banner.
-        """
-        self._do_check_updates(silent=True)
-
-    def _do_check_updates(self, *, silent: bool) -> None:
-        """Run an update check.
-
-        Args:
-            silent: When ``True``, suppress the in-app error banner
-                for failures and no-update results.  The banner is
-                always shown when an update *is* available.
-        """
-        if self._client.updater is None:
-            if not silent:
-                self._banner.show_error('Updater is not initialized.')
-            return
-
-        # Disable both the tray action and the settings button while checking
-        self.update_action.setEnabled(False)
-        self.update_action.setText('Checking for Updates...')
-        self._settings_window.set_checking()
-
-        self._update_task = asyncio.create_task(self._async_check_updates(silent=silent))
-
-    async def _async_check_updates(self, *, silent: bool) -> None:
-        """Run the update check coroutine and route results."""
-        try:
-            result = await check_for_update(self._client)
-            self._on_update_check_finished(result, silent=silent)
-        except Exception as exc:
-            logger.exception('Update check failed')
-            self._on_update_check_error(str(exc), silent=silent)
-
-    def _on_update_check_finished(self, result: UpdateInfo | None, *, silent: bool = False) -> None:
-        """Handle update check completion."""
-        self._reset_update_action()
-        self._settings_window.reset_check_updates_button()
-
-        if result is None:
-            self._settings_window.set_update_status('Check failed')
-            if not silent:
-                self._banner.show_error('Failed to check for updates.')
-            else:
-                logger.warning('Automatic update check failed (no result)')
-            return
-
-        if result.error:
-            self._settings_window.set_update_status(result.error)
-            if not silent:
-                self._banner.show_error(result.error)
-            else:
-                logger.warning('Automatic update check failed: %s', result.error)
-            return
-
-        if not result.available:
-            self._settings_window.set_update_status(
-                f'Up to date ({result.current_version})',
-            )
-            if not silent:
-                logger.info('No updates available (current: %s)', result.current_version)
-            else:
-                logger.debug('Automatic update check: no update available')
-            return
-
-        # Update available — show banner and start download automatically
-        version = str(result.latest_version)
-        self._settings_window.set_update_status(f'Update available: {version}')
-        self._banner.show_downloading(version)
-        self._start_download(version)
-
-    def _on_update_check_error(self, error: str, *, silent: bool = False) -> None:
-        """Handle update check error."""
-        self._reset_update_action()
-        self._settings_window.reset_check_updates_button()
-        self._settings_window.set_update_status(f'Error: {error}')
-
-        if not silent:
-            self._banner.show_error(f'Update check error: {error}')
-        else:
-            logger.warning('Automatic update check error: %s', error)
 
     # -- Tool update helpers --
 
@@ -571,51 +446,3 @@ class TrayScreen:
             tools_view.refresh()
 
         self._window.show()
-
-    # -- Self-update download & apply --
-
-    def _start_download(self, version: str) -> None:
-        """Start downloading the update in the background.
-
-        Args:
-            version: The version string being downloaded (for banner display).
-        """
-        self._update_task = asyncio.create_task(self._async_download(version))
-
-    async def _async_download(self, version: str) -> None:
-        """Run the download coroutine and route results."""
-        try:
-            success = await download_update(
-                self._client,
-                on_progress=self._banner.show_downloading_progress,
-            )
-            self._on_download_finished(success, version)
-        except Exception as exc:
-            logger.exception('Update download failed')
-            self._on_download_error(str(exc))
-
-    def _on_download_finished(self, success: bool, version: str) -> None:
-        """Handle download completion — transition banner to ready state."""
-        if not success:
-            self._banner.show_error('Download failed. Please try again later.')
-            return
-
-        self._banner.show_ready(version)
-        self._settings_window.set_update_status(f'Ready to install: {version}')
-
-    def _on_download_error(self, error: str) -> None:
-        """Handle download error — show error banner."""
-        self._banner.show_error(f'Download error: {error}')
-
-    def _apply_update(self) -> None:
-        """Apply the downloaded update and restart."""
-        if self._client.updater is None:
-            return
-
-        try:
-            self._client.apply_update_on_exit(restart=True)
-            logger.info('Update scheduled — restarting application')
-            self._app.quit()
-        except Exception as e:
-            logger.error('Failed to apply update: %s', e)
-            self._banner.show_error(f'Failed to apply update: {e}')

{synodic_client-0.0.1.dev41 → synodic_client-0.0.1.dev44}/synodic_client/application/theme.py

@@ -436,6 +436,21 @@ SETTINGS_GEAR_STYLE = (
 )
 """Gear button style for the MainWindow tab corner widget."""
 
+# ---------------------------------------------------------------------------
+# Settings inline update-status colours
+# ---------------------------------------------------------------------------
+UPDATE_STATUS_UP_TO_DATE_STYLE = 'color: #89d185; font-size: 12px;'
+"""Green text for 'Up to date' / 'Ready' status."""
+
+UPDATE_STATUS_AVAILABLE_STYLE = 'color: #cca700; font-size: 12px;'
+"""Orange text for 'Update available' status."""
+
+UPDATE_STATUS_ERROR_STYLE = 'color: #f48771; font-size: 12px;'
+"""Red text for error / check-failed status."""
+
+UPDATE_STATUS_CHECKING_STYLE = 'color: #808080; font-size: 12px; font-style: italic;'
+"""Grey italic text for 'Checking…' status."""
+
 # ---------------------------------------------------------------------------
 # Update banner (in-app self-update notification)
 # ---------------------------------------------------------------------------