synodic-client 0.0.1.dev74__tar.gz → 0.0.1.dev75__tar.gz

{synodic_client-0.0.1.dev74 → synodic_client-0.0.1.dev75}/PKG-INFO

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

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

{synodic_client-0.0.1.dev74 → synodic_client-0.0.1.dev75}/synodic_client/application/debug.py

@@ -17,6 +17,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 from synodic_client.config import is_dev_mode
+from synodic_client.operations.schema import DEBUG_ACTIONS
 
 if TYPE_CHECKING:
     from porringer.api import API
@@ -32,19 +33,7 @@ if TYPE_CHECKING:
 
 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>',
-}
+_ACTIONS = DEBUG_ACTIONS
 
 
 @dataclasses.dataclass
@@ -164,49 +153,39 @@ class DebugHandler:
 
     def _handle_list_projects(self) -> str:
         """List all cached project directories with validation status."""
-        from synodic_client.operations.project import list_projects
+        from synodic_client.operations.project import run_project_action
 
-        projects = list_projects(self._s.porringer)
-        return json.dumps({'projects': [dataclasses.asdict(p) for p in projects]})
+        return json.dumps(run_project_action('list_projects', None, self._s.porringer))
 
     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
+        from synodic_client.operations.project import run_project_action
 
-        try:
-            add_project(self._s.porringer, arg)
-        except (NotADirectoryError, ValueError) as exc:
-            return json.dumps({'error': str(exc)})
+        result = run_project_action('add_project', arg, self._s.porringer)
 
-        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()
+        if 'error' not in result:
+            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})
+        return json.dumps(result)
 
     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 run_project_action
 
-        from synodic_client.operations.project import remove_project
+        result = run_project_action('remove_project', arg, self._s.porringer)
 
-        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()
+        if 'error' not in result:
+            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})
+        return json.dumps(result)
 
     def _handle_project_status(self, arg: str | None) -> str:
         """Dump per-action preview status for a project."""
@@ -243,9 +222,11 @@ class DebugHandler:
                 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')
+        from synodic_client.operations.schema import classify_status
+
+        needed = sum(1 for s in model.action_states if classify_status(s.status) == 'needed')
+        satisfied = sum(1 for s in model.action_states if classify_status(s.status) == 'satisfied')
+        pending = sum(1 for s in model.action_states if classify_status(s.status) == 'pending')
         upgradable = len(model.upgradable_keys)
 
         return json.dumps({

{synodic_client-0.0.1.dev74 → synodic_client-0.0.1.dev75}/synodic_client/application/qt.py

@@ -13,7 +13,6 @@ from collections.abc import Callable
 
 import qasync
 from porringer.api import API
-from porringer.schema import LocalConfiguration
 from PySide6.QtCore import QEvent, QObject, Qt, QTimer
 from PySide6.QtWidgets import QApplication, QWidget
 
@@ -29,12 +28,9 @@ 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, log_path, set_debug_level
+from synodic_client.operations.bootstrap import init_services
 from synodic_client.protocol import extract_uri_from_args
-from synodic_client.resolution import (
-    ResolvedConfig,
-    resolve_config,
-    resolve_update_config,
-)
+from synodic_client.resolution import ResolvedConfig
 from synodic_client.subprocess_patch import apply as _apply_subprocess_patch
 from synodic_client.updater import initialize_velopack
 
@@ -42,27 +38,14 @@ from synodic_client.updater import initialize_velopack
 def _init_services(logger: logging.Logger) -> tuple[Client, API, ResolvedConfig]:
     """Create and configure core services.
 
+    Delegates to :func:`~synodic_client.operations.bootstrap.init_services`
+    and adds GUI-specific debug logging.
+
     Returns:
         A (Client, porringer API, resolved config) tuple.
     """
-    config = resolve_config()
-    client = Client()
-
-    local_config = LocalConfiguration()
-    porringer = API(local_config)
-
-    update_config = resolve_update_config(config)
-    client.initialize_updater(update_config)
+    client, porringer, config = init_services()
 
-    cached_dirs = porringer.cache.list_directories()
-
-    logger.info(
-        'Synodic Client v%s started (channel: %s, source: %s, cached_projects: %d)',
-        client.version,
-        update_config.channel.name,
-        update_config.repo_url,
-        len(cached_dirs),
-    )
     logger.debug(
         'Resolved config: update_source=%s update_channel=%s auto_update=%dm tool_update=%dm '
         'auto_apply=%s auto_start=%s debug_logging=%s prerelease_packages=%s plugin_auto_update=%s',

{synodic_client-0.0.1.dev74 → synodic_client-0.0.1.dev75}/synodic_client/application/screen/__init__.py

@@ -9,9 +9,19 @@ from __future__ import annotations
 import re
 from datetime import UTC, datetime
 
-from porringer.schema import SetupAction, SetupActionResult, SkipReason
+from porringer.schema import SetupAction, SetupActionResult
 from porringer.schema.plugin import PluginKind
 
+from synodic_client.operations.schema import (
+    SKIP_REASON_LABELS as SKIP_REASON_LABELS,
+)
+from synodic_client.operations.schema import (
+    resolve_action_status as resolve_action_status,
+)
+from synodic_client.operations.schema import (
+    skip_reason_label as skip_reason_label,
+)
+
 _SECONDS_PER_MINUTE = 60
 _MINUTES_PER_HOUR = 60
 _HOURS_PER_DAY = 24
@@ -48,22 +58,6 @@ def plugin_kind_group_label(kind: PluginKind) -> str:
     return PLUGIN_KIND_GROUP_LABELS.get(kind, kind.name.replace('_', ' ').title())
 
 
-SKIP_REASON_LABELS: dict[SkipReason, str] = {
-    SkipReason.ALREADY_INSTALLED: 'Already installed',
-    SkipReason.NOT_INSTALLED: 'Not installed',
-    SkipReason.ALREADY_LATEST: 'Already latest',
-    SkipReason.NO_PROJECT_DIRECTORY: 'No project directory',
-    SkipReason.UPDATE_AVAILABLE: 'Update available',
-}
-
-
-def skip_reason_label(reason: SkipReason | None) -> str:
-    """Return a human-readable label for a skip reason."""
-    if reason is None:
-        return 'Skipped'
-    return SKIP_REASON_LABELS.get(reason, reason.name.replace('_', ' ').capitalize())
-
-
 def format_cli_command(
     action: SetupAction,
     *,

{synodic_client-0.0.1.dev74 → synodic_client-0.0.1.dev75}/synodic_client/application/screen/action_card.py

@@ -14,7 +14,7 @@ from __future__ import annotations
 import logging
 
 from porringer.backend.command.core.action_builder import PHASE_ORDER
-from porringer.schema import SetupAction, SetupActionResult, SkipReason
+from porringer.schema import SetupAction, SetupActionResult
 from porringer.schema.plugin import PluginKind
 from PySide6.QtCore import Qt, QTimer, Signal
 from PySide6.QtGui import QColor
@@ -443,56 +443,47 @@ class ActionCard(QFrame):
     # Public API — dry-run check result
     # ------------------------------------------------------------------
 
-    def set_check_result(self, result: SetupActionResult) -> None:
+    def set_check_result(self, result: SetupActionResult, status: str) -> None:
         """Update the card with a dry-run check result.
 
-        Handles these cases:
-
-        * **Skipped (update available)** — amber "Update available" badge.
-        * **Skipped (other)** — muted satisfied badge.
-        * **Failed** — red "Failed" badge with diagnostic tooltip.
-        * **Bare command** (kind=None, success=True) — keeps "Pending".
-        * **Project sync** (kind=PROJECT, success=True) — "Ready".
-        * **Needed** — default blue badge.
+        The *status* string is pre-resolved by the operations layer via
+        :func:`resolve_action_status`.  This method maps it to the
+        appropriate style and updates the version / tooltip columns.
 
         Args:
             result: The action check result from the preview worker.
+            status: Pre-resolved human-readable status label.
         """
         if self._is_skeleton:
             return
 
         self._stop_spinner()
 
-        if result.skipped and result.skip_reason == SkipReason.UPDATE_AVAILABLE:
-            label = skip_reason_label(result.skip_reason)
-            self._status_label.setText(label)
-            self._status_label.setStyleSheet(ACTION_CARD_STATUS_UPDATE)
-        elif result.skipped:
-            label = '\u2713 ' + skip_reason_label(result.skip_reason)
-            self._status_label.setText(label)
-            self._status_label.setStyleSheet(ACTION_CARD_STATUS_SATISFIED)
-        elif not result.success:
-            label = 'Failed'
-            self._status_label.setText(label)
-            self._status_label.setStyleSheet(ACTION_CARD_STATUS_FAILED)
+        # Status-to-style mapping
+        _STATUS_STYLES: dict[str, str] = {
+            'Update available': ACTION_CARD_STATUS_UPDATE,
+            'Failed': ACTION_CARD_STATUS_FAILED,
+            'Pending': ACTION_CARD_STATUS_PENDING,
+            'Ready': ACTION_CARD_STATUS_SATISFIED,
+            'Needed': ACTION_CARD_STATUS_NEEDED,
+        }
+
+        style = _STATUS_STYLES.get(status, ACTION_CARD_STATUS_SATISFIED)
+        display = status
+
+        # Satisfied (skipped) statuses get a checkmark prefix
+        if result.skipped and status not in _STATUS_STYLES:
+            display = f'\u2713 {status}'
+
+        if not result.success and status == 'Failed':
             logger.warning(
                 'Dry-run check failed for %s: %s',
                 self._action.description if self._action else '(unknown)',
                 result.message or 'unknown error',
             )
-        elif self._action is not None and self._action.kind is None:
-            # Bare command — porringer returns success=True; keep Pending.
-            label = 'Pending'
-            self._status_label.setText(label)
-            self._status_label.setStyleSheet(ACTION_CARD_STATUS_PENDING)
-        elif self._action is not None and self._action.kind == PluginKind.PROJECT:
-            label = 'Ready'
-            self._status_label.setText(label)
-            self._status_label.setStyleSheet(ACTION_CARD_STATUS_SATISFIED)
-        else:
-            label = 'Needed'
-            self._status_label.setText(label)
-            self._status_label.setStyleSheet(ACTION_CARD_STATUS_NEEDED)
+
+        self._status_label.setText(display)
+        self._status_label.setStyleSheet(style)
 
         # Surface diagnostic detail (e.g. SCM URL mismatch) as a tooltip
         if result.message:

{synodic_client-0.0.1.dev74 → synodic_client-0.0.1.dev75}/synodic_client/application/screen/install.py

@@ -27,7 +27,6 @@ from porringer.schema import (
     SubActionProgress,
     SyncStrategy,
 )
-from porringer.schema.plugin import PluginKind
 from PySide6.QtCore import Qt, QTimer, Signal
 from PySide6.QtGui import QShowEvent
 from PySide6.QtWidgets import (
@@ -45,7 +44,6 @@ from PySide6.QtWidgets import (
 )
 
 from synodic_client.application.package_state import PackageStateStore
-from synodic_client.application.screen import skip_reason_label
 from synodic_client.application.screen.action_card import ActionCardList
 from synodic_client.application.screen.card import CardFrame
 from synodic_client.application.screen.install_workers import run_install, run_preview
@@ -615,28 +613,13 @@ class SetupPreviewWidget(QWidget):
         if preview.metadata:
             self.metadata_ready.emit(preview)
 
-    def _on_action_checked(self, row: int, result: SetupActionResult) -> None:
+    def _on_action_checked(self, row: int, result: SetupActionResult, status: str) -> None:
         """Update the model and action card with a dry-run result."""
         m = self._model
-        if result.skipped and result.skip_reason == SkipReason.UPDATE_AVAILABLE:
-            label = skip_reason_label(result.skip_reason)
-            if 0 <= row < len(m.action_states):
-                m.upgradable_keys.add(m.action_states[row].action)
-        elif result.skipped:
-            label = skip_reason_label(result.skip_reason)
-        elif not result.success:
-            label = 'Failed'
-        else:
-            # Bare commands (kind=None) and PROJECT actions always return
-            # success=True from porringer's dry_run_action.  Don't
-            # overwrite their initial status to "Needed".
-            action = m.action_states[row].action if 0 <= row < len(m.action_states) else None
-            if action is not None and action.kind is None:
-                label = 'Pending'
-            elif action is not None and action.kind == PluginKind.PROJECT:
-                label = 'Ready'
-            else:
-                label = 'Needed'
+        label = status
+
+        if result.skipped and result.skip_reason == SkipReason.UPDATE_AVAILABLE and 0 <= row < len(m.action_states):
+            m.upgradable_keys.add(m.action_states[row].action)
 
         if 0 <= row < len(m.action_states):
             m.action_states[row].status = label
@@ -657,7 +640,7 @@ class SetupPreviewWidget(QWidget):
             action = m.preview.actions[row]
             card = self._card_list.get_card(action)
             if card is not None:
-                card.set_check_result(result)
+                card.set_check_result(result, status)
 
             # Record in shared store so ToolsView can reflect the update
             if self._package_store is not None and action.installer and action.package:

synodic_client-0.0.1.dev75/synodic_client/application/screen/install_workers.py

@@ -0,0 +1,152 @@
+"""Async worker coroutines for install and preview operations.
+
+Contains ``run_install``, ``run_preview``, and supporting helpers that
+stream porringer events back to the GUI via callbacks.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from pathlib import Path
+
+from porringer.api import API
+from porringer.backend.command.core.discovery import DiscoveredPlugins
+from porringer.schema import (
+    ActionCompletedEvent,
+    ActionStartedEvent,
+    ManifestLoadedEvent,
+    SetupAction,
+    SetupActionResult,
+    SetupParameters,
+    SetupResults,
+    SubActionProgressEvent,
+)
+
+from synodic_client.application.screen.schema import (
+    InstallCallbacks,
+    InstallConfig,
+    PreviewCallbacks,
+    PreviewConfig,
+)
+from synodic_client.application.uri import safe_rmtree
+from synodic_client.operations.install import preview_manifest_stream
+from synodic_client.operations.schema import (
+    PreviewActionChecked,
+    PreviewManifestParsed,
+    PreviewPluginsQueried,
+    PreviewReady,
+)
+
+logger = logging.getLogger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# run_install — execute setup actions via porringer
+# ---------------------------------------------------------------------------
+
+
+async def run_install(
+    porringer: API,
+    manifest_path: Path,
+    config: InstallConfig | None = None,
+    callbacks: InstallCallbacks | None = None,
+    *,
+    plugins: DiscoveredPlugins | None = None,
+) -> SetupResults:
+    """Execute setup actions via porringer and stream progress.
+
+    Runs on the caller's event loop (typically the qasync main-thread
+    loop).  Callbacks are invoked between ``await`` points so the GUI
+    stays responsive without cross-thread signalling.
+    """
+    cfg = config or InstallConfig()
+    cb = callbacks or InstallCallbacks()
+    params = SetupParameters(
+        paths=[manifest_path],
+        project_directory=cfg.project_directory,
+        strategy=cfg.strategy,
+        prerelease_packages=cfg.prerelease_packages,
+    )
+    actions: list[SetupAction] = []
+    collected: list[SetupActionResult] = []
+    manifest_result: SetupResults | None = None
+
+    async for event in porringer.sync.execute_stream(params, plugins=plugins):
+        if isinstance(event, ManifestLoadedEvent):
+            manifest_result = event.manifest
+            actions = list(event.manifest.actions)
+
+        elif isinstance(event, ActionStartedEvent) and cb.on_action_started is not None:
+            cb.on_action_started(event.action)
+
+        elif isinstance(event, SubActionProgressEvent) and cb.on_sub_progress is not None:
+            cb.on_sub_progress(event.action, event.sub_action)
+
+        elif isinstance(event, ActionCompletedEvent):
+            collected.append(event.result)
+            if cb.on_progress is not None:
+                cb.on_progress(event.action, event.result)
+
+    return SetupResults(
+        actions=actions,
+        results=collected,
+        manifest_path=manifest_result.manifest_path if manifest_result else None,
+        metadata=manifest_result.metadata if manifest_result else None,
+    )
+
+
+# ---------------------------------------------------------------------------
+# run_preview — dry-run preview of a manifest
+# ---------------------------------------------------------------------------
+
+
+async def run_preview(
+    porringer: API,
+    url: str,
+    *,
+    config: PreviewConfig | None = None,
+    callbacks: PreviewCallbacks | None = None,
+    plugins: DiscoveredPlugins | None = None,
+) -> None:
+    """Download a manifest and perform a dry-run preview.
+
+    Delegates to :func:`preview_manifest_stream` in the operations
+    layer, then routes each :data:`PreviewEvent` to the appropriate
+    callback.
+    """
+    logger.info('run_preview starting for: %s', url)
+    cb = callbacks or PreviewCallbacks()
+    cfg = config or PreviewConfig()
+    temp_dir: str | None = None
+    try:
+        async for event in preview_manifest_stream(
+            porringer,
+            url,
+            project_directory=cfg.project_directory,
+            prerelease_packages=cfg.prerelease_packages,
+            discovered=plugins,
+        ):
+            if isinstance(event, PreviewManifestParsed):
+                temp_dir = event.temp_dir or None
+                if cb.on_manifest_parsed is not None:
+                    cb.on_manifest_parsed(event.manifest, event.manifest_path, event.temp_dir)
+
+            elif isinstance(event, PreviewPluginsQueried) and cb.on_plugins_queried is not None:
+                cb.on_plugins_queried(event.availability, event.capabilities)
+
+            elif isinstance(event, PreviewReady):
+                if cb.on_preview_ready is not None:
+                    cb.on_preview_ready(event.manifest, event.manifest_path, event.temp_dir)
+
+            elif isinstance(event, PreviewActionChecked) and cb.on_action_checked is not None:
+                cb.on_action_checked(event.index, event.result, event.status)
+
+    except asyncio.CancelledError:
+        if temp_dir:
+            safe_rmtree(temp_dir)
+        raise
+    except Exception:
+        if temp_dir:
+            safe_rmtree(temp_dir)
+        raise

{synodic_client-0.0.1.dev74 → synodic_client-0.0.1.dev75}/synodic_client/application/screen/schema.py

@@ -323,8 +323,8 @@ class PreviewCallbacks:
     on_preview_ready: Callable[[SetupResults, str, str], None] | None = None
     """``(SetupResults, manifest_path, temp_dir)`` — CLI commands resolved."""
 
-    on_action_checked: Callable[[int, SetupActionResult], None] | None = None
-    """``(row_index, SetupActionResult)`` — per-action dry-run result."""
+    on_action_checked: Callable[[int, SetupActionResult, str], None] | None = None
+    """``(row_index, SetupActionResult, status)`` — per-action dry-run result with resolved status."""
 
 
 @dataclass(frozen=True, slots=True)
@@ -333,10 +333,3 @@ class PreviewConfig:
 
     project_directory: Path | None = None
     prerelease_packages: set[str] | None = None
-
-
-@dataclass(slots=True)
-class _DispatchState:
-    """Mutable accumulator for :func:`_dispatch_preview_event`."""
-
-    got_parsed: bool = False

{synodic_client-0.0.1.dev74 → synodic_client-0.0.1.dev75}/synodic_client/application/screen/screen.py

@@ -11,13 +11,11 @@ from porringer.backend.builder import Builder
 from porringer.core.plugin_schema.plugin_manager import PluginManager
 from porringer.core.plugin_schema.project_environment import ProjectEnvironment
 from porringer.schema import (
-    ActionCompletedEvent,
     ManifestDirectory,
     ManifestParsedEvent,
     PluginInfo,
     SetupAction,
     SetupParameters,
-    SkipReason,
     SyncStrategy,
 )
 from porringer.schema.plugin import PluginKind, RuntimePackageResult
@@ -1045,14 +1043,10 @@ class ToolsView(QWidget):
         """
         actions: list[SetupAction] = []
         try:
+            from synodic_client.operations.project import find_manifest
+
             path = Path(directory.path)
-            filenames = self._porringer.sync.manifest_filenames()
-            manifest_path: Path | None = None
-            for fname in filenames:
-                candidate = path / fname
-                if candidate.exists():
-                    manifest_path = candidate
-                    break
+            manifest_path = find_manifest(self._porringer, path)
 
             if manifest_path is None:
                 return actions
@@ -1177,19 +1171,10 @@ class ToolsView(QWidget):
         if self._coordinator is not None:
             return await self._check_updates_via_coordinator()
 
-        # Legacy per-directory fallback
-        available: dict[str, dict[str, str]] = {}
-
-        async def _check_one(directory: ManifestDirectory) -> None:
-            partial = await self._check_directory_updates(directory)
-            for installer, packages in partial.items():
-                available.setdefault(installer, {}).update(packages)
-
-        async with asyncio.TaskGroup() as tg:
-            for d in directories:
-                tg.create_task(_check_one(d))
+        # Legacy per-directory fallback — delegate to the operations layer
+        from synodic_client.operations.tool import check_tool_updates
 
-        return available
+        return await check_tool_updates(self._porringer, directories)
 
     async def _check_updates_via_coordinator(self) -> dict[str, dict[str, str]]:
         """Use the coordinator's ``check_updates`` for efficient detection.
@@ -1225,48 +1210,6 @@ class ToolsView(QWidget):
 
         return available
 
-    async def _check_directory_updates(
-        self,
-        directory: ManifestDirectory,
-    ) -> dict[str, dict[str, str]]:
-        """Check a single directory for available updates (dry-run).
-
-        Legacy fallback used when no coordinator is available.
-        """
-        available: dict[str, dict[str, str]] = {}
-        try:
-            path = Path(directory.path)
-            filenames = self._porringer.sync.manifest_filenames()
-            manifest_path: Path | None = None
-            for fname in filenames:
-                candidate = path / fname
-                if candidate.exists():
-                    manifest_path = candidate
-                    break
-
-            if manifest_path is None:
-                return available
-
-            params = SetupParameters(
-                paths=[str(manifest_path)],
-                dry_run=True,
-                project_directory=path,
-            )
-            async for event in self._porringer.sync.execute_stream(params):
-                if isinstance(event, ActionCompletedEvent) and event.result.skip_reason == SkipReason.UPDATE_AVAILABLE:
-                    action = event.result.action
-                    if action.installer and action.package:
-                        pkg_name = str(action.package.name)
-                        latest = event.result.available_version or ''
-                        available.setdefault(action.installer, {})[pkg_name] = latest
-        except Exception:
-            logger.debug(
-                'Could not detect updates for %s',
-                directory.path,
-                exc_info=True,
-            )
-        return available
-
     async def _deferred_update_check(self) -> None:
         """Run update detection in the background, then patch the widget tree.