synodic-client 0.0.1.dev80__tar.gz → 0.0.1.dev81__tar.gz

{synodic_client-0.0.1.dev80 → synodic_client-0.0.1.dev81}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: synodic_client
-Version: 0.0.1.dev80
+Version: 0.0.1.dev81
 Author-Email: Synodic Software <contact@synodic.software>
 License: LGPL-3.0-or-later
 Project-URL: homepage, https://github.com/synodic/synodic-client
@@ -8,9 +8,9 @@ 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.dev86
+Requires-Dist: porringer>=0.2.1.dev88
 Requires-Dist: qasync>=0.28.0
-Requires-Dist: velopack>=0.0.1521.dev61717
+Requires-Dist: velopack>=0.0.1535.dev45597
 Requires-Dist: typer>=0.24.1
 Description-Content-Type: text/markdown
 

{synodic_client-0.0.1.dev80 → synodic_client-0.0.1.dev81}/pyproject.toml

@@ -10,12 +10,12 @@ requires-python = ">=3.14, <3.15"
 dependencies = [
     "pyside6>=6.10.2",
     "packaging>=26.0",
-    "porringer>=0.2.1.dev86",
+    "porringer>=0.2.1.dev88",
     "qasync>=0.28.0",
-    "velopack>=0.0.1521.dev61717",
+    "velopack>=0.0.1535.dev45597",
     "typer>=0.24.1",
 ]
-version = "0.0.1.dev80"
+version = "0.0.1.dev81"
 
 [project.license]
 text = "LGPL-3.0-or-later"

{synodic_client-0.0.1.dev80 → synodic_client-0.0.1.dev81}/synodic_client/application/screen/action_card.py

@@ -40,6 +40,7 @@ from synodic_client.application.screen.spinner import SpinnerCanvas
 from synodic_client.application.theme import (
     ACTION_CARD_COMMAND_STYLE,
     ACTION_CARD_DESC_STYLE,
+    ACTION_CARD_DISTRO_BADGE_STYLE,
     ACTION_CARD_EXECUTING_STYLE,
     ACTION_CARD_PACKAGE_STYLE,
     ACTION_CARD_SKELETON_BAR_STYLE,
@@ -64,6 +65,7 @@ from synodic_client.application.theme import (
     COPY_BTN_STYLE,
     COPY_FEEDBACK_MS,
     COPY_ICON,
+    WSL_DISTRO_HEADER_STYLE,
 )
 
 logger = logging.getLogger(__name__)
@@ -224,7 +226,7 @@ class ActionCard(QFrame):
         outer.addWidget(self._build_command_row())
 
     def _build_top_row(self) -> QHBoxLayout:
-        """Build the top row: type badge | package name ... version | status/spinner | prerelease."""
+        """Build the top row: type badge | [distro badge] | package name ... version | status/spinner | prerelease."""
         top = QHBoxLayout()
         top.setSpacing(8)
 
@@ -232,6 +234,11 @@ class ActionCard(QFrame):
         self._type_badge.setStyleSheet(ACTION_CARD_TYPE_BADGE_STYLE)
         top.addWidget(self._type_badge)
 
+        self._distro_badge = QLabel()
+        self._distro_badge.setStyleSheet(ACTION_CARD_DISTRO_BADGE_STYLE)
+        self._distro_badge.hide()
+        top.addWidget(self._distro_badge)
+
         self._package_label = QLabel()
         self._package_label.setStyleSheet(ACTION_CARD_PACKAGE_STYLE)
         self._package_label.setTextInteractionFlags(
@@ -360,6 +367,12 @@ class ActionCard(QFrame):
         if action.installer:
             self._type_badge.setToolTip(f'Plugin: {action.installer}')
 
+        if action.distro:
+            self._distro_badge.setText(action.distro)
+            self._distro_badge.show()
+        else:
+            self._distro_badge.hide()
+
         package_text = str(action.package) if action.package else action.description
         self._package_label.setText(package_text)
 
@@ -635,6 +648,32 @@ class ActionCard(QFrame):
         super().mousePressEvent(event)
 
 
+# ---------------------------------------------------------------------------
+# _DistroGroupHeader — section divider between native and WSL action groups
+# ---------------------------------------------------------------------------
+
+
+class _DistroGroupHeader(QLabel):
+    """Thin section divider between native and per-distro action groups.
+
+    Shows ``HOST`` for the native group or ``WSL — <distro>`` for each
+    WSL2 distro group.  Only inserted when both native and WSL actions
+    are present.
+    """
+
+    def __init__(self, distro_name: str | None, parent: QWidget | None = None) -> None:
+        """Initialise the header.
+
+        Args:
+            distro_name: WSL distro name, or ``None`` for the native group.
+            parent: Optional parent widget.
+        """
+        label = 'HOST' if distro_name is None else f'WSL \u2014 {distro_name}'.upper()
+        super().__init__(label, parent)
+        self.setObjectName('wslDistroHeader')
+        self.setStyleSheet(WSL_DISTRO_HEADER_STYLE)
+
+
 # ---------------------------------------------------------------------------
 # ActionCardList — card container
 # ---------------------------------------------------------------------------
@@ -667,6 +706,7 @@ class ActionCardList(QWidget):
         self._layout.addStretch()
 
         self._cards: list[ActionCard] = []
+        self._group_headers: list[QLabel] = []
         self._action_map: dict[SetupAction, ActionCard] = {}
         self._index_map: dict[int, ActionCard] = {}
 
@@ -701,25 +741,58 @@ class ActionCardList(QWidget):
     ) -> None:
         """Replace skeleton cards with real action cards.
 
+        When actions include WSL distro entries (``action.distro is not
+        None``), the list is split into groups.  Native host actions
+        appear first under a ``HOST`` section header; each WSL distro
+        gets its own ``WSL — <distro>`` section header below.  If all
+        actions are native, no headers are inserted.
+
         Args:
             actions: The setup actions to display.
             plugin_installed: Plugin name → installed mapping.
             prerelease_overrides: Package names with user pre-release overrides.
         """
         self.clear()
-        sorted_actions = sorted(actions, key=action_sort_key)
-        for act in sorted_actions:
-            card = ActionCard(self)
-            card.populate(
-                act,
-                plugin_installed=plugin_installed,
-                prerelease_overrides=prerelease_overrides,
-            )
-            card.prerelease_toggled.connect(self.prerelease_toggled.emit)
-            card.navigate_to_tool.connect(self.navigate_to_tool.emit)
-            self._layout.insertWidget(self._layout.count() - 1, card)
-            self._cards.append(card)
-            self._action_map[act] = card
+
+        # Partition into native and per-distro groups.
+        native_actions: list[SetupAction] = []
+        distro_actions: dict[str, list[SetupAction]] = {}
+        for act in actions:
+            if act.distro is None:
+                native_actions.append(act)
+            else:
+                distro_actions.setdefault(act.distro, []).append(act)
+
+        has_wsl = bool(distro_actions)
+
+        def _add_group(group_actions: list[SetupAction]) -> None:
+            for act in sorted(group_actions, key=action_sort_key):
+                card = ActionCard(self)
+                card.populate(
+                    act,
+                    plugin_installed=plugin_installed,
+                    prerelease_overrides=prerelease_overrides,
+                )
+                card.prerelease_toggled.connect(self.prerelease_toggled.emit)
+                card.navigate_to_tool.connect(self.navigate_to_tool.emit)
+                self._layout.insertWidget(self._layout.count() - 1, card)
+                self._cards.append(card)
+                self._action_map[act] = card
+
+        def _add_header(distro_name: str | None) -> None:
+            header = _DistroGroupHeader(distro_name, self)
+            self._layout.insertWidget(self._layout.count() - 1, header)
+            self._group_headers.append(header)
+
+        # Native actions (with host header only when WSL groups also exist)
+        if has_wsl and native_actions:
+            _add_header(None)
+        _add_group(native_actions)
+
+        # Per-distro groups
+        for distro_name in sorted(distro_actions):
+            _add_header(distro_name)
+            _add_group(distro_actions[distro_name])
 
         # Build original-index → card mapping so callers can look up by
         # the action index porringer emits, which is independent of the
@@ -776,7 +849,11 @@ class ActionCardList(QWidget):
             card.finalize_checking()
 
     def clear(self) -> None:
-        """Remove all cards."""
+        """Remove all cards and group headers."""
+        for header in self._group_headers:
+            self._layout.removeWidget(header)
+            header.deleteLater()
+        self._group_headers.clear()
         for card in self._cards:
             self._layout.removeWidget(card)
             card.deleteLater()

{synodic_client-0.0.1.dev80 → synodic_client-0.0.1.dev81}/synodic_client/application/screen/screen.py

@@ -50,6 +50,7 @@ from synodic_client.application.screen.schema import (
 )
 from synodic_client.application.screen.spinner import LoadingIndicator
 from synodic_client.application.screen.update_banner import UpdateBanner
+from synodic_client.application.screen.wsl import WslView
 from synodic_client.application.theme import (
     COMPACT_MARGINS,
     FILTER_CHIP_SPACING,
@@ -1434,6 +1435,7 @@ class MainWindow(QMainWindow):
     _tabs: QTabWidget | None = None
     _tools_view: ToolsView | None = None
     _projects_view: ProjectsView | None = None
+    _wsl_view: WslView | None = None
 
     def __init__(
         self,
@@ -1517,6 +1519,22 @@ class MainWindow(QMainWindow):
             self._tabs.addTab(self._tools_view, 'Tools')
             self.tools_view_created.emit(self._tools_view)
 
+            # WSL tab — only on Windows hosts with WSL available.
+            try:
+                from porringer.plugin.wsl.utility import is_wsl_host
+
+                if is_wsl_host():
+                    self._wsl_view = WslView(
+                        self._porringer,
+                        self._store,
+                        self,
+                        coordinator=self._coordinator,
+                        package_store=self._package_store,
+                    )
+                    self._tabs.addTab(self._wsl_view, 'WSL')
+            except Exception:
+                logger.debug('Could not initialise WSL tab', exc_info=True)
+
             # Navigate-to-project: switch to Projects tab and select directory
             self._tools_view.navigate_to_project_requested.connect(self._navigate_to_project)
 
@@ -1546,6 +1564,8 @@ class MainWindow(QMainWindow):
             self._tools_view.refresh()
         if self._projects_view is not None:
             self._projects_view.refresh()
+        if self._wsl_view is not None:
+            self._wsl_view.refresh()
 
     def _navigate_to_project(self, path_str: str) -> None:
         """Switch to the Projects tab and select the given directory."""

synodic_client-0.0.1.dev81/synodic_client/application/screen/wsl.py

@@ -0,0 +1,419 @@
+"""WSL package management view.
+
+Shows packages installed in each WSL2 distro, using the same plugin row
+widgets as :class:`~synodic_client.application.screen.screen.ToolsView`
+but scoped per-distro.
+
+Only rendered when :func:`porringer.plugin.wsl.utility.is_wsl_host`
+returns ``True`` (Windows + ``wsl`` on PATH).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import TYPE_CHECKING
+
+from porringer.schema.plugin import PluginKind
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtWidgets import (
+    QHBoxLayout,
+    QLabel,
+    QPushButton,
+    QScrollArea,
+    QVBoxLayout,
+    QWidget,
+)
+
+from synodic_client.application.screen.plugin_row import (
+    PluginProviderHeader,
+    PluginRow,
+    RowPhase,
+)
+from synodic_client.application.screen.schema import PackageEntry, PluginRowData
+from synodic_client.application.screen.spinner import LoadingIndicator
+from synodic_client.application.theme import (
+    COMPACT_MARGINS,
+    PLUGIN_KIND_HEADER_STYLE,
+    PLUGIN_SECTION_SPACING,
+)
+
+if TYPE_CHECKING:
+    from porringer.api import API
+    from porringer.schema import PluginInfo
+
+    from synodic_client.application.config_store import ConfigStore
+    from synodic_client.application.data import DataCoordinator
+    from synodic_client.application.package_state import PackageStateStore
+
+logger = logging.getLogger(__name__)
+
+#: Plugin kinds queried when listing packages inside a WSL distro.
+_WSL_QUERYABLE_KINDS = frozenset({PluginKind.TOOL, PluginKind.PACKAGE})
+
+
+# ---------------------------------------------------------------------------
+# _WslDistroHeader — section divider for one WSL distro
+# ---------------------------------------------------------------------------
+
+
+class _WslDistroHeader(QLabel):
+    """Uppercase section divider labelling a WSL2 distro group.
+
+    Styled like :class:`PluginKindHeader` but with a purple tint to
+    visually distinguish WSL sections from native host sections.
+    """
+
+    def __init__(self, distro_name: str, parent: QWidget | None = None) -> None:
+        super().__init__(distro_name.upper(), parent)
+        self.setObjectName('pluginKindHeader')
+        self.setStyleSheet(PLUGIN_KIND_HEADER_STYLE)
+
+
+# ---------------------------------------------------------------------------
+# WslView
+# ---------------------------------------------------------------------------
+
+
+class WslView(QWidget):
+    """Tool management view for packages installed inside WSL2 distros.
+
+    Mirrors the structure of ``ToolsView`` — distro section headers,
+    per-plugin :class:`PluginProviderHeader` rows, and per-package
+    :class:`PluginRow` widgets — but queries are routed through the
+    ``distro=`` parameter on :meth:`porringer.PackageCommands.list`,
+    :meth:`~porringer.PackageCommands.upgrade`, and
+    :meth:`~porringer.PackageCommands.uninstall`.
+
+    Each distro's packages are loaded in parallel.  Packages are
+    displayed globally (WSL environments don't have per-project venvs
+    in the same sense as the host).
+    """
+
+    package_update_requested = Signal(str, str, str)
+    """Emitted with ``(distro, plugin_name, package_name)`` when update is clicked."""
+
+    package_remove_requested = Signal(str, str, str)
+    """Emitted with ``(distro, plugin_name, package_name)`` when remove is clicked."""
+
+    def __init__(
+        self,
+        porringer: API,
+        store: ConfigStore,
+        parent: QWidget | None = None,
+        *,
+        coordinator: DataCoordinator | None = None,
+        package_store: PackageStateStore | None = None,
+    ) -> None:
+        """Initialize the WSL view.
+
+        Args:
+            porringer: The porringer API instance.
+            store: The centralised :class:`ConfigStore`.
+            parent: Optional parent widget.
+            coordinator: Shared data coordinator for reusing discovery results.
+            package_store: Shared package update state registry (currently unused
+                by WslView but accepted for API consistency with ToolsView).
+        """
+        super().__init__(parent)
+        self._porringer = porringer
+        self._store = store
+        self._coordinator = coordinator
+        self._section_widgets: list[QWidget] = []
+        self._plugin_info_map: dict[str, PluginInfo] = {}
+        self._refresh_in_progress = False
+        self._init_ui()
+
+    # ------------------------------------------------------------------
+    # UI construction
+    # ------------------------------------------------------------------
+
+    def _init_ui(self) -> None:
+        """Build the view layout: toolbar, scroll area, loading indicator."""
+        outer = QVBoxLayout(self)
+        outer.setContentsMargins(*COMPACT_MARGINS)
+
+        outer.addLayout(self._build_toolbar())
+
+        self._scroll = QScrollArea()
+        self._scroll.setWidgetResizable(True)
+        self._scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+
+        self._container = QWidget()
+        self._container_layout = QVBoxLayout(self._container)
+        self._container_layout.setSpacing(PLUGIN_SECTION_SPACING)
+        self._container_layout.setContentsMargins(0, 0, 0, 0)
+        self._container_layout.addStretch()
+
+        self._scroll.setWidget(self._container)
+        outer.addWidget(self._scroll)
+
+        self._loading_indicator = LoadingIndicator('Loading WSL packages\u2026')
+        outer.addWidget(self._loading_indicator)
+
+    def _build_toolbar(self) -> QHBoxLayout:
+        """Build the toolbar with a refresh button."""
+        toolbar = QHBoxLayout()
+        toolbar.addStretch()
+
+        self._refresh_btn = QPushButton('Refresh')
+        self._refresh_btn.setFlat(True)
+        self._refresh_btn.setToolTip('Re-scan WSL packages')
+        self._refresh_btn.clicked.connect(self.refresh)
+        toolbar.addWidget(self._refresh_btn)
+
+        return toolbar
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def refresh(self) -> None:
+        """Schedule an asynchronous rebuild of the WSL package list."""
+        if self._refresh_in_progress:
+            return
+        asyncio.create_task(self._async_refresh())
+
+    # ------------------------------------------------------------------
+    # Async refresh pipeline
+    # ------------------------------------------------------------------
+
+    async def _async_refresh(self) -> None:
+        """Rebuild the WSL package tree from porringer data."""
+        self._refresh_in_progress = True
+        self._scroll.hide()
+        self._loading_indicator.start()
+        self._refresh_btn.setEnabled(False)
+
+        try:
+            data = await self._gather_wsl_data()
+            self._build_widget_tree(data)
+        except Exception:
+            logger.exception('Failed to refresh WSL packages')
+        finally:
+            self._loading_indicator.stop()
+            self._scroll.show()
+            self._refresh_btn.setEnabled(True)
+            self._refresh_in_progress = False
+
+    async def _gather_wsl_data(self) -> dict[str, dict[str, list[PackageEntry]]]:
+        """Fetch packages for every available WSL2 distro.
+
+        For each distro, all TOOL- and PACKAGE-kind plugins are queried
+        in parallel using ``porringer.package.list(..., distro=distro)``.
+
+        Returns:
+            ``{distro_name: {plugin_name: [PackageEntry, ...]}}`` for
+            distros that have at least one non-empty plugin result.
+        """
+        from porringer.plugin.wsl.utility import available_distros
+
+        discovered = self._coordinator.discovered_plugins if self._coordinator else None
+
+        if self._coordinator is not None:
+            snapshot = await self._coordinator.refresh()
+            plugins = snapshot.plugins
+        else:
+            plugins = await self._porringer.plugin.list()
+
+        # Update the plugin-info lookup for PluginProviderHeader construction.
+        self._plugin_info_map = {p.name: p for p in plugins}
+
+        queryable = [p for p in plugins if p.kind in _WSL_QUERYABLE_KINDS and p.installed]
+
+        loop = asyncio.get_running_loop()
+        distros: list[str] = await loop.run_in_executor(None, available_distros)
+
+        result: dict[str, dict[str, list[PackageEntry]]] = {}
+
+        async def _fetch_distro(distro: str) -> None:
+            distro_pkgs: dict[str, list[PackageEntry]] = {}
+
+            async def _fetch_plugin(plugin: PluginInfo) -> None:
+                try:
+                    pkgs = await self._porringer.package.list(
+                        plugin.name,
+                        plugins=discovered,
+                        distro=distro,
+                    )
+                    if pkgs:
+                        distro_pkgs[plugin.name] = [
+                            PackageEntry(
+                                name=str(pkg.name),
+                                version=str(pkg.version) if pkg.version else '',
+                                host_tool=pkg.relation.host if pkg.relation else '',
+                            )
+                            for pkg in pkgs
+                        ]
+                except Exception:
+                    logger.debug(
+                        'Could not list packages for %s in distro %s',
+                        plugin.name,
+                        distro,
+                        exc_info=True,
+                    )
+
+            async with asyncio.TaskGroup() as tg:
+                for plugin in queryable:
+                    tg.create_task(_fetch_plugin(plugin))
+
+            if distro_pkgs:
+                result[distro] = distro_pkgs
+
+        async with asyncio.TaskGroup() as tg:
+            for distro in distros:
+                tg.create_task(_fetch_distro(distro))
+
+        return result
+
+    # ------------------------------------------------------------------
+    # Widget tree construction
+    # ------------------------------------------------------------------
+
+    def _build_widget_tree(self, data: dict[str, dict[str, list[PackageEntry]]]) -> None:
+        """Clear and rebuild section widgets from *data*."""
+        self._clear_section_widgets()
+
+        if not data:
+            empty = QLabel('No WSL packages found.')
+            empty.setAlignment(Qt.AlignmentFlag.AlignCenter)
+            empty.setStyleSheet('color: grey; padding: 20px;')
+            self._insert_section_widget(empty)
+            return
+
+        for distro_name in sorted(data):
+            header = _WslDistroHeader(distro_name, parent=self._container)
+            self._insert_section_widget(header)
+
+            for plugin_name, packages in sorted(data[distro_name].items()):
+                plugin_info = self._plugin_info_map.get(plugin_name)
+                if plugin_info is not None:
+                    provider = PluginProviderHeader(
+                        plugin_info,
+                        show_controls=False,
+                        parent=self._container,
+                    )
+                    self._insert_section_widget(provider)
+
+                for entry in packages:
+                    row = PluginRow(
+                        PluginRowData(
+                            name=entry.name,
+                            version=entry.version,
+                            plugin_name=plugin_name,
+                            show_toggle=False,
+                            is_global=True,
+                            host_tool=entry.host_tool,
+                        ),
+                        parent=self._container,
+                    )
+                    # Capture distro_name in the lambda so the handler
+                    # knows which distro to route the operation to.
+                    row.update_requested.connect(
+                        lambda pn, pkg, d=distro_name: asyncio.create_task(
+                            self._update_package(d, pn, pkg),
+                        ),
+                    )
+                    row.remove_requested.connect(
+                        lambda pn, pkg, d=distro_name: asyncio.create_task(
+                            self._remove_package(d, pn, pkg),
+                        ),
+                    )
+                    self._insert_section_widget(row)
+
+    def _insert_section_widget(self, widget: QWidget) -> None:
+        """Append *widget* to the container layout above the trailing stretch."""
+        idx = self._container_layout.count() - 1
+        self._container_layout.insertWidget(idx, widget)
+        self._section_widgets.append(widget)
+
+    def _clear_section_widgets(self) -> None:
+        """Remove and delete all current section widgets."""
+        for widget in self._section_widgets:
+            self._container_layout.removeWidget(widget)
+            widget.deleteLater()
+        self._section_widgets.clear()
+
+    # ------------------------------------------------------------------
+    # Package operations
+    # ------------------------------------------------------------------
+
+    async def _update_package(self, distro: str, plugin_name: str, package_name: str) -> None:
+        """Upgrade *package_name* inside *distro* via *plugin_name*.
+
+        Transitions the matching :class:`PluginRow` to the ``UPDATING``
+        phase, executes the upgrade, then returns it to ``IDLE`` or
+        shows an inline error on failure.
+        """
+        from porringer.core.schema import PackageRef
+
+        discovered = self._coordinator.discovered_plugins if self._coordinator else None
+        row = self._find_row(plugin_name, package_name)
+        if row is not None:
+            row.set_phase(RowPhase.UPDATING)
+
+        try:
+            ref = PackageRef(name=package_name)
+            action_result = await self._porringer.package.upgrade(
+                plugin_name,
+                ref,
+                plugins=discovered,
+                distro=distro,
+            )
+            if not action_result.success and not action_result.skipped:
+                msg = action_result.message or 'Update failed'
+                logger.warning('WSL package update failed: %s/%s in %s: %s', plugin_name, package_name, distro, msg)
+                if row is not None:
+                    row.set_error(msg)
+            else:
+                if row is not None:
+                    row.set_phase(RowPhase.IDLE)
+                self.package_update_requested.emit(distro, plugin_name, package_name)
+        except Exception:
+            logger.exception('WSL update error: %s/%s in %s', plugin_name, package_name, distro)
+            if row is not None:
+                row.set_error('Update error — see log')
+
+    async def _remove_package(self, distro: str, plugin_name: str, package_name: str) -> None:
+        """Uninstall *package_name* from *distro* via *plugin_name*.
+
+        On success, triggers a refresh so the removed package disappears
+        from the list.  On failure, shows an inline error on the row.
+        """
+        from porringer.core.schema import PackageRef
+
+        discovered = self._coordinator.discovered_plugins if self._coordinator else None
+        row = self._find_row(plugin_name, package_name)
+
+        try:
+            ref = PackageRef(name=package_name)
+            action_result = await self._porringer.package.uninstall(
+                plugin_name,
+                ref,
+                plugins=discovered,
+                distro=distro,
+            )
+            if action_result.success or action_result.skipped:
+                self.package_remove_requested.emit(distro, plugin_name, package_name)
+                # Refresh to remove the row from the list.
+                self.refresh()
+            else:
+                msg = action_result.message or 'Removal failed'
+                logger.warning('WSL package removal failed: %s/%s in %s: %s', plugin_name, package_name, distro, msg)
+                if row is not None:
+                    row.set_error(msg)
+        except Exception:
+            logger.exception('WSL removal error: %s/%s in %s', plugin_name, package_name, distro)
+            if row is not None:
+                row.set_error('Removal error — see log')
+
+    def _find_row(self, plugin_name: str, package_name: str) -> PluginRow | None:
+        """Return the first :class:`PluginRow` matching *plugin_name* and *package_name*."""
+        for widget in self._section_widgets:
+            if (
+                isinstance(widget, PluginRow)
+                and widget._plugin_name == plugin_name
+                and widget._package_name == package_name
+            ):
+                return widget
+        return None

{synodic_client-0.0.1.dev80 → synodic_client-0.0.1.dev81}/synodic_client/application/theme.py

@@ -448,6 +448,22 @@ ACTION_CARD_TYPE_BADGE_STYLE = (
 )
 """Small type badge (Package, Tool, Runtime, etc.) on each action card."""
 
+ACTION_CARD_DISTRO_BADGE_STYLE = (
+    'QLabel { font-size: 10px;  padding: 1px 6px; border-radius: 3px;  background: #3d2a50; color: #c5a0e0; }'
+)
+"""Muted purple pill showing the WSL distro name on a WSL action card."""
+
+WSL_DISTRO_HEADER_STYLE = (
+    'QLabel#wslDistroHeader {'
+    '  font-size: 11px;'
+    '  font-weight: bold;'
+    '  color: #c5a0e0;'
+    '  padding: 8px 4px 4px 4px;'
+    '  border-bottom: 1px solid palette(mid);'
+    '}'
+)
+"""Section divider for WSL distro groups inside the action card list."""
+
 ACTION_CARD_PACKAGE_STYLE = 'font-weight: bold; font-size: 12px;'
 """Primary line: package name."""
 

{synodic_client-0.0.1.dev80 → synodic_client-0.0.1.dev81}/synodic_client/operations/install.py

@@ -225,6 +225,7 @@ async def preview_manifest(
                         package=str(act.package.name) if act.package else None,
                         constraint=act.package.constraint if act.package else None,
                         installer=act.installer,
+                        distro=act.distro,
                     )
                 )
 

{synodic_client-0.0.1.dev80 → synodic_client-0.0.1.dev81}/synodic_client/operations/schema.py

@@ -355,6 +355,8 @@ class ActionInfo:
     package: str | None = None
     constraint: str | None = None
     installer: str | None = None
+    distro: str | None = None
+    """WSL2 distro name, or ``None`` for native host actions."""
 
 
 @dataclass(frozen=True, slots=True)

{synodic_client-0.0.1.dev80 → synodic_client-0.0.1.dev81}/synodic_client/updater.py

@@ -262,10 +262,9 @@ class Updater:
             # Simple semver comparison via packaging.version (accepts
             # semver pre-release tags like ``0.1.0-dev.79``).
             try:
-                if Version(ver) > Version(current_semver):
-                    if best_ver is None or Version(ver) > Version(best_ver):
-                        best = asset
-                        best_ver = ver
+                if Version(ver) > Version(current_semver) and (best_ver is None or Version(ver) > Version(best_ver)):
+                    best = asset
+                    best_ver = ver
             except Exception:
                 continue