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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: synodic_client
-Version: 0.0.1.dev42
+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.dev42 → 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.dev42"
+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.dev42 → 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.dev42 → 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.dev42 → synodic_client-0.0.1.dev44}/synodic_client/application/screen/settings.py

@@ -27,6 +27,7 @@ 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, UPDATE_STATUS_CHECKING_STYLE
@@ -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)
 

synodic_client-0.0.1.dev44/synodic_client/startup.py

@@ -0,0 +1,156 @@
+r"""Windows auto-startup registration via the registry.
+
+Manages a value under ``HKCU\Software\Microsoft\Windows\CurrentVersion\Run``
+so the application launches automatically when the user logs in.
+
+Windows also maintains a parallel
+``HKCU\...\Explorer\StartupApproved\Run`` key where each entry is a
+12-byte ``REG_BINARY`` value.  Byte 0 controls the enabled state:
+
+* ``0x02`` — **enabled** (Windows will honour the ``Run`` entry).
+* ``0x03`` — **disabled** (entry hidden from startup by Task Manager /
+  Settings → Startup Apps).
+
+When registering or removing auto-startup we synchronise *both* keys
+so that a user toggling the setting in-app overrides any prior
+Task-Manager disable.
+
+Other platforms are stubbed with no-op implementations, matching the
+approach in :mod:`synodic_client.protocol`.
+"""
+
+import logging
+import sys
+
+logger = logging.getLogger(__name__)
+
+STARTUP_VALUE_NAME = 'SynodicClient'
+"""Registry value name used in the ``Run`` key."""
+
+RUN_KEY_PATH = r'Software\Microsoft\Windows\CurrentVersion\Run'
+
+STARTUP_APPROVED_KEY_PATH = r'Software\Microsoft\Windows\CurrentVersion\Explorer\StartupApproved\Run'
+"""Registry key where Windows stores per-entry enabled/disabled flags."""
+
+# 12-byte REG_BINARY payloads for the StartupApproved value.
+APPROVED_ENABLED: bytes = b'\x02' + b'\x00' * 11
+"""Enabled payload for the ``StartupApproved\\Run`` registry value."""
+
+_APPROVED_DISABLED_BYTE: int = 0x03
+
+
+if sys.platform == 'win32':
+    import winreg
+
+    def register_startup(exe_path: str) -> None:
+        r"""Register the application to start automatically on login.
+
+        Writes a value to ``HKCU\Software\Microsoft\Windows\CurrentVersion\Run``
+        pointing to *exe_path* **and** writes an *enabled* flag to the
+        corresponding ``StartupApproved\Run`` key so that a previous
+        Task-Manager disable is overridden.
+
+        Calling this repeatedly is safe and will update the path (useful
+        after Velopack relocates the executable).
+
+        Args:
+            exe_path: Absolute path to the application executable.
+        """
+        try:
+            with winreg.OpenKey(winreg.HKEY_CURRENT_USER, RUN_KEY_PATH, 0, winreg.KEY_SET_VALUE) as key:
+                winreg.SetValueEx(key, STARTUP_VALUE_NAME, 0, winreg.REG_SZ, f'"{exe_path}"')
+            logger.info('Registered auto-startup -> %s', exe_path)
+        except OSError:
+            logger.exception('Failed to register auto-startup')
+
+        # Ensure Windows considers the entry enabled even if the user
+        # previously disabled it via Task Manager.
+        try:
+            with winreg.CreateKey(winreg.HKEY_CURRENT_USER, STARTUP_APPROVED_KEY_PATH) as key:
+                winreg.SetValueEx(key, STARTUP_VALUE_NAME, 0, winreg.REG_BINARY, APPROVED_ENABLED)
+            logger.debug('Wrote StartupApproved enabled flag')
+        except OSError:
+            logger.exception('Failed to write StartupApproved enabled flag')
+
+    def remove_startup() -> None:
+        """Remove the auto-startup registration.
+
+        Removes both the ``Run`` value and any ``StartupApproved`` flag.
+        Silently succeeds if the values do not exist.
+        """
+        try:
+            with winreg.OpenKey(winreg.HKEY_CURRENT_USER, RUN_KEY_PATH, 0, winreg.KEY_SET_VALUE) as key:
+                winreg.DeleteValue(key, STARTUP_VALUE_NAME)
+            logger.info('Removed auto-startup registration')
+        except FileNotFoundError:
+            logger.debug('Auto-startup registration not found, nothing to remove')
+        except OSError:
+            logger.exception('Failed to remove auto-startup registration')
+
+        try:
+            with winreg.OpenKey(winreg.HKEY_CURRENT_USER, STARTUP_APPROVED_KEY_PATH, 0, winreg.KEY_SET_VALUE) as key:
+                winreg.DeleteValue(key, STARTUP_VALUE_NAME)
+            logger.debug('Removed StartupApproved flag')
+        except FileNotFoundError:
+            logger.debug('StartupApproved flag not found, nothing to remove')
+        except OSError:
+            logger.exception('Failed to remove StartupApproved flag')
+
+    def is_startup_registered() -> bool:
+        r"""Check whether auto-startup is both present **and** enabled.
+
+        Returns ``True`` only when the ``Run`` value exists and Windows
+        has not disabled it via ``StartupApproved\Run``.
+
+        Returns:
+            ``True`` if the application will auto-start on login.
+        """
+        # 1. Check the Run key exists at all.
+        try:
+            with winreg.OpenKey(winreg.HKEY_CURRENT_USER, RUN_KEY_PATH, 0, winreg.KEY_QUERY_VALUE) as key:
+                winreg.QueryValueEx(key, STARTUP_VALUE_NAME)
+        except FileNotFoundError:
+            return False
+        except OSError:
+            logger.exception('Failed to query auto-startup registration')
+            return False
+
+        # 2. Check the StartupApproved override.  If the key/value is
+        #    absent the entry is considered enabled (Windows only writes
+        #    this key when the user explicitly disables/enables via Task
+        #    Manager or Settings).
+        try:
+            with winreg.OpenKey(winreg.HKEY_CURRENT_USER, STARTUP_APPROVED_KEY_PATH, 0, winreg.KEY_QUERY_VALUE) as key:
+                data, _ = winreg.QueryValueEx(key, STARTUP_VALUE_NAME)
+                if isinstance(data, bytes) and len(data) >= 1 and data[0] == _APPROVED_DISABLED_BYTE:
+                    logger.debug('Auto-startup is disabled via StartupApproved')
+                    return False
+        except FileNotFoundError:
+            # No approval override → treat as enabled.
+            pass
+        except OSError:
+            logger.exception('Failed to query StartupApproved flag')
+
+        return True
+
+else:
+
+    def register_startup(exe_path: str) -> None:
+        """Register auto-startup (no-op on non-Windows).
+
+        Args:
+            exe_path: Absolute path to the application executable.
+        """
+        logger.warning('Auto-startup registration is only supported on Windows (current: %s)', sys.platform)
+
+    def remove_startup() -> None:
+        """Remove auto-startup registration (no-op on non-Windows)."""
+        logger.warning('Auto-startup removal is only supported on Windows (current: %s)', sys.platform)
+
+    def is_startup_registered() -> bool:
+        """Check auto-startup registration (always ``False`` on non-Windows).
+
+        Returns:
+            ``False``.
+        """
+        return False

{synodic_client-0.0.1.dev42 → synodic_client-0.0.1.dev44}/synodic_client/updater.py

@@ -113,10 +113,10 @@ class UpdateInfo:
 
 
 # Default interval for automatic update checks (minutes)
-DEFAULT_AUTO_UPDATE_INTERVAL_MINUTES = 30
+DEFAULT_AUTO_UPDATE_INTERVAL_MINUTES = 5
 
 # Default interval for tool update checks (minutes)
-DEFAULT_TOOL_UPDATE_INTERVAL_MINUTES = 20
+DEFAULT_TOOL_UPDATE_INTERVAL_MINUTES = 5
 
 
 @dataclass
@@ -433,6 +433,9 @@ def _on_before_uninstall(version: str) -> None:
         logger.warning('Auto-startup removal failed during uninstall hook', exc_info=True)
 
 
+_velopack_initialized = False
+
+
 def initialize_velopack() -> None:
     """Initialize Velopack at application startup.
 
@@ -440,13 +443,18 @@ def initialize_velopack() -> None:
     before any UI is shown. Velopack may need to perform cleanup or apply
     pending updates.
 
-    Protocol registration happens on every app launch (see ``qt.application``).
+    Safe to call more than once — subsequent calls are no-ops.
 
     .. note::
 
         The SDK's callback hooks only accept ``PyCFunction`` — add an
         uninstall hook here when that is fixed upstream.
     """
+    global _velopack_initialized  # noqa: PLW0603
+    if _velopack_initialized:
+        return
+    _velopack_initialized = True
+
     logger.info('Initializing Velopack (exe=%s)', sys.executable)
     try:
         app = velopack.App()

synodic_client-0.0.1.dev44/tests/unit/test_init.py

@@ -0,0 +1,103 @@
+"""Tests for the shared startup preamble."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+import synodic_client.application.init as init_mod
+from synodic_client.application.init import run_startup_preamble
+
+_MODULE = 'synodic_client.application.init'
+
+
+@pytest.fixture(autouse=True)
+def _reset_preamble_guard() -> None:
+    """Reset the idempotency guard before each test."""
+    init_mod._preamble_done = False
+
+
+class TestRunStartupPreamble:
+    """Verify that run_startup_preamble orchestrates the correct calls."""
+
+    @staticmethod
+    def test_calls_seed_and_register_protocol() -> None:
+        """Seed, protocol registration, and config resolution are invoked."""
+        with (
+            patch(f'{_MODULE}.seed_user_config_from_build') as mock_seed,
+            patch(f'{_MODULE}.register_protocol') as mock_proto,
+            patch(f'{_MODULE}.resolve_config') as mock_resolve,
+            patch(f'{_MODULE}.register_startup'),
+            patch(f'{_MODULE}.remove_startup'),
+        ):
+            mock_resolve.return_value = MagicMock(auto_start=True)
+            run_startup_preamble(r'C:\app\synodic.exe')
+
+        mock_seed.assert_called_once()
+        mock_proto.assert_called_once_with(r'C:\app\synodic.exe')
+        mock_resolve.assert_called_once()
+
+    @staticmethod
+    def test_registers_startup_when_auto_start_true() -> None:
+        """register_startup is called when auto_start is True."""
+        with (
+            patch(f'{_MODULE}.seed_user_config_from_build'),
+            patch(f'{_MODULE}.register_protocol'),
+            patch(f'{_MODULE}.resolve_config') as mock_resolve,
+            patch(f'{_MODULE}.register_startup') as mock_register,
+            patch(f'{_MODULE}.remove_startup') as mock_remove,
+        ):
+            mock_resolve.return_value = MagicMock(auto_start=True)
+            run_startup_preamble(r'C:\app\synodic.exe')
+
+        mock_register.assert_called_once_with(r'C:\app\synodic.exe')
+        mock_remove.assert_not_called()
+
+    @staticmethod
+    def test_removes_startup_when_auto_start_false() -> None:
+        """remove_startup is called when auto_start is False."""
+        with (
+            patch(f'{_MODULE}.seed_user_config_from_build'),
+            patch(f'{_MODULE}.register_protocol'),
+            patch(f'{_MODULE}.resolve_config') as mock_resolve,
+            patch(f'{_MODULE}.register_startup') as mock_register,
+            patch(f'{_MODULE}.remove_startup') as mock_remove,
+        ):
+            mock_resolve.return_value = MagicMock(auto_start=False)
+            run_startup_preamble(r'C:\app\synodic.exe')
+
+        mock_remove.assert_called_once()
+        mock_register.assert_not_called()
+
+    @staticmethod
+    def test_defaults_exe_path_to_sys_executable() -> None:
+        """When exe_path is None, sys.executable is used."""
+        with (
+            patch(f'{_MODULE}.seed_user_config_from_build'),
+            patch(f'{_MODULE}.register_protocol') as mock_proto,
+            patch(f'{_MODULE}.resolve_config') as mock_resolve,
+            patch(f'{_MODULE}.register_startup') as mock_register,
+            patch(f'{_MODULE}.remove_startup'),
+            patch(f'{_MODULE}.sys') as mock_sys,
+        ):
+            mock_sys.executable = r'C:\Python\python.exe'
+            mock_resolve.return_value = MagicMock(auto_start=True)
+            run_startup_preamble()
+
+        mock_proto.assert_called_once_with(r'C:\Python\python.exe')
+        mock_register.assert_called_once_with(r'C:\Python\python.exe')
+
+    @staticmethod
+    def test_idempotent_on_second_call() -> None:
+        """A second call is a no-op; the preamble runs only once."""
+        with (
+            patch(f'{_MODULE}.seed_user_config_from_build') as mock_seed,
+            patch(f'{_MODULE}.register_protocol'),
+            patch(f'{_MODULE}.resolve_config') as mock_resolve,
+            patch(f'{_MODULE}.register_startup'),
+            patch(f'{_MODULE}.remove_startup'),
+        ):
+            mock_resolve.return_value = MagicMock(auto_start=True)
+            run_startup_preamble(r'C:\app\synodic.exe')
+            run_startup_preamble(r'C:\app\synodic.exe')
+
+        mock_seed.assert_called_once()

{synodic_client-0.0.1.dev42 → synodic_client-0.0.1.dev44}/tests/unit/test_updater.py

@@ -6,6 +6,7 @@ import pytest
 import velopack
 from packaging.version import Version
 
+import synodic_client.updater as updater_mod
 from synodic_client.updater import (
     GITHUB_REPO_URL,
     UpdateChannel,
@@ -416,6 +417,12 @@ class TestUpdaterApplyUpdate:
 class TestInitializeVelopack:
     """Tests for initialize_velopack function."""
 
+    @staticmethod
+    @pytest.fixture(autouse=True)
+    def _reset_velopack_guard() -> None:
+        """Reset the idempotency guard before each test."""
+        updater_mod._velopack_initialized = False
+
     @staticmethod
     def test_initialize_success() -> None:
         """Verify initialize_velopack calls App().run()."""
@@ -434,6 +441,15 @@ class TestInitializeVelopack:
             # Should not raise
             initialize_velopack()
 
+    @staticmethod
+    def test_idempotent_on_second_call() -> None:
+        """A second call is a no-op; Velopack is initialised only once."""
+        mock_app = MagicMock(spec=velopack.App)
+        with patch('synodic_client.updater.velopack.App', return_value=mock_app) as mock_app_class:
+            initialize_velopack()
+            initialize_velopack()
+            mock_app_class.assert_called_once()
+
 
 class TestGetVelopackManager:
     """Tests for _get_velopack_manager install detection via the SDK."""

synodic_client-0.0.1.dev44/tests/unit/windows/test_startup.py

@@ -0,0 +1,240 @@
+"""Tests for Windows auto-startup registration."""
+
+import winreg
+from unittest.mock import MagicMock, patch
+
+from synodic_client.startup import (
+    APPROVED_ENABLED,
+    RUN_KEY_PATH,
+    STARTUP_APPROVED_KEY_PATH,
+    STARTUP_VALUE_NAME,
+    is_startup_registered,
+    register_startup,
+    remove_startup,
+)
+
+
+class TestRegisterStartup:
+    """Tests for register_startup."""
+
+    @staticmethod
+    def test_writes_registry_value() -> None:
+        """Verify correct registry value is written on Windows."""
+        mock_key = MagicMock()
+        mock_key.__enter__ = MagicMock(return_value=mock_key)
+        mock_key.__exit__ = MagicMock(return_value=False)
+
+        with (
+            patch.object(winreg, 'OpenKey', return_value=mock_key) as mock_open,
+            patch.object(winreg, 'SetValueEx') as mock_set,
+            patch.object(winreg, 'CreateKey', return_value=mock_key),
+        ):
+            register_startup(r'C:\Program Files\Synodic\synodic.exe')
+
+        mock_open.assert_called_once_with(
+            winreg.HKEY_CURRENT_USER,
+            RUN_KEY_PATH,
+            0,
+            winreg.KEY_SET_VALUE,
+        )
+        mock_set.assert_any_call(
+            mock_key,
+            STARTUP_VALUE_NAME,
+            0,
+            winreg.REG_SZ,
+            r'"C:\Program Files\Synodic\synodic.exe"',
+        )
+
+    @staticmethod
+    def test_writes_startup_approved_enabled() -> None:
+        """Verify the StartupApproved enabled flag is written."""
+        mock_run_key = MagicMock()
+        mock_run_key.__enter__ = MagicMock(return_value=mock_run_key)
+        mock_run_key.__exit__ = MagicMock(return_value=False)
+
+        mock_approved_key = MagicMock()
+        mock_approved_key.__enter__ = MagicMock(return_value=mock_approved_key)
+        mock_approved_key.__exit__ = MagicMock(return_value=False)
+
+        with (
+            patch.object(winreg, 'OpenKey', return_value=mock_run_key),
+            patch.object(winreg, 'SetValueEx') as mock_set,
+            patch.object(winreg, 'CreateKey', return_value=mock_approved_key) as mock_create,
+        ):
+            register_startup(r'C:\synodic.exe')
+
+        mock_create.assert_called_once_with(
+            winreg.HKEY_CURRENT_USER,
+            STARTUP_APPROVED_KEY_PATH,
+        )
+        mock_set.assert_any_call(
+            mock_approved_key,
+            STARTUP_VALUE_NAME,
+            0,
+            winreg.REG_BINARY,
+            APPROVED_ENABLED,
+        )
+
+    @staticmethod
+    def test_noop_on_non_windows() -> None:
+        """Verify register_startup is a no-op on non-Windows platforms."""
+        with patch('synodic_client.startup.sys') as mock_sys:
+            mock_sys.platform = 'linux'
+            register_startup('/usr/bin/synodic')
+
+
+class TestRemoveStartup:
+    """Tests for remove_startup."""
+
+    @staticmethod
+    def test_deletes_registry_value() -> None:
+        """Verify the startup value is deleted."""
+        mock_key = MagicMock()
+        mock_key.__enter__ = MagicMock(return_value=mock_key)
+        mock_key.__exit__ = MagicMock(return_value=False)
+
+        with (
+            patch.object(winreg, 'OpenKey', return_value=mock_key),
+            patch.object(winreg, 'DeleteValue') as mock_delete,
+        ):
+            remove_startup()
+
+        mock_delete.assert_any_call(mock_key, STARTUP_VALUE_NAME)
+
+    @staticmethod
+    def test_clears_startup_approved() -> None:
+        """Verify the StartupApproved flag is also deleted."""
+        mock_run_key = MagicMock()
+        mock_run_key.__enter__ = MagicMock(return_value=mock_run_key)
+        mock_run_key.__exit__ = MagicMock(return_value=False)
+
+        mock_approved_key = MagicMock()
+        mock_approved_key.__enter__ = MagicMock(return_value=mock_approved_key)
+        mock_approved_key.__exit__ = MagicMock(return_value=False)
+
+        def _open_key_side_effect(_root: int, path: str, _reserved: int, _access: int) -> MagicMock:
+            if 'Explorer' in path:
+                return mock_approved_key
+            return mock_run_key
+
+        with (
+            patch.object(winreg, 'OpenKey', side_effect=_open_key_side_effect),
+            patch.object(winreg, 'DeleteValue') as mock_delete,
+        ):
+            remove_startup()
+
+        # Both the Run and StartupApproved values should be deleted
+        expected_delete_count = 2
+        assert mock_delete.call_count == expected_delete_count
+        mock_delete.assert_any_call(mock_run_key, STARTUP_VALUE_NAME)
+        mock_delete.assert_any_call(mock_approved_key, STARTUP_VALUE_NAME)
+
+    @staticmethod
+    def test_handles_missing_value_gracefully() -> None:
+        """Verify no error when startup value doesn't exist."""
+        mock_key = MagicMock()
+        mock_key.__enter__ = MagicMock(return_value=mock_key)
+        mock_key.__exit__ = MagicMock(return_value=False)
+
+        with (
+            patch.object(winreg, 'OpenKey', return_value=mock_key),
+            patch.object(winreg, 'DeleteValue', side_effect=FileNotFoundError),
+        ):
+            # Should not raise
+            remove_startup()
+
+    @staticmethod
+    def test_noop_on_non_windows() -> None:
+        """Verify remove_startup is a no-op on non-Windows platforms."""
+        with patch('synodic_client.startup.sys') as mock_sys:
+            mock_sys.platform = 'linux'
+            remove_startup()
+
+
+class TestIsStartupRegistered:
+    """Tests for is_startup_registered."""
+
+    @staticmethod
+    def test_returns_true_when_present() -> None:
+        """Verify True when the value exists and no approval override."""
+        mock_key = MagicMock()
+        mock_key.__enter__ = MagicMock(return_value=mock_key)
+        mock_key.__exit__ = MagicMock(return_value=False)
+
+        def _open_key_side_effect(_root: int, path: str, _reserved: int, _access: int) -> MagicMock:
+            return mock_key
+
+        def _query_side_effect(key: MagicMock, name: str) -> tuple[object, int]:
+            # Run key exists; StartupApproved key raises FileNotFoundError
+            # (no override → treated as enabled)
+            raise FileNotFoundError
+
+        with (
+            patch.object(winreg, 'OpenKey', side_effect=_open_key_side_effect),
+            patch.object(
+                winreg,
+                'QueryValueEx',
+                side_effect=[
+                    (r'"C:\synodic.exe"', winreg.REG_SZ),  # Run key query
+                    FileNotFoundError,  # StartupApproved query
+                ],
+            ),
+        ):
+            assert is_startup_registered() is True
+
+    @staticmethod
+    def test_returns_true_when_startup_approved_enabled() -> None:
+        """Verify True when the StartupApproved byte is 0x02 (enabled)."""
+        mock_key = MagicMock()
+        mock_key.__enter__ = MagicMock(return_value=mock_key)
+        mock_key.__exit__ = MagicMock(return_value=False)
+
+        enabled_data = b'\x02' + b'\x00' * 11
+
+        with (
+            patch.object(winreg, 'OpenKey', return_value=mock_key),
+            patch.object(
+                winreg,
+                'QueryValueEx',
+                side_effect=[
+                    (r'"C:\synodic.exe"', winreg.REG_SZ),  # Run key query
+                    (enabled_data, winreg.REG_BINARY),  # StartupApproved query
+                ],
+            ),
+        ):
+            assert is_startup_registered() is True
+
+    @staticmethod
+    def test_returns_false_when_startup_approved_disabled() -> None:
+        """Verify False when the StartupApproved byte is 0x03 (disabled)."""
+        mock_key = MagicMock()
+        mock_key.__enter__ = MagicMock(return_value=mock_key)
+        mock_key.__exit__ = MagicMock(return_value=False)
+
+        disabled_data = b'\x03' + b'\x00' * 11
+
+        with (
+            patch.object(winreg, 'OpenKey', return_value=mock_key),
+            patch.object(
+                winreg,
+                'QueryValueEx',
+                side_effect=[
+                    (r'"C:\synodic.exe"', winreg.REG_SZ),  # Run key query
+                    (disabled_data, winreg.REG_BINARY),  # StartupApproved query
+                ],
+            ),
+        ):
+            assert is_startup_registered() is False
+
+    @staticmethod
+    def test_returns_false_when_missing() -> None:
+        """Verify False when the value does not exist."""
+        mock_key = MagicMock()
+        mock_key.__enter__ = MagicMock(return_value=mock_key)
+        mock_key.__exit__ = MagicMock(return_value=False)
+
+        with (
+            patch.object(winreg, 'OpenKey', return_value=mock_key),
+            patch.object(winreg, 'QueryValueEx', side_effect=FileNotFoundError),
+        ):
+            assert is_startup_registered() is False

synodic_client-0.0.1.dev42/synodic_client/_version.py

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

synodic_client-0.0.1.dev42/synodic_client/startup.py

@@ -1,91 +0,0 @@
-r"""Windows auto-startup registration via the registry.
-
-Manages a value under ``HKCU\Software\Microsoft\Windows\CurrentVersion\Run``
-so the application launches automatically when the user logs in.
-
-Other platforms are stubbed with no-op implementations, matching the
-approach in :mod:`synodic_client.protocol`.
-"""
-
-import logging
-import sys
-
-logger = logging.getLogger(__name__)
-
-STARTUP_VALUE_NAME = 'SynodicClient'
-"""Registry value name used in the ``Run`` key."""
-
-RUN_KEY_PATH = r'Software\Microsoft\Windows\CurrentVersion\Run'
-
-
-if sys.platform == 'win32':
-    import winreg
-
-    def register_startup(exe_path: str) -> None:
-        r"""Register the application to start automatically on login.
-
-        Writes a value to ``HKCU\Software\Microsoft\Windows\CurrentVersion\Run``
-        pointing to *exe_path*.  Calling this repeatedly is safe and will
-        update the path (useful after Velopack relocates the executable).
-
-        Args:
-            exe_path: Absolute path to the application executable.
-        """
-        try:
-            with winreg.OpenKey(winreg.HKEY_CURRENT_USER, RUN_KEY_PATH, 0, winreg.KEY_SET_VALUE) as key:
-                winreg.SetValueEx(key, STARTUP_VALUE_NAME, 0, winreg.REG_SZ, f'"{exe_path}"')
-            logger.info('Registered auto-startup -> %s', exe_path)
-        except OSError:
-            logger.exception('Failed to register auto-startup')
-
-    def remove_startup() -> None:
-        """Remove the auto-startup registration.
-
-        Silently succeeds if the value does not exist.
-        """
-        try:
-            with winreg.OpenKey(winreg.HKEY_CURRENT_USER, RUN_KEY_PATH, 0, winreg.KEY_SET_VALUE) as key:
-                winreg.DeleteValue(key, STARTUP_VALUE_NAME)
-            logger.info('Removed auto-startup registration')
-        except FileNotFoundError:
-            logger.debug('Auto-startup registration not found, nothing to remove')
-        except OSError:
-            logger.exception('Failed to remove auto-startup registration')
-
-    def is_startup_registered() -> bool:
-        """Check whether the auto-startup value is currently present.
-
-        Returns:
-            ``True`` if the ``Run`` key contains the startup value.
-        """
-        try:
-            with winreg.OpenKey(winreg.HKEY_CURRENT_USER, RUN_KEY_PATH, 0, winreg.KEY_QUERY_VALUE) as key:
-                winreg.QueryValueEx(key, STARTUP_VALUE_NAME)
-                return True
-        except FileNotFoundError:
-            return False
-        except OSError:
-            logger.exception('Failed to query auto-startup registration')
-            return False
-
-else:
-
-    def register_startup(exe_path: str) -> None:
-        """Register auto-startup (no-op on non-Windows).
-
-        Args:
-            exe_path: Absolute path to the application executable.
-        """
-        logger.warning('Auto-startup registration is only supported on Windows (current: %s)', sys.platform)
-
-    def remove_startup() -> None:
-        """Remove auto-startup registration (no-op on non-Windows)."""
-        logger.warning('Auto-startup removal is only supported on Windows (current: %s)', sys.platform)
-
-    def is_startup_registered() -> bool:
-        """Check auto-startup registration (always ``False`` on non-Windows).
-
-        Returns:
-            ``False``.
-        """
-        return False

synodic_client-0.0.1.dev42/tests/unit/windows/test_startup.py

@@ -1,121 +0,0 @@
-"""Tests for Windows auto-startup registration."""
-
-import winreg
-from unittest.mock import MagicMock, patch
-
-from synodic_client.startup import (
-    RUN_KEY_PATH,
-    STARTUP_VALUE_NAME,
-    is_startup_registered,
-    register_startup,
-    remove_startup,
-)
-
-
-class TestRegisterStartup:
-    """Tests for register_startup."""
-
-    @staticmethod
-    def test_writes_registry_value() -> None:
-        """Verify correct registry value is written on Windows."""
-        mock_key = MagicMock()
-        mock_key.__enter__ = MagicMock(return_value=mock_key)
-        mock_key.__exit__ = MagicMock(return_value=False)
-
-        with (
-            patch.object(winreg, 'OpenKey', return_value=mock_key) as mock_open,
-            patch.object(winreg, 'SetValueEx') as mock_set,
-        ):
-            register_startup(r'C:\Program Files\Synodic\synodic.exe')
-
-        mock_open.assert_called_once_with(
-            winreg.HKEY_CURRENT_USER,
-            RUN_KEY_PATH,
-            0,
-            winreg.KEY_SET_VALUE,
-        )
-        mock_set.assert_called_once_with(
-            mock_key,
-            STARTUP_VALUE_NAME,
-            0,
-            winreg.REG_SZ,
-            r'"C:\Program Files\Synodic\synodic.exe"',
-        )
-
-    @staticmethod
-    def test_noop_on_non_windows() -> None:
-        """Verify register_startup is a no-op on non-Windows platforms."""
-        with patch('synodic_client.startup.sys') as mock_sys:
-            mock_sys.platform = 'linux'
-            register_startup('/usr/bin/synodic')
-
-
-class TestRemoveStartup:
-    """Tests for remove_startup."""
-
-    @staticmethod
-    def test_deletes_registry_value() -> None:
-        """Verify the startup value is deleted."""
-        mock_key = MagicMock()
-        mock_key.__enter__ = MagicMock(return_value=mock_key)
-        mock_key.__exit__ = MagicMock(return_value=False)
-
-        with (
-            patch.object(winreg, 'OpenKey', return_value=mock_key),
-            patch.object(winreg, 'DeleteValue') as mock_delete,
-        ):
-            remove_startup()
-
-        mock_delete.assert_called_once_with(mock_key, STARTUP_VALUE_NAME)
-
-    @staticmethod
-    def test_handles_missing_value_gracefully() -> None:
-        """Verify no error when startup value doesn't exist."""
-        mock_key = MagicMock()
-        mock_key.__enter__ = MagicMock(return_value=mock_key)
-        mock_key.__exit__ = MagicMock(return_value=False)
-
-        with (
-            patch.object(winreg, 'OpenKey', return_value=mock_key),
-            patch.object(winreg, 'DeleteValue', side_effect=FileNotFoundError),
-        ):
-            # Should not raise
-            remove_startup()
-
-    @staticmethod
-    def test_noop_on_non_windows() -> None:
-        """Verify remove_startup is a no-op on non-Windows platforms."""
-        with patch('synodic_client.startup.sys') as mock_sys:
-            mock_sys.platform = 'linux'
-            remove_startup()
-
-
-class TestIsStartupRegistered:
-    """Tests for is_startup_registered."""
-
-    @staticmethod
-    def test_returns_true_when_present() -> None:
-        """Verify True when the value exists."""
-        mock_key = MagicMock()
-        mock_key.__enter__ = MagicMock(return_value=mock_key)
-        mock_key.__exit__ = MagicMock(return_value=False)
-
-        with (
-            patch.object(winreg, 'OpenKey', return_value=mock_key),
-            patch.object(winreg, 'QueryValueEx', return_value=(r'"C:\synodic.exe"', winreg.REG_SZ)),
-        ):
-            assert is_startup_registered() is True
-
-    @staticmethod
-    def test_returns_false_when_missing() -> None:
-        """Verify False when the value does not exist."""
-        mock_key = MagicMock()
-        mock_key.__enter__ = MagicMock(return_value=mock_key)
-        mock_key.__exit__ = MagicMock(return_value=False)
-
-        with (
-            patch.object(winreg, 'OpenKey', return_value=mock_key),
-            patch.object(winreg, 'QueryValueEx', side_effect=FileNotFoundError),
-        ):
-            assert is_startup_registered() is False
-            assert is_startup_registered() is False