synodic-client 0.0.1.dev61__tar.gz → 0.0.1.dev63__tar.gz

{synodic_client-0.0.1.dev61 → synodic_client-0.0.1.dev63}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: synodic_client
-Version: 0.0.1.dev61
+Version: 0.0.1.dev63
 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.dev61 → synodic_client-0.0.1.dev63}/pyproject.toml

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

{synodic_client-0.0.1.dev61 → synodic_client-0.0.1.dev63}/synodic_client/application/bootstrap.py

@@ -17,6 +17,7 @@ import sys
 
 from synodic_client.config import set_dev_mode
 from synodic_client.logging import configure_logging
+from synodic_client.subprocess_patch import apply as _apply_subprocess_patch
 from synodic_client.protocol import extract_uri_from_args
 from synodic_client.updater import initialize_velopack
 
@@ -24,6 +25,7 @@ from synodic_client.updater import initialize_velopack
 _dev_mode = '--dev' in sys.argv[1:]
 _debug = '--debug' in sys.argv[1:]
 set_dev_mode(_dev_mode)
+_apply_subprocess_patch()
 
 configure_logging(debug=_debug)
 initialize_velopack()

{synodic_client-0.0.1.dev61 → synodic_client-0.0.1.dev63}/synodic_client/application/qt.py

@@ -31,6 +31,7 @@ from synodic_client.resolution import (
     resolve_config,
     resolve_update_config,
 )
+from synodic_client.subprocess_patch import apply as _apply_subprocess_patch
 from synodic_client.updater import initialize_velopack
 
 
@@ -72,6 +73,23 @@ def _process_uri(uri: str, handler: Callable[[str], None]) -> None:
             handler(manifests[0])
 
 
+def _cancel_all_tasks(loop: asyncio.AbstractEventLoop) -> None:
+    """Cancel every pending asyncio task on *loop*.
+
+    Called synchronously from the ``aboutToQuit`` handler.  Each task
+    receives a cancellation request; when the event loop processes its
+    remaining iterations the ``CancelledError`` propagates and the
+    tasks finish cleanly.
+    """
+    _logger = logging.getLogger(__name__)
+    pending = [t for t in asyncio.all_tasks(loop) if not t.done()]
+    if not pending:
+        return
+    _logger.info('Cancelling %d pending async task(s)', len(pending))
+    for task in pending:
+        task.cancel()
+
+
 def _install_exception_hook(logger: logging.Logger) -> None:
     """Redirect unhandled exceptions to the log file.
 
@@ -163,6 +181,7 @@ def application(*, uri: str | None = None, dev_mode: bool = False, debug: bool =
     """
     # Activate dev-mode namespacing before anything reads config paths.
     set_dev_mode(dev_mode)
+    _apply_subprocess_patch()
 
     # Configure logging before Velopack so install/uninstall hooks and
     # first-run diagnostics are captured in the log file.
@@ -221,6 +240,18 @@ def application(*, uri: str | None = None, dev_mode: bool = False, debug: bool =
     if uri:
         _process_uri(uri, _handle_install_uri)
 
+    # --- Graceful shutdown ---
+    # aboutToQuit fires synchronously when app.quit() is called but
+    # before the event loop stops, giving us a window to cancel
+    # in-flight async tasks and stop timers.
+
+    def _on_about_to_quit() -> None:
+        logger.info('Application shutting down — cancelling async tasks')
+        _tray.shutdown()
+        _cancel_all_tasks(loop)
+
+    app.aboutToQuit.connect(_on_about_to_quit)
+
     # qasync integrates the asyncio event loop with Qt's event loop,
     # enabling async/await usage in the GUI layer without dedicated threads.
     with loop:

{synodic_client-0.0.1.dev61 → synodic_client-0.0.1.dev63}/synodic_client/application/screen/projects.py

@@ -22,7 +22,7 @@ from synodic_client.application.data import DataCoordinator
 from synodic_client.application.screen.install import SetupPreviewWidget
 from synodic_client.application.screen.schema import PreviewPhase
 from synodic_client.application.screen.sidebar import ManifestSidebar
-from synodic_client.application.screen.spinner import SpinnerWidget
+from synodic_client.application.screen.spinner import LoadingIndicator
 from synodic_client.application.theme import COMPACT_MARGINS
 from synodic_client.resolution import ResolvedConfig
 
@@ -91,9 +91,10 @@ class ProjectsView(QWidget):
         self._empty_placeholder.setStyleSheet('color: grey; font-size: 13px;')
         self._stack.addWidget(self._empty_placeholder)
 
-        outer.addLayout(right, stretch=1)
+        self._loading_indicator = LoadingIndicator('Loading projects\u2026')
+        self._stack.addWidget(self._loading_indicator)
 
-        self._loading_spinner = SpinnerWidget('Loading projects\u2026', parent=self)
+        outer.addLayout(right, stretch=1)
 
     # --- Public API ---
 
@@ -106,7 +107,8 @@ class ProjectsView(QWidget):
     async def _async_refresh(self) -> None:
         """Refresh the sidebar and stacked widgets from the porringer cache."""
         self._refresh_in_progress = True
-        self._loading_spinner.start()
+        self._loading_indicator.start()
+        self._stack.setCurrentWidget(self._loading_indicator)
         self._sidebar.set_enabled(False)
 
         try:
@@ -167,7 +169,7 @@ class ProjectsView(QWidget):
         except Exception:
             logger.exception('Failed to refresh projects')
         finally:
-            self._loading_spinner.stop()
+            self._loading_indicator.stop()
             self._sidebar.set_enabled(True)
             self._refresh_in_progress = False
 

{synodic_client-0.0.1.dev61 → synodic_client-0.0.1.dev63}/synodic_client/application/screen/screen.py

@@ -50,7 +50,7 @@ from synodic_client.application.screen.schema import (
     ProjectInstance,
     RefreshData,
 )
-from synodic_client.application.screen.spinner import SpinnerWidget
+from synodic_client.application.screen.spinner import LoadingIndicator
 from synodic_client.application.screen.update_banner import UpdateBanner
 from synodic_client.application.theme import (
     COMPACT_MARGINS,
@@ -197,7 +197,8 @@ class ToolsView(QWidget):
         self._scroll.setWidget(self._container)
         outer.addWidget(self._scroll)
 
-        self._loading_spinner = SpinnerWidget('Loading tools\u2026', parent=self)
+        self._loading_indicator = LoadingIndicator('Loading tools\u2026')
+        outer.addWidget(self._loading_indicator)
 
         # Periodic timer to refresh relative timestamps (every 60s)
         self._timestamp_timer = QTimer(self)
@@ -224,10 +225,10 @@ class ToolsView(QWidget):
         toolbar.addWidget(check_btn)
         self._check_btn = check_btn
 
-        update_all_btn = QPushButton('Update All')
-        update_all_btn.setToolTip('Upgrade all auto-update-enabled plugins now')
-        update_all_btn.clicked.connect(self.update_all_requested.emit)
-        toolbar.addWidget(update_all_btn)
+        self._update_all_btn = QPushButton('Update All')
+        self._update_all_btn.setToolTip('Upgrade all auto-update-enabled plugins now')
+        self._update_all_btn.clicked.connect(self.update_all_requested.emit)
+        toolbar.addWidget(self._update_all_btn)
 
         return toolbar
 
@@ -248,7 +249,10 @@ class ToolsView(QWidget):
         background task so the widget tree renders immediately.
         """
         self._refresh_in_progress = True
-        self._loading_spinner.start()
+        self._scroll.hide()
+        self._loading_indicator.start()
+        self._check_btn.setEnabled(False)
+        self._update_all_btn.setEnabled(False)
         need_deferred_check = False
 
         try:
@@ -259,7 +263,10 @@ class ToolsView(QWidget):
             logger.exception('Failed to refresh tools')
             need_deferred_check = False
         finally:
-            self._loading_spinner.stop()
+            self._loading_indicator.stop()
+            self._scroll.show()
+            self._check_btn.setEnabled(True)
+            self._update_all_btn.setEnabled(True)
             self._refresh_in_progress = False
 
         # Fire-and-forget: detect updates in the background, then patch

{synodic_client-0.0.1.dev61 → synodic_client-0.0.1.dev63}/synodic_client/application/screen/settings.py

@@ -305,6 +305,15 @@ class SettingsWindow(QMainWindow):
         """Re-enable the *Check for Updates* button after a check completes."""
         self._check_updates_btn.setEnabled(True)
 
+    def update_config(self, config: ResolvedConfig) -> None:
+        """Replace the internal config snapshot without emitting signals.
+
+        Called by controllers that persist timestamps so that the next
+        :meth:`sync_from_config` sees fresh data instead of the stale
+        snapshot captured at construction time.
+        """
+        self._config = config
+
     def set_last_checked(self, timestamp: str) -> None:
         """Update the *last updated* label from an ISO 8601 timestamp."""
         relative = _format_relative_time(timestamp)

{synodic_client-0.0.1.dev61 → synodic_client-0.0.1.dev63}/synodic_client/application/screen/spinner.py

@@ -2,20 +2,23 @@
 
 Provides :class:`SpinnerCanvas` — a lightweight, palette-aware spinning
 arc that can be sized and styled for any context — and
-:class:`SpinnerWidget` — a self-positioning overlay variant with an
-optional text label.
+:class:`LoadingIndicator` — a centred spinner-plus-label widget suited
+for embedding in layouts as a loading placeholder.
 
 :class:`SpinnerCanvas` is used directly in plugin rows and action cards
-where only a small inline indicator is needed.  :class:`SpinnerWidget`
-wraps a canvas and centres itself over its parent for modal-style use.
+where only a small inline indicator is needed.  :class:`LoadingIndicator`
+wraps a canvas with an optional label and is designed to be placed into
+a ``QStackedWidget`` page or swapped with content by the consumer.
 """
 
 from __future__ import annotations
 
-from PySide6.QtCore import QEvent, QRect, Qt, QTimer
+from PySide6.QtCore import QRect, Qt, QTimer
 from PySide6.QtGui import QPainter, QPen
 from PySide6.QtWidgets import QHBoxLayout, QLabel, QSizePolicy, QVBoxLayout, QWidget
 
+from synodic_client.application.theme import LOADING_LABEL_STYLE
+
 _DEFAULT_SIZE = 24
 _DEFAULT_PEN = 3
 _INTERVAL = 50
@@ -83,23 +86,36 @@ class SpinnerCanvas(QWidget):
         self.update()
 
 
-class SpinnerWidget(QWidget):
-    """Animated spinner circle with optional text label.
+class LoadingIndicator(QWidget):
+    """Centred spinner arc with an optional text label.
+
+    Designed to be placed into a layout — for example as a page in a
+    ``QStackedWidget`` or shown/hidden alongside content.  The widget
+    expands to fill available space and centres its contents.
+
+    The consumer is responsible for swapping visibility or stack pages;
+    this component manages only its own animation and display state.
+
+    Typical usage::
 
-    When a *parent* is provided the widget configures itself as a
-    floating overlay that fills the parent's geometry automatically.
-    No ``resizeEvent`` override, ``setSizePolicy``, ``raise_()``, or
-    ``lower()`` call is needed by the consumer — just ``start()`` and
-    ``stop()``.
+        indicator = LoadingIndicator('Loading…')
+        stack.addWidget(indicator)
+
+        # begin loading
+        indicator.start()
+        stack.setCurrentWidget(indicator)
+
+        # finish loading
+        indicator.stop()
+        stack.setCurrentWidget(content)
     """
 
     def __init__(self, text: str = '', parent: QWidget | None = None) -> None:
-        """Initialize the spinner.
+        """Create a loading indicator.
 
         Args:
             text: Optional label shown beside the spinner arc.
-            parent: Optional parent widget.  When set, the spinner
-                becomes a floating overlay that tracks the parent size.
+            parent: Optional parent widget.
         """
         super().__init__(parent)
         self.hide()
@@ -109,6 +125,8 @@ class SpinnerWidget(QWidget):
         self._timer.setInterval(_INTERVAL)
         self._timer.timeout.connect(self._canvas.tick)
 
+        self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+
         outer = QVBoxLayout(self)
         outer.setContentsMargins(0, 0, 0, 0)
         outer.addStretch()
@@ -118,6 +136,7 @@ class SpinnerWidget(QWidget):
         row.addStretch()
         row.addWidget(self._canvas)
         self._label = QLabel(text)
+        self._label.setStyleSheet(LOADING_LABEL_STYLE)
         if text:
             row.addWidget(self._label)
         row.addStretch()
@@ -125,34 +144,25 @@ class SpinnerWidget(QWidget):
         outer.addLayout(row)
         outer.addStretch()
 
-        # Auto-overlay: track parent geometry via event filter
-        if parent is not None:
-            self.setAutoFillBackground(True)
-            self.setStyleSheet('background: palette(window);')
-            self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
-            parent.installEventFilter(self)
-            self.setGeometry(parent.rect())
-
-    # -- Event filter (overlay geometry tracking) --------------------------
+    # -- Public API --------------------------------------------------------
 
-    def eventFilter(self, obj: object, event: QEvent) -> bool:
-        """Resize to match the parent whenever it resizes."""
-        parent = self.parent()
-        if event.type() == QEvent.Type.Resize and obj is parent and isinstance(parent, QWidget):
-            self.setGeometry(parent.rect())
-        return False
+    @property
+    def running(self) -> bool:
+        """Return ``True`` if the animation is currently active."""
+        return self._timer.isActive()
 
-    # -- Public API --------------------------------------------------------
+    def set_text(self, text: str) -> None:
+        """Update the label text."""
+        self._label.setText(text)
+        self._label.setVisible(bool(text))
 
     def start(self) -> None:
-        """Show the overlay and start the animation."""
-        self.raise_()
-        self.show()
+        """Reset the arc angle, start the animation, and show the widget."""
         self._canvas._angle = 0
         self._timer.start()
+        self.show()
 
     def stop(self) -> None:
-        """Stop the animation, hide, and move below siblings."""
+        """Stop the animation and hide the widget."""
         self._timer.stop()
         self.hide()
-        self.lower()

{synodic_client-0.0.1.dev61 → synodic_client-0.0.1.dev63}/synodic_client/application/screen/tool_update_controller.py

@@ -74,6 +74,16 @@ class ToolUpdateOrchestrator:
         self._tool_task: asyncio.Task[None] | None = None
         self._tool_update_timer: QTimer | None = None
 
+    def shutdown(self) -> None:
+        """Stop timers and cancel in-flight tasks for a clean exit."""
+        if self._tool_update_timer is not None:
+            self._tool_update_timer.stop()
+            self._tool_update_timer = None
+        if self._tool_task is not None and not self._tool_task.done():
+            self._tool_task.cancel()
+            self._tool_task = None
+        logger.info('ToolUpdateOrchestrator shut down')
+
     # -- Timer management --
 
     @staticmethod
@@ -175,6 +185,9 @@ class ToolUpdateOrchestrator:
             if coordinator is not None:
                 coordinator.invalidate()
             self._on_tool_update_finished(result)
+        except asyncio.CancelledError:
+            logger.debug('Tool update cancelled (shutdown)')
+            raise
         except Exception as exc:
             logger.exception('Tool update failed')
             self._on_tool_update_error(str(exc))
@@ -238,6 +251,9 @@ class ToolUpdateOrchestrator:
             if coordinator is not None:
                 coordinator.invalidate()
             self._on_tool_update_finished(result, updating_plugin=signal_key, manual=True)
+        except asyncio.CancelledError:
+            logger.debug('Runtime plugin update cancelled (shutdown)')
+            raise
         except Exception as exc:
             logger.exception('Runtime tool update failed')
             tools_view = self._window.tools_view
@@ -270,6 +286,9 @@ class ToolUpdateOrchestrator:
             if coordinator is not None:
                 coordinator.invalidate()
             self._on_tool_update_finished(result, updating_plugin=plugin_name, manual=True)
+        except asyncio.CancelledError:
+            logger.debug('Single plugin update cancelled (shutdown)')
+            raise
         except Exception as exc:
             logger.exception('Tool update failed')
             tools_view = self._window.tools_view
@@ -326,6 +345,9 @@ class ToolUpdateOrchestrator:
                     updating_package=(plugin_name, package_name),
                     manual=True,
                 )
+            except asyncio.CancelledError:
+                logger.debug('Runtime package update cancelled (shutdown)')
+                raise
             except Exception as exc:
                 logger.exception('Runtime package update failed')
                 tools_view = self._window.tools_view
@@ -348,6 +370,9 @@ class ToolUpdateOrchestrator:
                 updating_package=(plugin_name, package_name),
                 manual=True,
             )
+        except asyncio.CancelledError:
+            logger.debug('Package update cancelled (shutdown)')
+            raise
         except Exception as exc:
             logger.exception('Package update failed')
             tools_view = self._window.tools_view
@@ -382,7 +407,12 @@ class ToolUpdateOrchestrator:
             for pkg_name in result.updated_packages:
                 key = f'{plugin_name}/{pkg_name}' if plugin_name else pkg_name
                 existing[key] = now
-            update_user_config(last_tool_updates=existing)
+            resolved = update_user_config(last_tool_updates=existing)
+            # Refresh the config on the tools view so the next rebuild
+            # picks up the updated timestamps instead of stale data.
+            tools_view_ref = self._window.tools_view
+            if tools_view_ref is not None:
+                tools_view_ref._config = resolved
 
         # Clear updating state on widgets
         tools_view = self._window.tools_view
@@ -465,6 +495,9 @@ class ToolUpdateOrchestrator:
             if coordinator is not None:
                 coordinator.invalidate()
             self._on_package_remove_finished(result, plugin_name, package_name)
+        except asyncio.CancelledError:
+            logger.debug('Package removal cancelled (shutdown)')
+            raise
         except Exception as exc:
             logger.exception('Package removal failed')
             tools_view = self._window.tools_view

{synodic_client-0.0.1.dev61 → synodic_client-0.0.1.dev63}/synodic_client/application/screen/tray.py

@@ -141,6 +141,12 @@ class TrayScreen:
         """
         return any(w.isVisible() for w in QApplication.topLevelWidgets() if isinstance(w, QMainWindow))
 
+    def shutdown(self) -> None:
+        """Stop all timers and cancel in-flight tasks for a clean exit."""
+        self._update_controller.shutdown()
+        self._tool_orchestrator.shutdown()
+        logger.info('TrayScreen shut down')
+
     def _on_settings_changed(self, config: ResolvedConfig) -> None:
         """React to a change made in the settings window."""
         self._config = config

{synodic_client-0.0.1.dev61 → synodic_client-0.0.1.dev63}/synodic_client/application/theme.py

@@ -47,6 +47,7 @@ COPY_BTN_STYLE = (
 # ---------------------------------------------------------------------------
 HEADER_STYLE = 'font-size: 14px; font-weight: bold;'
 MUTED_STYLE = 'color: grey;'
+LOADING_LABEL_STYLE = 'color: grey; font-size: 13px;'
 COMMAND_HEADER_STYLE = 'color: grey; margin-top: 6px;'
 
 # ---------------------------------------------------------------------------

{synodic_client-0.0.1.dev61 → synodic_client-0.0.1.dev63}/synodic_client/application/update_controller.py

@@ -111,6 +111,16 @@ class UpdateController:
         """
         self._is_user_active = predicate
 
+    def shutdown(self) -> None:
+        """Stop timers and cancel in-flight tasks for a clean exit."""
+        if self._auto_update_timer is not None:
+            self._auto_update_timer.stop()
+            self._auto_update_timer = None
+        if self._update_task is not None and not self._update_task.done():
+            self._update_task.cancel()
+            self._update_task = None
+        logger.info('UpdateController shut down')
+
     # ------------------------------------------------------------------
     # Config helpers
     # ------------------------------------------------------------------
@@ -132,7 +142,8 @@ class UpdateController:
     def _persist_check_timestamp(self) -> None:
         """Persist the current time as *last_client_update* and refresh the label."""
         ts = datetime.now(UTC).isoformat()
-        update_user_config(last_client_update=ts)
+        resolved = update_user_config(last_client_update=ts)
+        self._settings_window.update_config(resolved)
         self._settings_window.set_last_checked(ts)
 
     def _report_error(self, message: str, *, silent: bool) -> None:
@@ -249,6 +260,9 @@ class UpdateController:
             result = await check_for_update(self._client)
             self._on_check_finished(result, silent=silent)
             logger.info('[DIAG] Self-update check completed (silent=%s)', silent)
+        except asyncio.CancelledError:
+            logger.debug('Update check cancelled (shutdown)')
+            raise
         except Exception as exc:
             logger.exception('Update check failed')
             self._on_check_error(str(exc), silent=silent)
@@ -310,6 +324,9 @@ class UpdateController:
                 on_progress=self._on_download_progress,
             )
             self._on_download_finished(success, version)
+        except asyncio.CancelledError:
+            logger.debug('Update download cancelled (shutdown)')
+            raise
         except Exception as exc:
             logger.exception('Update download failed')
             self._on_download_error(str(exc))
@@ -329,7 +346,9 @@ class UpdateController:
 
         # Persist the client-update timestamp (actual update downloaded)
         ts = datetime.now(UTC).isoformat()
-        update_user_config(last_client_update=ts)
+        resolved = update_user_config(last_client_update=ts)
+        self._settings_window.update_config(resolved)
+        self._settings_window.set_last_checked(ts)
 
         self._pending_version = version
 

{synodic_client-0.0.1.dev61 → synodic_client-0.0.1.dev63}/synodic_client/application/workers.py

@@ -34,7 +34,11 @@ async def check_for_update(client: Client) -> UpdateInfo | None:
         An ``UpdateInfo`` result, or ``None`` when no updater is initialised.
     """
     loop = asyncio.get_running_loop()
-    return await loop.run_in_executor(None, client.check_for_update)
+    try:
+        return await loop.run_in_executor(None, client.check_for_update)
+    except asyncio.CancelledError:
+        logger.debug('check_for_update cancelled')
+        raise
 
 
 async def download_update(
@@ -61,7 +65,11 @@ async def download_update(
 
         return client.download_update(progress_callback)
 
-    return await loop.run_in_executor(None, _run)
+    try:
+        return await loop.run_in_executor(None, _run)
+    except asyncio.CancelledError:
+        logger.debug('download_update cancelled')
+        raise
 
 
 async def run_tool_updates(
@@ -107,24 +115,28 @@ async def run_tool_updates(
             plugins=plugins,
             include_packages=include_packages,
         )
-        async for event in porringer.sync.execute_stream(
-            params,
-            plugins=discovered_plugins,
-        ):
-            if event.kind == ProgressEventKind.ACTION_COMPLETED and event.result is not None:
-                action_result = event.result
-                if action_result.skipped:
-                    if action_result.skip_reason in {
-                        SkipReason.ALREADY_LATEST,
-                        SkipReason.ALREADY_INSTALLED,
-                    }:
-                        result.already_latest += 1
-                elif action_result.success:
-                    result.updated += 1
-                    if action_result.action.package:
-                        result.updated_packages.add(str(action_result.action.package.name))
-                else:
-                    result.failed += 1
+        try:
+            async for event in porringer.sync.execute_stream(
+                params,
+                plugins=discovered_plugins,
+            ):
+                if event.kind == ProgressEventKind.ACTION_COMPLETED and event.result is not None:
+                    action_result = event.result
+                    if action_result.skipped:
+                        if action_result.skip_reason in {
+                            SkipReason.ALREADY_LATEST,
+                            SkipReason.ALREADY_INSTALLED,
+                        }:
+                            result.already_latest += 1
+                    elif action_result.success:
+                        result.updated += 1
+                        if action_result.action.package:
+                            result.updated_packages.add(str(action_result.action.package.name))
+                    else:
+                        result.failed += 1
+        except asyncio.CancelledError:
+            logger.debug('run_tool_updates cancelled during manifest processing')
+            raise
         result.manifests_processed += 1
     return result
 

synodic_client-0.0.1.dev63/synodic_client/subprocess_patch.py

@@ -0,0 +1,82 @@
+"""Suppress console-window flashes for child processes on Windows.
+
+When the application runs as a windowed executable (``console=False``),
+every subprocess that launches a console program (pip, pipx, uv, winget,
+etc.) would briefly flash a visible console window.  This module patches
+``subprocess.Popen.__init__`` to inject two complementary flags:
+
+* ``CREATE_NO_WINDOW`` in *creationflags* — prevents Windows from
+  allocating a new console for the child process.
+* ``STARTUPINFO`` with ``STARTF_USESHOWWINDOW`` and
+  ``wShowWindow=SW_HIDE`` — tells Windows to pass ``SW_HIDE`` as the
+  initial ``nCmdShow`` to the child, suppressing the brief window flash
+  that some GUI-subsystem tools (e.g. ``winget.exe``) produce even
+  without a console.
+
+Since ``asyncio.create_subprocess_exec`` and all other high-level
+subprocess APIs ultimately call ``subprocess.Popen``, patching
+``Popen.__init__`` is sufficient.
+
+The PyInstaller runtime hook (``rthook_no_console.py``) applies the same
+patch for frozen builds.  This module covers the dev-mode entry point
+where the rthook does not run.
+
+Call :func:`apply` once at process startup — it is idempotent.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from typing import Any
+
+_applied = False
+
+
+def apply() -> None:
+    """Activate the subprocess-suppression patch (idempotent, Windows-only)."""
+    global _applied  # noqa: PLW0603
+    if _applied or sys.platform != "win32":
+        return
+    _applied = True
+
+    _patch_popen()
+
+
+# ------------------------------------------------------------------
+# subprocess.Popen patch
+# ------------------------------------------------------------------
+
+_CREATE_NO_WINDOW: int = 0
+_STARTF_USESHOWWINDOW: int = 0
+_SW_HIDE: int = 0
+
+if sys.platform == "win32":
+    _CREATE_NO_WINDOW = subprocess.CREATE_NO_WINDOW  # 0x0800_0000
+    _STARTF_USESHOWWINDOW = subprocess.STARTF_USESHOWWINDOW
+    _SW_HIDE = 0
+
+
+def _inject_hidden_flags(kwargs: dict[str, Any]) -> None:
+    """Mutate *kwargs* so the child process has no visible window.
+
+    Flags are OR-ed (not replaced) so caller-supplied values are
+    preserved.  An existing ``startupinfo`` object is augmented
+    rather than overwritten.
+    """
+    kwargs["creationflags"] = kwargs.get("creationflags", 0) | _CREATE_NO_WINDOW
+
+    startupinfo = kwargs.get("startupinfo") or subprocess.STARTUPINFO()
+    startupinfo.dwFlags |= _STARTF_USESHOWWINDOW
+    startupinfo.wShowWindow = _SW_HIDE
+    kwargs["startupinfo"] = startupinfo
+
+
+def _patch_popen() -> None:
+    _original_init = subprocess.Popen.__init__
+
+    def _patched_init(self: subprocess.Popen, *args: Any, **kwargs: Any) -> None:  # type: ignore[type-arg]
+        _inject_hidden_flags(kwargs)
+        _original_init(self, *args, **kwargs)
+
+    subprocess.Popen.__init__ = _patched_init  # type: ignore[method-assign]

{synodic_client-0.0.1.dev61 → synodic_client-0.0.1.dev63}/tests/unit/qt/test_settings.py

@@ -404,3 +404,46 @@ class TestCheckForUpdatesButton:
         window.set_checking()
         assert window._check_updates_btn.isEnabled() is False
         assert window._update_status_label.text() == 'Checking\u2026'
+
+
+# ---------------------------------------------------------------------------
+# update_config — silent config refresh
+# ---------------------------------------------------------------------------
+
+
+class TestUpdateConfig:
+    """Verify that update_config refreshes _config without emitting signals."""
+
+    @staticmethod
+    def test_update_config_replaces_internal_config() -> None:
+        """update_config should replace _config with the new snapshot."""
+        window = _make_window(_make_config(last_client_update=None))
+        new_config = _make_config(last_client_update='2026-03-09T12:00:00+00:00')
+
+        window.update_config(new_config)
+
+        assert window._config is new_config
+        assert window._config.last_client_update == '2026-03-09T12:00:00+00:00'
+
+    @staticmethod
+    def test_update_config_does_not_emit_settings_changed() -> None:
+        """update_config must NOT emit settings_changed to avoid circular reinit."""
+        window = _make_window()
+        signal_spy = MagicMock()
+        window.settings_changed.connect(signal_spy)
+
+        window.update_config(_make_config(update_channel='dev'))
+
+        signal_spy.assert_not_called()
+
+    @staticmethod
+    def test_sync_after_update_config_uses_new_timestamp() -> None:
+        """sync_from_config after update_config should display the refreshed timestamp."""
+        window = _make_window(_make_config(last_client_update=None))
+        assert window._last_client_update_label.text() == ''
+
+        new_config = _make_config(last_client_update='2026-03-09T12:00:00+00:00')
+        window.update_config(new_config)
+        window.sync_from_config()
+
+        assert 'Last updated:' in window._last_client_update_label.text()

{synodic_client-0.0.1.dev61 → synodic_client-0.0.1.dev63}/tests/unit/qt/test_update_controller.py

@@ -414,3 +414,57 @@ class TestCheckError:
         ctrl._on_check_error('timeout', silent=True)
 
         assert banner.state.name == 'HIDDEN'
+
+
+# ---------------------------------------------------------------------------
+# Timestamp sync — _persist_check_timestamp updates config
+# ---------------------------------------------------------------------------
+
+
+class TestPersistCheckTimestamp:
+    """Verify _persist_check_timestamp syncs the settings config."""
+
+    @staticmethod
+    def test_persist_updates_settings_config() -> None:
+        """_persist_check_timestamp should call update_config on the settings window."""
+        ctrl, _app, _client, _banner, settings = _make_controller()
+
+        fake_resolved = _make_config(last_client_update='2026-03-09T00:00:00+00:00')
+        with patch(
+            'synodic_client.application.update_controller.update_user_config',
+            return_value=fake_resolved,
+        ):
+            ctrl._persist_check_timestamp()
+
+        settings.update_config.assert_called_once_with(fake_resolved)
+        settings.set_last_checked.assert_called_once()
+
+    @staticmethod
+    def test_on_check_finished_success_syncs_config() -> None:
+        """A successful check should persist timestamp AND sync settings config."""
+        ctrl, _app, _client, _banner, settings = _make_controller()
+        result = UpdateInfo(available=False, current_version=Version('1.0.0'))
+
+        fake_resolved = _make_config(last_client_update='2026-03-09T00:00:00+00:00')
+        with patch(
+            'synodic_client.application.update_controller.update_user_config',
+            return_value=fake_resolved,
+        ):
+            ctrl._on_check_finished(result, silent=True)
+
+        settings.update_config.assert_called_once_with(fake_resolved)
+
+    @staticmethod
+    def test_download_finished_syncs_config_and_label() -> None:
+        """_on_download_finished should sync config and update the label."""
+        ctrl, _app, _client, _banner, settings = _make_controller(auto_apply=False)
+
+        fake_resolved = _make_config(last_client_update='2026-03-09T00:00:00+00:00')
+        with patch(
+            'synodic_client.application.update_controller.update_user_config',
+            return_value=fake_resolved,
+        ):
+            ctrl._on_download_finished(True, '2.0.0')
+
+        settings.update_config.assert_called_once_with(fake_resolved)
+        settings.set_last_checked.assert_called_once()