portacode 1.5.31.dev1__tar.gz → 1.5.31.dev3__tar.gz

{portacode-1.5.31.dev1 → portacode-1.5.31.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: portacode
-Version: 1.5.31.dev1
+Version: 1.5.31.dev3
 Summary: Connect real machines to the Portacode AI development environment
 Home-page: https://github.com/portacode/portacode
 Author: Meena Erian

{portacode-1.5.31.dev1 → portacode-1.5.31.dev3}/portacode/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.5.31.dev1'
-__version_tuple__ = version_tuple = (1, 5, 31, 'dev1')
+__version__ = version = '1.5.31.dev3'
+__version_tuple__ = version_tuple = (1, 5, 31, 'dev3')
 
 __commit_id__ = commit_id = None

{portacode-1.5.31.dev1 → portacode-1.5.31.dev3}/portacode/connection/handlers/cloudflare_forwarding.py

@@ -10,6 +10,7 @@ import re
 import subprocess
 import threading
 import tempfile
+import time
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 from urllib.parse import urlparse
@@ -58,6 +59,16 @@ GLOBAL_SHELL_HOOK_PATHS = (
 MANAGED_BLOCK_BEGIN = "# >>> PORTACODE_EXPOSED_SERVICES >>>"
 MANAGED_BLOCK_END = "# <<< PORTACODE_EXPOSED_SERVICES <<<"
 
+
+def _timed_stage(operation_id: str, stage: str, started: float, **details: Any) -> None:
+    logger.info(
+        "Expose ports timing operation_id=%s stage=%s elapsed_s=%.3f details=%s",
+        operation_id,
+        stage,
+        time.monotonic() - started,
+        details,
+    )
+
 def _is_root() -> bool:
     return hasattr(os, "geteuid") and os.geteuid() == 0
 
@@ -301,11 +312,17 @@ def _route_dns(hostnames: List[str], tunnel_name: str) -> None:
         if hostname in seen:
             continue
         seen.add(hostname)
+        started = time.monotonic()
         try:
             _call_subprocess(
                 ["cloudflared", "tunnel", "route", "dns", "--overwrite-dns", tunnel_name, hostname],
                 check=True,
             )
+            logger.info(
+                "Expose ports timing stage=route_dns hostname=%s elapsed_s=%.3f",
+                hostname,
+                time.monotonic() - started,
+            )
         except subprocess.CalledProcessError as exc:
             stderr = (getattr(exc, "stderr", "") or "").strip()
             stdout = (getattr(exc, "stdout", "") or "").strip()
@@ -318,7 +335,14 @@ def _route_dns(hostnames: List[str], tunnel_name: str) -> None:
 
 def _reload_cloudflared_service() -> None:
     # Restart via init-system aware logic; sudo/root handled inside.
-    restart_service()
+    started = time.monotonic()
+    try:
+        restart_service()
+    finally:
+        logger.info(
+            "Expose ports timing stage=reload_cloudflared elapsed_s=%.3f",
+            time.monotonic() - started,
+        )
 
 
 def _load_tunnel_state() -> Dict[str, Any]:
@@ -349,20 +373,34 @@ def _apply_and_persist_forwarding_rules(
     if not domain or not tunnel_name:
         raise RuntimeError("Cloudflare domain or tunnel name missing from state.")
 
+    operation_id = f"apply-{time.monotonic_ns()}"
+    total_started = time.monotonic()
     requires_proxmox = any(rule["parsed"]["type"] == "device" for rule in rules)
     proxmox = node = None
     if requires_proxmox:
         infra_config = _ensure_infra_configured()
         proxmox = _connect_proxmox(infra_config)
         node = _get_node_from_config(infra_config)
+    _timed_stage(operation_id, "connect_proxmox", total_started, required=requires_proxmox)
 
+    started = time.monotonic()
     entries = _build_ingress_entries(rules, proxmox, node)
+    _timed_stage(operation_id, "build_ingress_entries", started, rule_count=len(rules))
+    started = time.monotonic()
     _write_cloudflared_config(tunnel_state, entries)
+    _timed_stage(operation_id, "write_cloudflared_config", started, entry_count=len(entries))
     hostnames = [entry["hostname"] for entry in entries if entry.get("hostname")]
     if hostnames:
+        started = time.monotonic()
         _route_dns(hostnames, tunnel_name)
+        _timed_stage(operation_id, "route_dns_all", started, hostname_count=len(hostnames))
+    started = time.monotonic()
     _reload_cloudflared_service()
+    _timed_stage(operation_id, "reload_cloudflared_call", started)
+    started = time.monotonic()
     state = persist_forwarding_state(rules)
+    _timed_stage(operation_id, "persist_forwarding_state", started, rule_count=len(rules))
+    _timed_stage(operation_id, "apply_total", total_started, rule_count=len(rules))
     return {
         "rules": _sanitize_rules(rules),
         "updated_at": state.get("updated_at"),
@@ -414,18 +452,48 @@ def _push_root_file_to_container(vmid: int, path: str, data: bytes, mode: int =
     try:
         parent = str(Path(path).parent)
         if parent not in {"", ".", "/"}:
+            started = time.monotonic()
             _run_pct_exec_check(vmid, ["mkdir", "-p", parent])
+            logger.info(
+                "Expose ports timing stage=pct_mkdir vmid=%s elapsed_s=%.3f",
+                vmid,
+                time.monotonic() - started,
+            )
+            started = time.monotonic()
             _run_pct_exec_check(vmid, ["chown", "root:root", parent])
+            logger.info(
+                "Expose ports timing stage=pct_chown_parent vmid=%s elapsed_s=%.3f",
+                vmid,
+                time.monotonic() - started,
+            )
         with tempfile.NamedTemporaryFile(delete=False) as tmp:
             tmp.write(data)
             tmp.flush()
             os.fsync(tmp.fileno())
             tmp_path = tmp.name
+        started = time.monotonic()
         res = _run_pct_push(vmid, tmp_path, path)
+        logger.info(
+            "Expose ports timing stage=pct_push vmid=%s elapsed_s=%.3f",
+            vmid,
+            time.monotonic() - started,
+        )
         if res.returncode != 0:
             raise RuntimeError(res.stderr or res.stdout or f"pct push returned {res.returncode}")
+        started = time.monotonic()
         _run_pct_exec_check(vmid, ["chown", "root:root", path])
+        logger.info(
+            "Expose ports timing stage=pct_chown_file vmid=%s elapsed_s=%.3f",
+            vmid,
+            time.monotonic() - started,
+        )
+        started = time.monotonic()
         _run_pct_exec_check(vmid, ["chmod", format(mode, "o"), path])
+        logger.info(
+            "Expose ports timing stage=pct_chmod_file vmid=%s elapsed_s=%.3f",
+            vmid,
+            time.monotonic() - started,
+        )
     finally:
         if tmp_path:
             try:
@@ -607,13 +675,29 @@ def _sync_exposed_services_into_container(
     proxmox: Any,
     node: str,
 ) -> None:
+    started = time.monotonic()
     vmid = _resolve_device_vmid(container_device_id, proxmox, node)
+    logger.info(
+        "Expose ports timing stage=resolve_target_vmid device_id=%s vmid=%s elapsed_s=%.3f",
+        container_device_id,
+        vmid,
+        time.monotonic() - started,
+    )
     services_payload = {
         "device_id": container_device_id,
         "exposed_services": exposed_ports,
     }
     json_data = (json.dumps(services_payload, indent=2) + "\n").encode("utf-8")
-    _push_root_file_to_container(vmid, EXPOSED_SERVICES_JSON_PATH, json_data, mode=0o644)
+    started = time.monotonic()
+    try:
+        _push_root_file_to_container(vmid, EXPOSED_SERVICES_JSON_PATH, json_data, mode=0o644)
+    finally:
+        logger.info(
+            "Expose ports timing stage=sync_container_metadata device_id=%s vmid=%s elapsed_s=%.3f",
+            container_device_id,
+            vmid,
+            time.monotonic() - started,
+        )
 
 
 def _rule_targets_container(rule: Dict[str, Any], container_device_id: str, domain: str) -> bool:
@@ -639,12 +723,19 @@ def set_container_forwarding_rules(
     container_device_id: Any,
     container_rules: List[Dict[str, Any]],
 ) -> Dict[str, Any]:
+    operation_started = time.monotonic()
     tunnel_state = _load_tunnel_state()
     domain = str(tunnel_state.get("domain") or "").strip().lower().rstrip(".")
     normalized_specs = _normalize_container_rule_specs(container_device_id, container_rules)
     normalized_device_id = str(container_device_id).strip()
 
     with _FORWARDING_UPDATE_LOCK:
+        lock_acquired = time.monotonic()
+        logger.info(
+            "Expose ports timing stage=lock_wait device_id=%s elapsed_s=%.3f",
+            normalized_device_id,
+            lock_acquired - operation_started,
+        )
         stored = load_forwarding_state().get("rules", [])
         existing_rules = _normalize_rules(stored, domain, from_storage=True)
         preserved_rules = [
@@ -676,16 +767,28 @@ def set_container_forwarding_rules(
         merged_rules = preserved_rules + new_rules
 
         # Ensure the child container receives updated exposure metadata first.
+        started = time.monotonic()
         infra_config = _ensure_infra_configured()
         proxmox = _connect_proxmox(infra_config)
         node = _get_node_from_config(infra_config)
+        logger.info(
+            "Expose ports timing stage=metadata_connect_proxmox device_id=%s elapsed_s=%.3f",
+            normalized_device_id,
+            time.monotonic() - started,
+        )
         try:
+            started = time.monotonic()
             _sync_exposed_services_into_container(
                 normalized_device_id,
                 exposed_ports,
                 proxmox,
                 node,
             )
+            logger.info(
+                "Expose ports timing stage=metadata_total device_id=%s elapsed_s=%.3f",
+                normalized_device_id,
+                time.monotonic() - started,
+            )
         except Exception:
             if exposed_ports:
                 raise
@@ -697,6 +800,13 @@ def set_container_forwarding_rules(
 
         persisted = _apply_and_persist_forwarding_rules(merged_rules, tunnel_state=tunnel_state)
 
+    logger.info(
+        "Expose ports timing stage=request_total device_id=%s elapsed_s=%.3f rule_count=%s",
+        normalized_device_id,
+        time.monotonic() - operation_started,
+        len(merged_rules),
+    )
+
     return {
         "device_id": normalized_device_id,
         "domain": domain,

{portacode-1.5.31.dev1 → portacode-1.5.31.dev3}/portacode/connection/handlers/proxmox_infra.py

@@ -53,6 +53,7 @@ CACHE_SOURCE_MARKER = "cache_source="
 CACHE_PARENT_MARKER = "cache_parent="
 _PROVISIONING_MAINTENANCE_LAST_RUN = 0.0
 PROVISIONING_MAINTENANCE_INTERVAL_S = 300
+PROXMOX_INVENTORY_RECONCILE_INTERVAL_S = 300
 # Keep reusable roots small while leaving enough room for the OS, Portacode,
 # Codex, and (on apt systems) Playwright Chromium to be installed. A request
 # below this size still builds at its requested size; if the software cannot
@@ -154,6 +155,7 @@ _MANAGED_CONTAINERS_STATE: Dict[str, Any] = {
     "initial_totals": {"ram_mib": 0, "disk_gib": 0, "cpu_share": 0.0},
     "records": {},
     "pending": {},
+    "revision": 0,
 }
 TEMPLATES_REFRESH_INTERVAL_S = 300
 _TEMPLATE_CACHE_LOCK = threading.Lock()
@@ -1340,9 +1342,47 @@ def _initialize_managed_containers_state(force: bool = False) -> Dict[str, Any]:
         _MANAGED_CONTAINERS_STATE["initial_totals"] = initial_totals
         _MANAGED_CONTAINERS_STATE["records"] = record_map
         _MANAGED_CONTAINERS_STATE["pending"] = {}
+        _MANAGED_CONTAINERS_STATE["revision"] = int(
+            _MANAGED_CONTAINERS_STATE.get("revision") or 0
+        ) + 1
     return _copy_summary(base_summary)
 
 
+def reconcile_managed_containers_inventory() -> Dict[str, Any]:
+    """Refresh Proxmox inventory without blocking or racing provisioning.
+
+    The comparatively expensive Proxmox API scan runs outside the state lock.
+    A revision check makes the final swap conditional: if a managed create,
+    delete, or record update occurred during the scan, the stale result is
+    discarded and the next periodic pass retries it. Pending reservations are
+    never replaced by reconciliation.
+    """
+    _initialize_managed_containers_state()
+    with _MANAGED_CONTAINERS_STATE_LOCK:
+        revision = int(_MANAGED_CONTAINERS_STATE.get("revision") or 0)
+        records = [record.copy() for record in _MANAGED_CONTAINERS_STATE.get("records", {}).values()]
+
+    config = _load_config()
+    if not config:
+        return {"refreshed": False, "reason": "not_configured"}
+    refreshed_summary = _build_full_container_summary(records, config)
+    refreshed_totals = {
+        "ram_mib": int(refreshed_summary.get("total_ram_mib") or 0),
+        "disk_gib": int(refreshed_summary.get("total_disk_gib") or 0),
+        "cpu_share": float(refreshed_summary.get("total_cpu_share") or 0.0),
+    }
+
+    with _MANAGED_CONTAINERS_STATE_LOCK:
+        if int(_MANAGED_CONTAINERS_STATE.get("revision") or 0) != revision:
+            return {"refreshed": False, "reason": "state_changed"}
+        _MANAGED_CONTAINERS_STATE["base_summary"] = refreshed_summary
+        _MANAGED_CONTAINERS_STATE["initial_totals"] = refreshed_totals
+    return {
+        "refreshed": True,
+        "inventory_updated_at": refreshed_summary.get("inventory_updated_at"),
+    }
+
+
 def _load_managed_container_records() -> List[Dict[str, Any]]:
     _ensure_containers_dir()
     records: List[Dict[str, Any]] = []
@@ -1668,10 +1708,17 @@ def _compose_managed_containers_summary(
         for entry in base_summary.get("containers", [])
         if entry.get("vmid") is not None
     }
+    missing_vmids = {
+        str(entry.get("vmid"))
+        for entry in base_summary.get("missing_containers", [])
+        if entry.get("vmid") is not None
+    }
     default_storage = summary.get("default_storage")
     merged_containers: List[Dict[str, Any]] = []
     for entry in managed_summary["containers"]:
         vmid = str(entry.get("vmid")) if entry.get("vmid") is not None else None
+        if vmid in missing_vmids:
+            continue
         base_entry = base_by_vmid.get(vmid) if vmid is not None else None
         if base_entry:
             merged = base_entry.copy()
@@ -2832,12 +2879,18 @@ def _register_container_record(vmid: int, payload: Dict[str, Any], reservation_i
         if reservation_id:
             _MANAGED_CONTAINERS_STATE["pending"].pop(reservation_id, None)
         _MANAGED_CONTAINERS_STATE["records"][str(vmid)] = payload.copy()
+        _MANAGED_CONTAINERS_STATE["revision"] = int(
+            _MANAGED_CONTAINERS_STATE.get("revision") or 0
+        ) + 1
 
 
 def _unregister_container_record(vmid: int) -> None:
     _initialize_managed_containers_state()
     with _MANAGED_CONTAINERS_STATE_LOCK:
         _MANAGED_CONTAINERS_STATE["records"].pop(str(vmid), None)
+        _MANAGED_CONTAINERS_STATE["revision"] = int(
+            _MANAGED_CONTAINERS_STATE.get("revision") or 0
+        ) + 1
 
 
 def _write_container_record(vmid: int, payload: Dict[str, Any], reservation_id: Optional[str] = None) -> None:

{portacode-1.5.31.dev1 → portacode-1.5.31.dev3}/portacode/connection/handlers/test_proxmox_infra.py

@@ -6,6 +6,7 @@ from unittest.mock import MagicMock, patch
 from portacode.connection.handlers.proxmox_infra import (
     RemoveProxmoxContainerHandler,
     _build_full_container_summary,
+    _compose_managed_containers_summary,
     _build_bootstrap_steps,
     _cacheable_bootstrap_steps,
     _claim_ctid_for_reservation,
@@ -26,11 +27,69 @@ from portacode.connection.handlers.proxmox_infra import (
     _running_portacode_version_is_prerelease,
     _require_successful_proxmox_task,
     _reserve_container_resources,
+    reconcile_managed_containers_inventory,
     _sanitize_project_paths,
 )
 
 
 class ProxmoxInfraHandlerTests(TestCase):
+    def test_reconciled_external_deletion_is_not_reinserted_from_local_record(self):
+        summary = _compose_managed_containers_summary(
+            [{"vmid": 144, "device_id": "42", "ram_mib": 2048, "disk_gib": 14, "cpus": 1}],
+            [],
+            {
+                "containers": [],
+                "missing_containers": [{"vmid": "144", "device_id": "42"}],
+                "allocated_ram_mib": 0,
+                "allocated_disk_gib": 0,
+                "allocated_cpu_share": 0,
+            },
+            {"ram_mib": 2048, "disk_gib": 14, "cpu_share": 1},
+        )
+
+        self.assertEqual(summary["containers"], [])
+        self.assertEqual(summary["missing_containers"][0]["vmid"], "144")
+
+    @patch("portacode.connection.handlers.proxmox_infra._build_full_container_summary")
+    @patch("portacode.connection.handlers.proxmox_infra._load_config", return_value={"node": "pve"})
+    def test_reconciliation_atomically_replaces_inventory_baseline(self, _config, build_summary):
+        refreshed = {"inventory_updated_at": "new", "total_ram_mib": 2, "total_disk_gib": 3, "total_cpu_share": 1}
+        build_summary.return_value = refreshed
+        state = {
+            "initialized": True, "base_summary": {"inventory_updated_at": "old"},
+            "initial_totals": {}, "records": {"144": {"vmid": 144}},
+            "pending": {"reservation": {"ram_mib": 1}}, "revision": 4,
+        }
+        with patch("portacode.connection.handlers.proxmox_infra._MANAGED_CONTAINERS_STATE", state):
+            result = reconcile_managed_containers_inventory()
+
+        self.assertTrue(result["refreshed"])
+        self.assertIs(state["base_summary"], refreshed)
+        self.assertIn("reservation", state["pending"])
+        self.assertEqual(state["revision"], 4)
+
+    @patch("portacode.connection.handlers.proxmox_infra._load_config", return_value={"node": "pve"})
+    def test_reconciliation_discards_scan_when_managed_state_changes(self, _config):
+        state = {
+            "initialized": True, "base_summary": {"inventory_updated_at": "old"},
+            "initial_totals": {}, "records": {"144": {"vmid": 144}},
+            "pending": {}, "revision": 7,
+        }
+
+        def concurrent_scan(_records, _config):
+            state["records"]["145"] = {"vmid": 145}
+            state["revision"] += 1
+            return {"inventory_updated_at": "stale scan"}
+
+        with patch("portacode.connection.handlers.proxmox_infra._MANAGED_CONTAINERS_STATE", state), patch(
+            "portacode.connection.handlers.proxmox_infra._build_full_container_summary",
+            side_effect=concurrent_scan,
+        ):
+            result = reconcile_managed_containers_inventory()
+
+        self.assertEqual(result, {"refreshed": False, "reason": "state_changed"})
+        self.assertEqual(state["base_summary"]["inventory_updated_at"], "old")
+
     def test_cpu_can_be_oversubscribed_when_ram_and_disk_are_available(self):
         state = {
             "initialized": True,

{portacode-1.5.31.dev1 → portacode-1.5.31.dev3}/portacode/connection/terminal.py

@@ -513,6 +513,15 @@ class TerminalManager:
             self._periodic_provisioning_template_maintenance()
         )
 
+        if getattr(self, "_proxmox_inventory_reconciliation_task", None):
+            try:
+                self._proxmox_inventory_reconciliation_task.cancel()
+            except Exception:
+                pass
+        self._proxmox_inventory_reconciliation_task = asyncio.create_task(
+            self._periodic_proxmox_inventory_reconciliation()
+        )
+
         # Start exposed-services file monitor for realtime updates.
         if getattr(self, "_exposed_services_task", None):
             try:
@@ -686,6 +695,24 @@ class TerminalManager:
                 logger.exception("Provisioning template maintenance failed: %s", exc)
             await asyncio.sleep(PROVISIONING_MAINTENANCE_INTERVAL_S)
 
+    async def _periodic_proxmox_inventory_reconciliation(self) -> None:
+        """Periodically detect changes made directly through Proxmox."""
+        from .handlers.proxmox_infra import (
+            PROXMOX_INVENTORY_RECONCILE_INTERVAL_S,
+            reconcile_managed_containers_inventory,
+        )
+
+        while True:
+            await asyncio.sleep(PROXMOX_INVENTORY_RECONCILE_INTERVAL_S)
+            try:
+                result = await asyncio.to_thread(reconcile_managed_containers_inventory)
+                if result.get("reason") == "state_changed":
+                    logger.debug("Discarded Proxmox inventory scan after concurrent state change")
+            except asyncio.CancelledError:
+                raise
+            except Exception as exc:
+                logger.warning("Proxmox inventory reconciliation failed safely: %s", exc)
+
     def _read_exposed_services_snapshot(self) -> Dict[str, Any]:
         path = EXPOSED_SERVICES_MONITOR_PATH
         if not os.path.exists(path):

{portacode-1.5.31.dev1 → portacode-1.5.31.dev3}/portacode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: portacode
-Version: 1.5.31.dev1
+Version: 1.5.31.dev3
 Summary: Connect real machines to the Portacode AI development environment
 Home-page: https://github.com/portacode/portacode
 Author: Meena Erian