portacode 2.0.0.dev0__tar.gz → 2.0.2__tar.gz

{portacode-2.0.0.dev0 → portacode-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: portacode
-Version: 2.0.0.dev0
+Version: 2.0.2
 Summary: Device agent for the AI platform that builds, tests, deploys, and operates real software
 Home-page: https://portacode.com/
 Author: Meena Erian

{portacode-2.0.0.dev0 → portacode-2.0.2}/portacode/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.0.0.dev0'
-__version_tuple__ = version_tuple = (2, 0, 0, 'dev0')
+__version__ = version = '2.0.2'
+__version_tuple__ = version_tuple = (2, 0, 2)
 
 __commit_id__ = commit_id = None

{portacode-2.0.0.dev0 → portacode-2.0.2}/portacode/connection/guest_host_protocol.py

@@ -24,6 +24,7 @@ GUEST_HOST_REQUEST_COMMANDS = frozenset(
         "configure_proxmox_container_expose_ports",
         "start_proxmox_container",
         "stop_proxmox_container",
+        "restart_proxmox_container",
         "remove_proxmox_container",
         "create_proxmox_container",
     }
@@ -32,14 +33,23 @@ GUEST_HOST_COMMAND_OPERATIONS = {
     "configure_proxmox_container_expose_ports": "expose_ports",
     "start_proxmox_container": "power",
     "stop_proxmox_container": "power",
+    "restart_proxmox_container": "power",
     "remove_proxmox_container": "delete",
     "create_proxmox_container": "provision",
 }
 
-# The protocol reserves additional commands for staged rollout, but this CLI
-# release advertises and executes only the operation validated end-to-end.
+# Every advertised operation is mapped to its existing, independently
+# registered legacy handler.  Server-side capability and runtime gates still
+# control which operations are actually sent through this protocol.
 GUEST_HOST_EXECUTABLE_COMMANDS = frozenset(
-    {"configure_proxmox_container_expose_ports"}
+    {
+        "configure_proxmox_container_expose_ports",
+        "start_proxmox_container",
+        "stop_proxmox_container",
+        "restart_proxmox_container",
+        "remove_proxmox_container",
+        "create_proxmox_container",
+    }
 )
 
 

{portacode-2.0.0.dev0 → portacode-2.0.2}/portacode/connection/handlers/WEBSOCKET_PROTOCOL.md

@@ -88,6 +88,18 @@ versions continue using existing commands while flags are disabled. Unknown
 message types or commands must fail closed; they must never fall through to an
 ordinary client-session handler.
 
+Protocol version 1 defines these request types and command mappings:
+
+- `expose_ports` → `configure_proxmox_container_expose_ports`;
+- `power` → `start_proxmox_container`, `stop_proxmox_container`, or `restart_proxmox_container`;
+- `delete` → `remove_proxmox_container`;
+- `provision` → `create_proxmox_container`.
+
+Supporting CLI versions advertise the enabled set in
+`system_info.protocol_capabilities.guest_host_requests.request_types`. The
+server must check that per-host list as well as its per-operation runtime flag
+before selecting this transport. Otherwise it uses the unchanged legacy path.
+
 This document describes the complete protocol for communicating with devices through the server, guiding app developers on how to get their client sessions to communicate with devices.
 
 ## Table of Contents
@@ -534,6 +546,14 @@ Stops a running Portacode-managed container. Handled by [`StopProxmoxContainerHa
 *   Emits a [`proxmox_container_action`](#proxmox_container_action-event) event with `action="stop"` and the refreshed infra snapshot.
 *   Emits an [`error`](#error) event on failure.
 
+### `restart_proxmox_container`
+
+Stops and starts a Portacode-managed container as one validated host-side
+operation. It accepts the same required `child_device_id` and optional `ctid`
+fields as the start/stop actions. The handler verifies the child-to-container
+mapping before changing state, then emits `proxmox_container_action` with
+`action="restart"`.
+
 ### `remove_proxmox_container`
 
 Deletes a managed container from Proxmox (stopping it first if necessary) and removes the stored metadata file. Handled by [`RemoveProxmoxContainerHandler`](./proxmox_infra.py).

{portacode-2.0.0.dev0 → portacode-2.0.2}/portacode/connection/handlers/__init__.py

@@ -60,6 +60,7 @@ from .proxmox_infra import (
     StartPortacodeServiceHandler,
     StartProxmoxContainerHandler,
     StopProxmoxContainerHandler,
+    RestartProxmoxContainerHandler,
     RemoveProxmoxContainerHandler,
 )
 from .cloudflare_tunnel import CloudflareTunnelSetupHandler
@@ -132,6 +133,7 @@ __all__ = [
     "StartPortacodeServiceHandler",
     "StartProxmoxContainerHandler",
     "StopProxmoxContainerHandler",
+    "RestartProxmoxContainerHandler",
     "RemoveProxmoxContainerHandler",
     "UpdatePortacodeHandler",
     "RevertProxmoxInfraHandler",

{portacode-2.0.0.dev0 → portacode-2.0.2}/portacode/connection/handlers/proxmox_infra.py

@@ -1327,7 +1327,7 @@ def _refresh_container_statuses(records: List[Dict[str, Any]], config: Optional[
 
 
 def _initialize_managed_containers_state(force: bool = False) -> Dict[str, Any]:
-    with _MANAGED_CONTAINERS_STATE_LOCK:
+    with _acquire_state_lock("managed state initialization check"):
         if _MANAGED_CONTAINERS_STATE["initialized"] and not force:
             base = _MANAGED_CONTAINERS_STATE["base_summary"]
             return _copy_summary(base) if base else {}
@@ -1352,7 +1352,7 @@ def _initialize_managed_containers_state(force: bool = False) -> Dict[str, Any]:
         "cpu_share": float(base_summary.get("total_cpu_share") or 0.0),
     }
 
-    with _MANAGED_CONTAINERS_STATE_LOCK:
+    with _acquire_state_lock("managed state initialization commit"):
         _MANAGED_CONTAINERS_STATE["initialized"] = True
         _MANAGED_CONTAINERS_STATE["base_summary"] = base_summary
         _MANAGED_CONTAINERS_STATE["initial_totals"] = initial_totals
@@ -1374,7 +1374,7 @@ def reconcile_managed_containers_inventory() -> Dict[str, Any]:
     never replaced by reconciliation.
     """
     _initialize_managed_containers_state()
-    with _MANAGED_CONTAINERS_STATE_LOCK:
+    with _acquire_state_lock("inventory reconciliation snapshot"):
         revision = int(_MANAGED_CONTAINERS_STATE.get("revision") or 0)
         records = [record.copy() for record in _MANAGED_CONTAINERS_STATE.get("records", {}).values()]
 
@@ -1401,38 +1401,46 @@ def reconcile_managed_containers_inventory() -> Dict[str, Any]:
 
     cleaned_vmids: List[int] = []
     cleanup_errors: List[Dict[str, str]] = []
-    with _MANAGED_CONTAINERS_STATE_LOCK:
+    with _acquire_state_lock("inventory reconciliation pre-cleanup check"):
         if int(_MANAGED_CONTAINERS_STATE.get("revision") or 0) != revision:
             return {"refreshed": False, "reason": "state_changed"}
-        # Serialize cleanup with create/delete state mutations. This prevents a
-        # stale inventory scan from clearing metadata after a CTID is reused.
-        for record in missing_records:
-            try:
-                vmid = int(record["vmid"])
-            except (KeyError, TypeError, ValueError):
-                continue
-            device_id = str(record.get("device_id") or "").strip()
-            try:
-                if device_id:
-                    from .cloudflare_forwarding import set_container_forwarding_rules
 
-                    try:
-                        set_container_forwarding_rules(device_id, [])
-                    except RuntimeError as exc:
-                        message = str(exc).lower()
-                        if (
-                            "cloudflare tunnel is not configured yet" not in message
-                            and "domain or tunnel name missing" not in message
-                        ):
-                            raise
-                cleaned_vmids.append(vmid)
-            except Exception as exc:  # retry on the next reconciliation pass
-                logger.warning(
-                    "Unable to clean Proxmox-side metadata for missing container %s: %s",
-                    vmid,
-                    exc,
-                )
-                cleanup_errors.append({"vmid": str(vmid), "error": str(exc)})
+    # Forwarding cleanup may call cloudflared and touch its configuration. It
+    # must never run while holding the managed-state lock: reservations,
+    # deletion, and system snapshots all need that lock to remain responsive.
+    for record in missing_records:
+        try:
+            vmid = int(record["vmid"])
+        except (KeyError, TypeError, ValueError):
+            continue
+        device_id = str(record.get("device_id") or "").strip()
+        try:
+            if device_id:
+                from .cloudflare_forwarding import set_container_forwarding_rules
+
+                try:
+                    set_container_forwarding_rules(device_id, [])
+                except RuntimeError as exc:
+                    message = str(exc).lower()
+                    if (
+                        "cloudflare tunnel is not configured yet" not in message
+                        and "domain or tunnel name missing" not in message
+                    ):
+                        raise
+            cleaned_vmids.append(vmid)
+        except Exception as exc:  # retry on the next reconciliation pass
+            logger.warning(
+                "Unable to clean Proxmox-side metadata for missing container %s: %s",
+                vmid,
+                exc,
+            )
+            cleanup_errors.append({"vmid": str(vmid), "error": str(exc)})
+
+    with _acquire_state_lock("inventory reconciliation commit"):
+        if int(_MANAGED_CONTAINERS_STATE.get("revision") or 0) != revision:
+            return {"refreshed": False, "reason": "state_changed"}
+        # The revision check prevents stale scan results from removing metadata
+        # after provisioning or deletion changed the managed state.
         for vmid in cleaned_vmids:
             path = CONTAINERS_DIR / f"ct-{vmid}.json"
             path.unlink(missing_ok=True)
@@ -1856,7 +1864,7 @@ def _compose_managed_containers_summary(
 
 def _get_managed_containers_summary(force: bool = False) -> Dict[str, Any]:
     _initialize_managed_containers_state(force=force)
-    with _MANAGED_CONTAINERS_STATE_LOCK:
+    with _acquire_state_lock("managed container summary snapshot"):
         base_summary = _MANAGED_CONTAINERS_STATE.get("base_summary") or {}
         records = list(_MANAGED_CONTAINERS_STATE.get("records", {}).values())
         pending = list(_MANAGED_CONTAINERS_STATE.get("pending", {}).values())
@@ -1872,7 +1880,7 @@ def _reserve_container_resources(payload: Dict[str, Any], *, device_id: str, req
     disk_gib = int(payload.get("disk_gib") or 0)
     cpu_share = float(payload.get("cpus") or 0.0)
     reservation_id = secrets.token_hex(8)
-    with _MANAGED_CONTAINERS_STATE_LOCK:
+    with _acquire_state_lock("container resource reservation"):
         base_summary = _MANAGED_CONTAINERS_STATE.get("base_summary") or {}
         records = list(_MANAGED_CONTAINERS_STATE.get("records", {}).values())
         pending = list(_MANAGED_CONTAINERS_STATE.get("pending", {}).values())
@@ -1904,7 +1912,7 @@ def _reserve_container_resources(payload: Dict[str, Any], *, device_id: str, req
 def _release_container_reservation(reservation_id: Optional[str]) -> None:
     if not reservation_id:
         return
-    with _MANAGED_CONTAINERS_STATE_LOCK:
+    with _acquire_state_lock("container reservation release"):
         _MANAGED_CONTAINERS_STATE.get("pending", {}).pop(reservation_id, None)
 
 
@@ -2990,7 +2998,7 @@ def _require_successful_proxmox_task(
 
 def _register_container_record(vmid: int, payload: Dict[str, Any], reservation_id: Optional[str] = None) -> None:
     _initialize_managed_containers_state()
-    with _MANAGED_CONTAINERS_STATE_LOCK:
+    with _acquire_state_lock("container record update"):
         if reservation_id:
             _MANAGED_CONTAINERS_STATE["pending"].pop(reservation_id, None)
         _MANAGED_CONTAINERS_STATE["records"][str(vmid)] = payload.copy()
@@ -3001,7 +3009,7 @@ def _register_container_record(vmid: int, payload: Dict[str, Any], reservation_i
 
 def _unregister_container_record(vmid: int) -> None:
     _initialize_managed_containers_state()
-    with _MANAGED_CONTAINERS_STATE_LOCK:
+    with _acquire_state_lock("container record removal"):
         _MANAGED_CONTAINERS_STATE["records"].pop(str(vmid), None)
         _MANAGED_CONTAINERS_STATE["revision"] = int(
             _MANAGED_CONTAINERS_STATE.get("revision") or 0
@@ -5165,6 +5173,68 @@ class StopProxmoxContainerHandler(SyncHandler):
         }
 
 
+class RestartProxmoxContainerHandler(SyncHandler):
+    """Restart a managed container as one validated host-side operation."""
+
+    @property
+    def command_name(self) -> str:
+        return "restart_proxmox_container"
+
+    def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        child_device_id = (message.get("child_device_id") or "").strip()
+        if not child_device_id:
+            raise ValueError("child_device_id is required for restart_proxmox_container")
+        config = _ensure_infra_configured()
+        proxmox = _connect_proxmox(config)
+        node = _get_node_from_config(config)
+        try:
+            vmid = _parse_ctid(message)
+        except ValueError:
+            try:
+                vmid = _resolve_vmid_for_device(child_device_id)
+            except _DeviceLookupError:
+                vmid = _resolve_vmid_for_device_in_proxmox(proxmox, node, child_device_id)
+        _ensure_container_managed(proxmox, node, vmid, device_id=child_device_id)
+
+        stop_status, stop_elapsed = _stop_container(proxmox, node, vmid)
+        start_status, start_elapsed = _start_container(proxmox, node, vmid)
+        _update_container_record(vmid, {"status": "running"})
+
+        forwarding_ip_updated = False
+        try:
+            from .cloudflare_forwarding import reconcile_container_forwarding_ip
+
+            forwarding_ip_updated = reconcile_container_forwarding_ip(
+                child_device_id,
+                proxmox=proxmox,
+                node=node,
+                lease_attempts=6,
+                lease_retry_seconds=1.0,
+            )
+        except Exception:
+            logger.warning(
+                "Unable to reconcile exposed IP after restarting container device_id=%s vmid=%s",
+                child_device_id,
+                vmid,
+                exc_info=True,
+            )
+
+        return {
+            "event": "proxmox_container_action",
+            "action": "restart",
+            "success": True,
+            "ctid": str(vmid),
+            "message": f"Restarted container {vmid} in {stop_elapsed + start_elapsed:.1f}s.",
+            "details": {
+                "stop_exitstatus": stop_status.get("exitstatus"),
+                "start_exitstatus": start_status.get("exitstatus"),
+                "forwarding_ip_updated": forwarding_ip_updated,
+            },
+            "status": start_status.get("status") or "running",
+            "infra": get_infra_snapshot(),
+        }
+
+
 class RemoveProxmoxContainerHandler(SyncHandler):
     """Delete a managed container via the Proxmox API."""
 

{portacode-2.0.0.dev0 → portacode-2.0.2}/portacode/connection/handlers/registry.py

@@ -1,5 +1,6 @@
 """Command registry for managing handler dispatch."""
 
+import asyncio
 import logging
 from typing import Dict, Type, Any, Optional, List, TYPE_CHECKING
 from portacode.utils.ntp_clock import ntp_clock
@@ -24,6 +25,7 @@ class CommandRegistry:
         self.control_channel = control_channel
         self.context = context
         self._handlers: Dict[str, "BaseHandler"] = {}
+        self._inflight_dispatches: Dict[str, asyncio.Task[bool]] = {}
         
     def register(self, handler_class: Type["BaseHandler"]) -> None:
         """Register a command handler.
@@ -99,6 +101,35 @@ class CommandRegistry:
             logger.warning("registry: No handler found for command: %s", command_name)
             return False
 
+        # System information is requested by periodic refreshes, dashboard
+        # joins, and explicit probes. All of those sources must share one
+        # collection; Proxmox discovery is too expensive to run concurrently.
+        if command_name == "system_info":
+            existing = self._inflight_dispatches.get(command_name)
+            if existing is not None and not existing.done():
+                logger.info("registry: Coalesced concurrent system_info request")
+                return True
+            task = asyncio.create_task(
+                self._dispatch_handler(command_name, handler, message, reply_channel)
+            )
+            self._inflight_dispatches[command_name] = task
+
+            def _clear_inflight(completed: asyncio.Task[bool]) -> None:
+                if self._inflight_dispatches.get(command_name) is completed:
+                    self._inflight_dispatches.pop(command_name, None)
+
+            task.add_done_callback(_clear_inflight)
+            return True
+
+        return await self._dispatch_handler(command_name, handler, message, reply_channel)
+
+    async def _dispatch_handler(
+        self,
+        command_name: str,
+        handler: "BaseHandler",
+        message: Dict[str, Any],
+        reply_channel: Optional[str],
+    ) -> bool:
         try:
             await handler.handle(message, reply_channel)
             logger.info("registry: Successfully dispatched command '%s'", command_name)

{portacode-2.0.0.dev0 → portacode-2.0.2}/portacode/connection/handlers/system_handlers.py

@@ -632,7 +632,7 @@ class SystemInfoHandler(SyncHandler):
         info["protocol_capabilities"] = {
             "guest_host_requests": {
                 "protocol_version": 1,
-                "request_types": ["expose_ports"],
+                "request_types": ["expose_ports", "power", "delete", "provision"],
                 "message_types": [
                     "guest_host_request",
                     "guest_host_ack",

{portacode-2.0.0.dev0 → portacode-2.0.2}/portacode/connection/handlers/test_proxmox_infra.py

@@ -1,10 +1,12 @@
 from unittest import TestCase
+import threading
 from pathlib import Path
 from tempfile import TemporaryDirectory
 from unittest.mock import MagicMock, patch
 
 from portacode.connection.handlers.proxmox_infra import (
     RemoveProxmoxContainerHandler,
+    RestartProxmoxContainerHandler,
     _build_full_container_summary,
     _compose_managed_containers_summary,
     _build_bootstrap_steps,
@@ -36,6 +38,31 @@ from portacode.connection.handlers.proxmox_infra import (
 
 
 class ProxmoxInfraHandlerTests(TestCase):
+    @patch("portacode.connection.handlers.proxmox_infra.get_infra_snapshot", return_value={})
+    @patch("portacode.connection.handlers.proxmox_infra._update_container_record")
+    @patch("portacode.connection.handlers.proxmox_infra._start_container")
+    @patch("portacode.connection.handlers.proxmox_infra._stop_container")
+    @patch("portacode.connection.handlers.proxmox_infra._ensure_container_managed")
+    @patch("portacode.connection.handlers.proxmox_infra._resolve_vmid_for_device", return_value=101)
+    @patch("portacode.connection.handlers.proxmox_infra._get_node_from_config", return_value="pve")
+    @patch("portacode.connection.handlers.proxmox_infra._connect_proxmox")
+    @patch("portacode.connection.handlers.proxmox_infra._ensure_infra_configured", return_value={})
+    def test_restart_validates_child_then_stops_and_starts_once(
+        self, _config, connect, _node, _resolve, ensure_managed, stop, start, update, _snapshot
+    ):
+        stop.return_value = ({"exitstatus": "OK", "status": "stopped"}, 1.0)
+        start.return_value = ({"exitstatus": "OK", "status": "running"}, 2.0)
+        handler = RestartProxmoxContainerHandler(MagicMock(), {})
+
+        result = handler.execute({"child_device_id": "42"})
+
+        ensure_managed.assert_called_once_with(connect.return_value, "pve", 101, device_id="42")
+        stop.assert_called_once_with(connect.return_value, "pve", 101)
+        start.assert_called_once_with(connect.return_value, "pve", 101)
+        update.assert_called_once_with(101, {"status": "running"})
+        self.assertEqual(result["action"], "restart")
+        self.assertTrue(result["success"])
+
     def test_container_config_memory_is_always_mib_even_above_10000(self):
         self.assertEqual(
             _pick_container_ram_mib("lxc", {"memory": 32768}, {"maxmem": 34359738368}),
@@ -211,6 +238,50 @@ class ProxmoxInfraHandlerTests(TestCase):
         self.assertEqual(result["cleaned_vmids"], [])
         self.assertEqual(result["cleanup_errors"][0]["vmid"], "144")
 
+    @patch("portacode.connection.handlers.proxmox_infra._load_config", return_value={"node": "pve"})
+    def test_reconciliation_does_not_hold_state_lock_during_forwarding_cleanup(self, _config):
+        from portacode.connection.handlers import proxmox_infra
+
+        entered_cleanup = threading.Event()
+        release_cleanup = threading.Event()
+        state = {
+            "initialized": True, "base_summary": {}, "initial_totals": {},
+            "records": {"144": {"vmid": 144, "device_id": "42"}},
+            "pending": {}, "revision": 2,
+        }
+        refreshed = {
+            "inventory_updated_at": "now",
+            "missing_containers": [{"vmid": "144", "device_id": "42"}],
+            "total_ram_mib": 0, "total_disk_gib": 0, "total_cpu_share": 0,
+        }
+
+        def blocking_cleanup(_device_id, _rules):
+            entered_cleanup.set()
+            release_cleanup.wait(timeout=1)
+
+        with TemporaryDirectory() as root, patch(
+            "portacode.connection.handlers.proxmox_infra.CONTAINERS_DIR", Path(root)
+        ), patch(
+            "portacode.connection.handlers.proxmox_infra._MANAGED_CONTAINERS_STATE", state
+        ), patch(
+            "portacode.connection.handlers.proxmox_infra._build_full_container_summary",
+            return_value=refreshed,
+        ), patch(
+            "portacode.connection.handlers.cloudflare_forwarding.set_container_forwarding_rules",
+            side_effect=blocking_cleanup,
+        ):
+            worker = threading.Thread(target=reconcile_managed_containers_inventory)
+            worker.start()
+            self.assertTrue(entered_cleanup.wait(timeout=0.2))
+            acquired = proxmox_infra._MANAGED_CONTAINERS_STATE_LOCK.acquire(timeout=0.2)
+            if acquired:
+                proxmox_infra._MANAGED_CONTAINERS_STATE_LOCK.release()
+            release_cleanup.set()
+            worker.join(timeout=1)
+
+        self.assertTrue(acquired)
+        self.assertFalse(worker.is_alive())
+
     @patch("portacode.connection.handlers.proxmox_infra._load_config", return_value={"node": "pve"})
     def test_reconciliation_discards_scan_when_managed_state_changes(self, _config):
         state = {

{portacode-2.0.0.dev0 → portacode-2.0.2}/portacode/connection/terminal.py

@@ -74,6 +74,7 @@ from .handlers import (
     StartPortacodeServiceHandler,
     StartProxmoxContainerHandler,
     StopProxmoxContainerHandler,
+    RestartProxmoxContainerHandler,
     RemoveProxmoxContainerHandler,
     CloudflareTunnelSetupHandler,
     CloudflareForwardingHandler,
@@ -110,6 +111,7 @@ from portacode.tunneling.privileged import read_text, run, write_text
 logger = logging.getLogger(__name__)
 EXPOSED_SERVICES_MONITOR_PATH = "/etc/portacode/exposed_services.json"
 EXPOSED_SERVICES_MONITOR_INTERVAL_S = 2.0
+SYSTEM_INFO_INTERVAL_S = 10.0
 EXPOSED_SERVICES_MISSING_SIGNATURE = "__missing__"
 EXPOSED_SERVICES_INVALID_SIGNATURE = "__invalid__"
 EXPOSED_SERVICES_ENV_PATH = Path("/etc/portacode/exposed_services.env")
@@ -595,6 +597,7 @@ class TerminalManager:
         self._command_registry.register(StartPortacodeServiceHandler)
         self._command_registry.register(StartProxmoxContainerHandler)
         self._command_registry.register(StopProxmoxContainerHandler)
+        self._command_registry.register(RestartProxmoxContainerHandler)
         self._command_registry.register(RemoveProxmoxContainerHandler)
         self._command_registry.register(RevertProxmoxInfraHandler)
         self._command_registry.register(CloudflareTunnelSetupHandler)
@@ -776,12 +779,14 @@ class TerminalManager:
         """Send system_info event every 10 seconds when clients are connected."""
         while True:
             try:
-                await asyncio.sleep(10)
-                if self._client_session_manager.has_interested_clients():
-                    from .handlers.system_handlers import SystemInfoHandler
-                    handler = SystemInfoHandler(self._control_channel, self._context)
-                    system_info = handler.execute({})
-                    await self._send_session_aware(system_info)
+                await asyncio.sleep(SYSTEM_INFO_INTERVAL_S)
+                if not self._client_session_manager.has_interested_clients():
+                    continue
+                # CommandRegistry owns the single-flight invariant shared by
+                # periodic ticks, dashboard joins, and explicit probes.
+                await self._command_registry.dispatch("system_info", {}, None)
+            except asyncio.CancelledError:
+                raise
             except Exception as exc:
                 logger.exception("Error in periodic system info: %s", exc)
                 continue

{portacode-2.0.0.dev0 → portacode-2.0.2}/portacode/connection/test_guest_host_terminal.py

@@ -30,6 +30,21 @@ class Registry:
         return self.handler if command == self.handler.command_name else None
 
 
+class CommandRecordingHandler(SyncHandler):
+    def __init__(self, control_channel, session, command):
+        super().__init__(control_channel, session)
+        self._command = command
+        self.messages = []
+
+    @property
+    def command_name(self):
+        return self._command
+
+    def execute(self, message):
+        self.messages.append(message)
+        return {"event": "handled", "command": self._command}
+
+
 def request(request_id="ghr-1", target="42"):
     return {
         "type": GUEST_HOST_REQUEST,
@@ -76,11 +91,36 @@ class GuestHostTerminalTests(IsolatedAsyncioTestCase):
         await self.manager._handle_guest_host_request(envelope)
         self.assertEqual(self.manager._control_channel.sent, [])
 
-    async def test_reserved_but_unimplemented_request_type_is_rejected(self):
+    async def test_enabled_request_without_registered_handler_is_rejected(self):
         envelope = request()
         envelope["command"] = "stop_proxmox_container"
         envelope["authorization"]["operation"] = "power.stop"
         await self.manager._handle_guest_host_request(envelope)
         ack, result = self.manager._control_channel.sent
-        self.assertFalse(ack["data"]["accepted"])
-        self.assertEqual(result["data"]["error_code"], "unsupported_request_type")
+        self.assertTrue(ack["data"]["accepted"])
+        self.assertEqual(result["data"]["error_code"], "handler_unavailable")
+
+    async def test_each_advertised_operation_delegates_to_existing_handler(self):
+        cases = (
+            ("start_proxmox_container", "power.start"),
+            ("stop_proxmox_container", "power.stop"),
+            ("restart_proxmox_container", "power.reboot"),
+            ("remove_proxmox_container", "delete"),
+            ("create_proxmox_container", "provision"),
+        )
+        for command, operation in cases:
+            with self.subTest(command=command):
+                handler = CommandRecordingHandler(self.manager._control_channel, {}, command)
+                self.manager._command_registry = Registry(handler)
+                self.manager._control_channel.sent.clear()
+                envelope = request(request_id=f"ghr-{command}")
+                envelope["command"] = command
+                envelope["authorization"]["operation"] = operation
+
+                await self.manager._handle_guest_host_request(envelope)
+
+                ack, result = self.manager._control_channel.sent
+                self.assertTrue(ack["data"]["accepted"])
+                self.assertTrue(result["data"]["success"])
+                self.assertEqual(len(handler.messages), 1)
+                self.assertEqual(handler.messages[0]["child_device_id"], "42")

portacode-2.0.2/portacode/tests/test_terminal_periodic_system_info.py

@@ -0,0 +1,59 @@
+import asyncio
+from types import SimpleNamespace
+from unittest.mock import AsyncMock
+
+import pytest
+
+from portacode.connection import terminal
+from portacode.connection.handlers.registry import CommandRegistry
+
+
+@pytest.mark.asyncio
+async def test_registry_coalesces_concurrent_system_info_dispatches():
+    started = asyncio.Event()
+    release = asyncio.Event()
+    calls = 0
+
+    class BlockingHandler:
+        async def handle(self, _message, _reply_channel):
+            nonlocal calls
+            calls += 1
+            started.set()
+            await release.wait()
+
+    registry = CommandRegistry(AsyncMock(), {})
+    registry._handlers["system_info"] = BlockingHandler()
+
+    assert await registry.dispatch("system_info", {}, None)
+    await asyncio.wait_for(started.wait(), timeout=0.1)
+    assert await registry.dispatch("system_info", {}, None)
+    assert calls == 1
+
+    inflight = registry._inflight_dispatches["system_info"]
+    release.set()
+    await asyncio.wait_for(inflight, timeout=0.1)
+
+
+@pytest.mark.asyncio
+async def test_periodic_system_info_uses_shared_registry(monkeypatch):
+    manager = object.__new__(terminal.TerminalManager)
+    manager._client_session_manager = SimpleNamespace(
+        has_interested_clients=lambda: True
+    )
+    manager._command_registry = SimpleNamespace(dispatch=AsyncMock(return_value=True))
+    monkeypatch.setattr(terminal, "SYSTEM_INFO_INTERVAL_S", 0.001)
+    periodic = asyncio.create_task(manager._periodic_system_info())
+
+    try:
+        async def wait_for_dispatch():
+            while not manager._command_registry.dispatch.await_count:
+                await asyncio.sleep(0.001)
+
+        await asyncio.wait_for(wait_for_dispatch(), timeout=0.1)
+        manager._command_registry.dispatch.assert_awaited_with(
+            "system_info", {}, None
+        )
+    finally:
+        periodic.cancel()
+        with pytest.raises(asyncio.CancelledError):
+            await periodic

{portacode-2.0.0.dev0 → portacode-2.0.2}/portacode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: portacode
-Version: 2.0.0.dev0
+Version: 2.0.2
 Summary: Device agent for the AI platform that builds, tests, deploys, and operates real software
 Home-page: https://portacode.com/
 Author: Meena Erian