synodic-client 0.0.1.dev71__tar.gz → 0.0.1.dev72__tar.gz

{synodic_client-0.0.1.dev71 → synodic_client-0.0.1.dev72}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: synodic_client
-Version: 0.0.1.dev71
+Version: 0.0.1.dev72
 Author-Email: Synodic Software <contact@synodic.software>
 License: LGPL-3.0-or-later
 Project-URL: homepage, https://github.com/synodic/synodic-client
@@ -8,7 +8,7 @@ Project-URL: repository, https://github.com/synodic/synodic-client
 Requires-Python: <3.15,>=3.14
 Requires-Dist: pyside6>=6.10.2
 Requires-Dist: packaging>=26.0
-Requires-Dist: porringer>=0.2.1.dev81
+Requires-Dist: porringer>=0.2.1.dev84
 Requires-Dist: qasync>=0.28.0
 Requires-Dist: velopack>=0.0.1444.dev49733
 Requires-Dist: typer>=0.24.1

{synodic_client-0.0.1.dev71 → synodic_client-0.0.1.dev72}/pyproject.toml

@@ -10,12 +10,12 @@ requires-python = ">=3.14, <3.15"
 dependencies = [
     "pyside6>=6.10.2",
     "packaging>=26.0",
-    "porringer>=0.2.1.dev81",
+    "porringer>=0.2.1.dev84",
     "qasync>=0.28.0",
     "velopack>=0.0.1444.dev49733",
     "typer>=0.24.1",
 ]
-version = "0.0.1.dev71"
+version = "0.0.1.dev72"
 
 [project.license]
 text = "LGPL-3.0-or-later"
@@ -35,7 +35,7 @@ build = [
     "pyinstaller>=6.19.0",
 ]
 lint = [
-    "ruff>=0.15.5",
+    "ruff>=0.15.6",
     "pyrefly>=0.56.0",
 ]
 test = [
@@ -62,6 +62,8 @@ ignore = [
     "E111",
     "E114",
     "E117",
+    "PLC0415",
+    "PLR0913",
 ]
 select = [
     "D",
@@ -75,14 +77,6 @@ select = [
     "PT",
 ]
 
-[tool.ruff.lint.per-file-ignores]
-"synodic_client/application/bootstrap.py" = [
-    "E402",
-]
-"synodic_client/cli.py" = [
-    "PLC0415",
-]
-
 [tool.ruff.lint.pydocstyle]
 convention = "google"
 
@@ -108,14 +102,12 @@ allow-prereleases = true
 
 [tool.pdm.scripts]
 analyze = "ruff check"
+dev = "synodic-c --dev"
 format = "ruff format"
 test = "pytest --cov=synodic_client --verbose tests"
 type-check = "pyrefly check"
 serve = "zensical serve"
 
-[tool.pdm.scripts.dev]
-call = "tool.scripts.dev:main"
-
 [tool.pdm.scripts.lint]
 composite = [
     "analyze",

synodic_client-0.0.1.dev72/synodic_client/application/bootstrap.py

@@ -0,0 +1,63 @@
+"""Bootstrap entry point for PyInstaller builds.
+
+Runs the lightweight startup preamble — logging, Velopack hooks, and
+protocol registration — **before** importing heavy modules (PySide6,
+porringer).  Velopack's install/uninstall/update hooks have strict
+timeouts (15–30 s) and must complete before the process is killed.
+
+Import order matters:
+    1. stdlib + config (pure-Python, fast)
+    2. configure_logging() — now Qt-free
+    3. initialize_velopack() — hooks run with logging active
+    4. run_startup_preamble() — protocol, config seed, auto-startup
+    5. import qt.application — PySide6 / porringer loaded here
+"""
+
+import logging
+import sys
+import traceback
+
+
+def bootstrap() -> None:
+    """Execute the ordered bootstrap sequence."""
+    try:
+        from synodic_client.config import set_dev_mode
+        from synodic_client.logging import configure_logging
+        from synodic_client.protocol import extract_uri_from_args
+        from synodic_client.subprocess_patch import apply as _apply_subprocess_patch
+        from synodic_client.updater import initialize_velopack
+    except Exception:
+        # Last-resort crash log when imports fail before logging is configured.
+        import os
+
+        _fallback = os.path.join(os.environ.get('LOCALAPPDATA', '.'), 'Synodic', 'logs', 'bootstrap-crash.log')
+        os.makedirs(os.path.dirname(_fallback), exist_ok=True)
+        with open(_fallback, 'a', encoding='utf-8') as _f:
+            _f.write(traceback.format_exc())
+        raise
+
+    # Parse flags early so logging uses the right filename and level.
+    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)
+
+    logger = logging.getLogger(__name__)
+    logger.info('Bootstrap started (exe=%s, argv=%s)', sys.executable, sys.argv)
+
+    initialize_velopack()
+
+    if not dev_mode:
+        from synodic_client.application.init import run_startup_preamble
+
+        run_startup_preamble(sys.executable)
+
+    # Heavy imports happen here — PySide6, porringer, etc.
+    from synodic_client.application.qt import application
+
+    application(uri=extract_uri_from_args(), dev_mode=dev_mode, debug=debug)
+
+
+bootstrap()

{synodic_client-0.0.1.dev71 → synodic_client-0.0.1.dev72}/synodic_client/application/data.py

@@ -64,6 +64,11 @@ class DataCoordinator:
         """Shortcut to the current ``DiscoveredPlugins`` instance."""
         return self._snapshot.discovered
 
+    @property
+    def is_stale(self) -> bool:
+        """Whether the cached data needs refreshing."""
+        return self._stale
+
     def invalidate(self) -> None:
         """Mark the cached data as stale.
 
@@ -173,14 +178,27 @@ class DataCoordinator:
             if isinstance(env, PluginManager) and env.is_available():
                 managers[env.tool_name()] = env
 
+        # Step 5: collect protocol capabilities for each plugin
+        capabilities: dict[str, frozenset] = {
+            plugin.name: frozenset(discovered.capabilities(plugin.name)) for plugin in plugins
+        }
+
         # Derive the un-validated directory list for callers that only
         # need path + name (e.g. _gather_packages).
         directories = [r.directory for r in validated]
 
+        logger.info(
+            'Discovery complete: %d plugin(s), %d directory(ies), %d plugin manager(s)',
+            len(plugins),
+            len(directories),
+            len(managers),
+        )
+
         return Snapshot(
             plugins=plugins,
             directories=directories,
             validated_directories=validated,
             discovered=discovered,
             plugin_managers=managers,
+            plugin_capabilities=capabilities,
         )

synodic_client-0.0.1.dev72/synodic_client/application/debug.py

@@ -0,0 +1,271 @@
+"""Debug automation interface for agent and developer interaction.
+
+Provides a command handler that serialises application domain state and
+dispatches deterministic actions via the existing controller/service
+layer.  Commands arrive over the :class:`SingleInstance` IPC socket and
+responses are returned as JSON strings.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import json
+import logging
+import sys
+from collections.abc import Callable
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from synodic_client.config import is_dev_mode
+
+if TYPE_CHECKING:
+    from porringer.api import API
+
+    from synodic_client.application.config_store import ConfigStore
+    from synodic_client.application.data import DataCoordinator
+    from synodic_client.application.screen.screen import MainWindow
+    from synodic_client.application.screen.settings import SettingsWindow
+    from synodic_client.application.screen.tool_update_controller import ToolUpdateOrchestrator
+    from synodic_client.application.update_controller import UpdateController
+    from synodic_client.application.update_model import UpdateModel
+    from synodic_client.client import Client
+
+logger = logging.getLogger(__name__)
+
+_ACTIONS: dict[str, str] = {
+    'check_update': 'Trigger a self-update check.',
+    'tool_update': 'Run tool/package updates for all plugins.',
+    'refresh_data': 'Mark cached data as stale (next refresh re-fetches).',
+    'show_main': 'Show and raise the main window.',
+    'show_settings': 'Show the settings window.',
+    'apply_update': 'Apply a downloaded update and restart.',
+    'list_projects': 'List cached project directories with validation status.',
+    'add_project': 'Add a directory to the project cache. Arg: <path>',
+    'remove_project': 'Remove a directory from the project cache. Arg: <path>',
+    'project_status': 'Dump per-action preview status. Arg (optional): <path>',
+    'select_project': 'Select a project in the sidebar. Arg: <path>',
+}
+
+
+@dataclasses.dataclass
+class DebugServices:
+    """Bundle of service references for the debug handler."""
+
+    client: Client
+    porringer: API
+    coordinator: DataCoordinator | None
+    config_store: ConfigStore
+    update_controller: UpdateController
+    update_model: UpdateModel
+    tool_orchestrator: ToolUpdateOrchestrator
+    main_window: MainWindow
+    settings_window: SettingsWindow
+
+
+class DebugHandler:
+    """Routes debug IPC commands to the application service layer."""
+
+    def __init__(self, services: DebugServices) -> None:
+        """Initialize the debug handler with service references."""
+        self._s = services
+
+    def handle(self, command: str) -> str:
+        """Dispatch a debug command and return a JSON response string."""
+        logger.debug('Debug command received: %s', command)
+
+        if command == 'state':
+            return self._handle_state()
+        if command == 'actions':
+            return self._handle_actions()
+        if command.startswith('action:'):
+            remainder = command[len('action:') :]
+            name, _, arg = remainder.partition(':')
+            return self._handle_action(name, arg or None)
+
+        return json.dumps({'error': f'unknown command: {command}'})
+
+    def _handle_state(self) -> str:
+        """Serialise current application domain state."""
+        config = self._s.config_store.config
+        coordinator = self._s.coordinator
+        model = self._s.update_model
+
+        snapshot = coordinator.snapshot if coordinator is not None else None
+        data_stale = coordinator.is_stale if coordinator is not None else None
+
+        state = {
+            'app': {
+                'version': str(self._s.client.version),
+                'dev_mode': is_dev_mode(),
+                'frozen': getattr(sys, 'frozen', False),
+                'platform': sys.platform,
+            },
+            'config': dataclasses.asdict(config),
+            'update': {
+                'phase': model.phase.name,
+                'version': model.version,
+                'error_message': model.error_message,
+            },
+            'data': {
+                'plugin_count': len(snapshot.plugins) if snapshot else 0,
+                'directory_count': len(snapshot.directories) if snapshot else 0,
+                'manager_count': len(snapshot.plugin_managers) if snapshot else 0,
+                'stale': data_stale,
+            },
+            'windows': {
+                'main_visible': self._s.main_window.isVisible(),
+                'settings_visible': self._s.settings_window.isVisible(),
+            },
+        }
+        return json.dumps(state, default=str)
+
+    @staticmethod
+    def _handle_actions() -> str:
+        """Return a list of available action names with descriptions."""
+        return json.dumps({'actions': _ACTIONS})
+
+    def _handle_action(self, name: str, arg: str | None = None) -> str:
+        """Dispatch a named action to the appropriate controller."""
+        if name not in _ACTIONS:
+            return json.dumps({'error': f'unknown action: {name}', 'available': list(_ACTIONS)})
+
+        # Actions that return their own JSON response
+        _project_dispatch: dict[str, Callable[[str | None], str]] = {
+            'list_projects': lambda _: self._handle_list_projects(),
+            'add_project': self._handle_add_project,
+            'remove_project': self._handle_remove_project,
+            'project_status': self._handle_project_status,
+            'select_project': self._handle_select_project,
+        }
+
+        if name in _project_dispatch:
+            return _project_dispatch[name](arg)
+
+        # Fire-and-forget actions
+        if name == 'check_update':
+            self._s.update_controller.check_now(silent=False)
+        elif name == 'tool_update':
+            self._s.tool_orchestrator.on_tool_update()
+        elif name == 'refresh_data':
+            if self._s.coordinator is not None:
+                self._s.coordinator.invalidate()
+        elif name == 'show_main':
+            self._s.main_window.show()
+            self._s.main_window.raise_()
+            self._s.main_window.activateWindow()
+        elif name == 'show_settings':
+            self._s.settings_window.show()
+        elif name == 'apply_update':
+            self._s.update_controller.request_apply()
+
+        return json.dumps({'ok': True, 'action': name})
+
+    # -- Project management actions ----------------------------------------
+
+    def _handle_list_projects(self) -> str:
+        """List all cached project directories with validation status."""
+        from synodic_client.operations.project import list_projects
+
+        projects = list_projects(self._s.porringer)
+        return json.dumps({'projects': [dataclasses.asdict(p) for p in projects]})
+
+    def _handle_add_project(self, arg: str | None) -> str:
+        """Add a directory to the porringer cache."""
+        if not arg:
+            return json.dumps({'error': 'add_project requires a path argument'})
+
+        from synodic_client.operations.project import add_project
+
+        try:
+            add_project(self._s.porringer, arg)
+        except (NotADirectoryError, ValueError) as exc:
+            return json.dumps({'error': str(exc)})
+
+        if self._s.coordinator is not None:
+            self._s.coordinator.invalidate()
+
+        projects_view = self._s.main_window._projects_view
+        if projects_view is not None:
+            projects_view.refresh()
+
+        return json.dumps({'ok': True, 'action': 'add_project', 'path': arg})
+
+    def _handle_remove_project(self, arg: str | None) -> str:
+        """Remove a directory from the porringer cache."""
+        if not arg:
+            return json.dumps({'error': 'remove_project requires a path argument'})
+
+        from synodic_client.operations.project import remove_project
+
+        remove_project(self._s.porringer, arg)
+
+        if self._s.coordinator is not None:
+            self._s.coordinator.invalidate()
+
+        projects_view = self._s.main_window._projects_view
+        if projects_view is not None:
+            projects_view.refresh()
+
+        return json.dumps({'ok': True, 'action': 'remove_project', 'path': arg})
+
+    def _handle_project_status(self, arg: str | None) -> str:
+        """Dump per-action preview status for a project."""
+        projects_view = self._s.main_window._projects_view
+        if projects_view is None:
+            return json.dumps({'error': 'projects view not initialised — run show_main first'})
+
+        if arg:
+            target = Path(arg)
+        else:
+            target = projects_view._sidebar.selected_path
+            if target is None:
+                return json.dumps({'error': 'no project selected and no path argument provided'})
+
+        widget = projects_view._widgets.get(target)
+        if widget is None:
+            available = [str(p) for p in projects_view._widgets]
+            return json.dumps({'error': f'no widget for path: {target}', 'available_paths': available})
+
+        model = widget.model
+        actions = []
+        for state in model.action_states:
+            act = state.action
+            entry: dict[str, object] = {
+                'description': act.description,
+                'kind': act.kind.name if act.kind else None,
+                'status': state.status,
+            }
+            if act.package is not None:
+                entry['package'] = act.package.name
+                if act.package.constraint:
+                    entry['constraint'] = act.package.constraint
+            if act.installer:
+                entry['installer'] = act.installer
+            actions.append(entry)
+
+        needed = sum(1 for s in model.action_states if s.status == 'Needed')
+        satisfied = sum(1 for s in model.action_states if '\u2713' in s.status)
+        pending = sum(1 for s in model.action_states if s.status == 'Pending')
+        upgradable = len(model.upgradable_keys)
+
+        return json.dumps({
+            'path': str(target),
+            'phase': model.phase.name,
+            'action_count': len(model.action_states),
+            'checked_count': model.checked_count,
+            'actions': actions,
+            'summary': {
+                'needed': needed,
+                'satisfied': satisfied,
+                'pending': pending,
+                'upgradable': upgradable,
+            },
+        })
+
+    def _handle_select_project(self, arg: str | None) -> str:
+        """Select a project in the sidebar."""
+        if not arg:
+            return json.dumps({'error': 'select_project requires a path argument'})
+
+        self._s.main_window._navigate_to_project(arg)
+        return json.dumps({'ok': True, 'action': 'select_project', 'path': arg})

{synodic_client-0.0.1.dev71 → synodic_client-0.0.1.dev72}/synodic_client/application/instance.py

@@ -3,9 +3,13 @@
 Ensures only one instance of Synodic Client runs at a time.  When a second
 instance is launched (e.g. by clicking a ``synodic://`` URI), it sends the
 URI to the already-running instance and exits.
+
+Debug commands (prefixed with ``debug:``) receive a JSON response on the
+same connection before it is closed.
 """
 
 import logging
+from collections.abc import Callable
 
 from PySide6.QtCore import QByteArray, QObject, Signal
 from PySide6.QtNetwork import QLocalServer, QLocalSocket
@@ -18,6 +22,13 @@ logger = logging.getLogger(__name__)
 _SERVER_NAME = 'synodic-client'
 _SERVER_NAME_DEV = 'synodic-client-dev'
 
+_DEBUG_PREFIX = 'debug:'
+
+
+def _decode(raw: bytes | bytearray | memoryview) -> str:
+    """Decode raw socket data to a UTF-8 string."""
+    return bytes(raw).decode('utf-8')
+
 
 def _server_name() -> str:
     """Return the server name, namespaced for dev mode."""
@@ -41,6 +52,16 @@ class SingleInstance(QObject):
         """
         super().__init__(parent)
         self._server: QLocalServer | None = None
+        self._debug_handler: Callable[[str], str] | None = None
+
+    def set_debug_handler(self, handler: Callable[[str], str]) -> None:
+        """Register a handler for ``debug:`` IPC commands.
+
+        Args:
+            handler: Callable that accepts a command string (without the
+                ``debug:`` prefix) and returns a JSON response string.
+        """
+        self._debug_handler = handler
 
     @staticmethod
     def try_send_to_existing(message: str) -> bool:
@@ -65,6 +86,34 @@ class SingleInstance(QObject):
 
         return False
 
+    @staticmethod
+    def send_debug_command(command: str) -> str:
+        """Send a debug command to the running instance and return its response.
+
+        Args:
+            command: The debug command (without the ``debug:`` prefix).
+
+        Returns:
+            The JSON response string from the running instance, or an
+            error JSON string if the connection failed.
+        """
+        socket = QLocalSocket()
+        socket.connectToServer(_server_name())
+
+        if not socket.waitForConnected(SOCKET_TIMEOUT_MS):
+            return '{"error": "No running instance found"}'
+
+        socket.write(QByteArray(f'{_DEBUG_PREFIX}{command}'.encode()))
+        socket.waitForBytesWritten(SOCKET_TIMEOUT_MS)
+
+        if not socket.waitForReadyRead(SOCKET_TIMEOUT_MS):
+            socket.disconnectFromServer()
+            return '{"error": "Timed out waiting for response"}'
+
+        raw = socket.readAll().data()
+        socket.disconnectFromServer()
+        return _decode(raw)
+
     def start_server(self) -> bool:
         """Start the local socket server to listen for incoming messages.
 
@@ -98,8 +147,17 @@ class SingleInstance(QObject):
 
         if socket.waitForReadyRead(SOCKET_TIMEOUT_MS):
             raw = socket.readAll().data()
-            data = raw.decode('utf-8') if isinstance(raw, (bytes, bytearray)) else str(raw)
-            if data:
+            data = _decode(raw)
+
+            if data.startswith(_DEBUG_PREFIX):
+                command = data[len(_DEBUG_PREFIX) :]
+                if self._debug_handler is not None:
+                    response = self._debug_handler(command)
+                else:
+                    response = '{"error": "debug handler not registered"}'
+                socket.write(QByteArray(response.encode('utf-8')))
+                socket.waitForBytesWritten(SOCKET_TIMEOUT_MS)
+            elif data:
                 logger.info('Received message from another instance: %s', data)
                 self.uri_received.emit(data)
             else: