portacode 1.4.17__py3-none-any.whl → 1.4.17.dev1__py3-none-any.whl

portacode/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.4.17'
-__version_tuple__ = version_tuple = (1, 4, 17)
+__version__ = version = '1.4.17.dev1'
+__version_tuple__ = version_tuple = (1, 4, 17, 'dev1')
 
 __commit_id__ = commit_id = None

portacode/connection/handlers/proxmox_infra.py

@@ -45,38 +45,15 @@ DNS_SERVER = "1.1.1.1"
 IFACES_PATH = Path("/etc/network/interfaces")
 SYSCTL_PATH = Path("/etc/sysctl.d/99-portacode-forward.conf")
 UNIT_DIR = Path("/etc/systemd/system")
-_MANAGED_CONTAINERS_STATE_LOCK = threading.Lock()
-_MANAGED_CONTAINERS_STATE: Dict[str, Any] = {
-    "initialized": False,
-    "base_summary": None,
-    "initial_totals": {"ram_mib": 0, "disk_gib": 0, "cpu_share": 0.0},
-    "records": {},
-    "pending": {},
-}
+_MANAGED_CONTAINERS_CACHE_TTL_S = 30.0
+_MANAGED_CONTAINERS_CACHE: Dict[str, Any] = {"timestamp": 0.0, "summary": None}
+_MANAGED_CONTAINERS_CACHE_LOCK = threading.Lock()
+_CAPACITY_LOCK = threading.Lock()
 TEMPLATES_REFRESH_INTERVAL_S = 300
 
 ProgressCallback = Callable[[int, int, Dict[str, Any], str, Optional[Dict[str, Any]]], None]
 
 
-def _emit_host_event(
-    handler: SyncHandler,
-    payload: Dict[str, Any],
-) -> None:
-    loop = handler.context.get("event_loop")
-    if not loop or loop.is_closed():
-        logger.debug("host event skipped (no event loop) event=%s", payload.get("event"))
-        return
-
-    future = asyncio.run_coroutine_threadsafe(handler.send_response(payload), loop)
-    future.add_done_callback(
-        lambda fut: logger.warning(
-            "Failed to emit host event %s: %s", payload.get("event"), fut.exception()
-        )
-        if fut.exception()
-        else None
-    )
-
-
 def _emit_progress_event(
     handler: SyncHandler,
     *,
@@ -598,76 +575,10 @@ def _ensure_containers_dir() -> None:
     CONTAINERS_DIR.mkdir(parents=True, exist_ok=True)
 
 
-def _copy_summary(summary: Dict[str, Any]) -> Dict[str, Any]:
-    snapshot = summary.copy()
-    containers = summary.get("containers")
-    if isinstance(containers, list):
-        snapshot["containers"] = [entry.copy() for entry in containers]
-    unmanaged = summary.get("unmanaged_containers")
-    if isinstance(unmanaged, list):
-        snapshot["unmanaged_containers"] = [entry.copy() for entry in unmanaged]
-    return snapshot
-
-
-def _refresh_container_statuses(records: List[Dict[str, Any]], config: Dict[str, Any] | None) -> None:
-    if not records or not config:
-        return
-    try:
-        proxmox = _connect_proxmox(config)
-        node = _get_node_from_config(config)
-        statuses = {
-            str(ct.get("vmid")): (ct.get("status") or "unknown").lower()
-            for ct in proxmox.nodes(node).lxc.get()
-        }
-    except Exception as exc:  # pragma: no cover - best effort
-        logger.debug("Failed to refresh container statuses: %s", exc)
-        return
-    for record in records:
-        vmid = record.get("vmid")
-        if vmid is None:
-            continue
-        try:
-            vmid_key = str(int(vmid))
-        except (ValueError, TypeError):
-            continue
-        status = statuses.get(vmid_key)
-        if status:
-            record["status"] = status
-
-
-def _initialize_managed_containers_state(force: bool = False) -> Dict[str, Any]:
-    with _MANAGED_CONTAINERS_STATE_LOCK:
-        if _MANAGED_CONTAINERS_STATE["initialized"] and not force:
-            base = _MANAGED_CONTAINERS_STATE["base_summary"]
-            return _copy_summary(base) if base else {}
-
-    config = _load_config()
-    records = _load_managed_container_records()
-    _refresh_container_statuses(records, config)
-    base_summary = _build_full_container_summary(records, config)
-    record_map: Dict[str, Dict[str, Any]] = {}
-    for record in records:
-        vmid = record.get("vmid")
-        if vmid is None:
-            continue
-        try:
-            record_map[str(int(vmid))] = record
-        except (TypeError, ValueError):
-            continue
-
-    initial_totals = {
-        "ram_mib": int(base_summary.get("total_ram_mib") or 0),
-        "disk_gib": int(base_summary.get("total_disk_gib") or 0),
-        "cpu_share": float(base_summary.get("total_cpu_share") or 0.0),
-    }
-
-    with _MANAGED_CONTAINERS_STATE_LOCK:
-        _MANAGED_CONTAINERS_STATE["initialized"] = True
-        _MANAGED_CONTAINERS_STATE["base_summary"] = base_summary
-        _MANAGED_CONTAINERS_STATE["initial_totals"] = initial_totals
-        _MANAGED_CONTAINERS_STATE["records"] = record_map
-        _MANAGED_CONTAINERS_STATE["pending"] = {}
-    return _copy_summary(base_summary)
+def _invalidate_managed_containers_cache() -> None:
+    with _MANAGED_CONTAINERS_CACHE_LOCK:
+        _MANAGED_CONTAINERS_CACHE["timestamp"] = 0.0
+        _MANAGED_CONTAINERS_CACHE["summary"] = None
 
 
 def _load_managed_container_records() -> List[Dict[str, Any]]:
@@ -867,131 +778,97 @@ def _build_full_container_summary(records: List[Dict[str, Any]], config: Dict[st
     return summary
 
 
-def _pending_totals(pending: Iterable[Dict[str, Any]]) -> Tuple[int, int, float]:
-    ram_total = 0
-    disk_total = 0
-    cpu_total = 0.0
-    for entry in pending:
-        ram_total += int(entry.get("ram_mib") or 0)
-        disk_total += int(entry.get("disk_gib") or 0)
-        cpu_total += float(entry.get("cpu_share") or 0.0)
-    return ram_total, disk_total, cpu_total
-
-
-def _compose_managed_containers_summary(
-    records: Iterable[Dict[str, Any]],
-    pending: Iterable[Dict[str, Any]],
-    base_summary: Dict[str, Any],
-    initial_totals: Dict[str, Any],
-) -> Dict[str, Any]:
-    managed_summary = _build_managed_containers_summary(list(records))
-    summary = _copy_summary(base_summary)
-    base_by_vmid = {
-        str(entry.get("vmid")): entry
-        for entry in base_summary.get("containers", [])
-        if entry.get("vmid") is not None
+def _compute_free_resources(summary: Dict[str, Any]) -> Dict[str, float]:
+    """Return free resources using the same math as the dashboard."""
+    free_ram = None
+    free_disk = None
+    free_cpu = None
+    host_ram = summary.get("host_total_ram_mib")
+    alloc_ram = summary.get("allocated_ram_mib")
+    if host_ram is not None and alloc_ram is not None:
+        free_ram = max(float(host_ram) - float(alloc_ram), 0.0)
+
+    host_disk = summary.get("host_total_disk_gib")
+    alloc_disk = summary.get("allocated_disk_gib")
+    if host_disk is not None and alloc_disk is not None:
+        free_disk = max(float(host_disk) - float(alloc_disk), 0.0)
+
+    host_cpu = summary.get("host_total_cpu_cores")
+    alloc_cpu = summary.get("allocated_cpu_share")
+    if host_cpu is not None and alloc_cpu is not None:
+        free_cpu = max(float(host_cpu) - float(alloc_cpu), 0.0)
+
+    return {
+        "ram_mib": free_ram,
+        "disk_gib": free_disk,
+        "cpu_share": free_cpu,
     }
-    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
-        base_entry = base_by_vmid.get(vmid) if vmid is not None else None
-        if base_entry:
-            merged = base_entry.copy()
-            merged.update(entry)
-        else:
-            merged = entry.copy()
-            merged.setdefault("managed", True)
-            merged.setdefault("type", "lxc")
-            if default_storage and merged.get("storage"):
-                merged["matches_default_storage"] = (
-                    str(merged["storage"]).lower() == str(default_storage).lower()
-                )
-        merged_containers.append(merged)
-    summary["updated_at"] = managed_summary["updated_at"]
-    summary["count"] = managed_summary["count"]
-    summary["total_ram_mib"] = managed_summary["total_ram_mib"]
-    summary["total_disk_gib"] = managed_summary["total_disk_gib"]
-    summary["total_cpu_share"] = managed_summary["total_cpu_share"]
-    summary["containers"] = merged_containers
-
-    pending_ram, pending_disk, pending_cpu = _pending_totals(pending)
-    delta_ram = managed_summary["total_ram_mib"] - int(initial_totals.get("ram_mib") or 0)
-    delta_disk = managed_summary["total_disk_gib"] - int(initial_totals.get("disk_gib") or 0)
-    delta_cpu = managed_summary["total_cpu_share"] - float(initial_totals.get("cpu_share") or 0.0)
-
-    if "allocated_ram_mib" in summary and summary.get("allocated_ram_mib") is not None:
-        summary["allocated_ram_mib"] = round(float(summary["allocated_ram_mib"]) + delta_ram + pending_ram, 2)
-    if "allocated_disk_gib" in summary and summary.get("allocated_disk_gib") is not None:
-        summary["allocated_disk_gib"] = round(float(summary["allocated_disk_gib"]) + delta_disk + pending_disk, 2)
-    if "allocated_cpu_share" in summary and summary.get("allocated_cpu_share") is not None:
-        summary["allocated_cpu_share"] = round(float(summary["allocated_cpu_share"]) + delta_cpu + pending_cpu, 2)
-
-    if "available_ram_mib" in summary and summary.get("available_ram_mib") is not None:
-        available_ram = float(summary["available_ram_mib"]) - delta_ram - pending_ram
-        summary["available_ram_mib"] = max(int(available_ram), 0)
-    if "available_disk_gib" in summary and summary.get("available_disk_gib") is not None:
-        available_disk = float(summary["available_disk_gib"]) - delta_disk - pending_disk
-        summary["available_disk_gib"] = max(available_disk, 0.0)
-    if "available_cpu_share" in summary and summary.get("available_cpu_share") is not None:
-        available_cpu = float(summary["available_cpu_share"]) - delta_cpu - pending_cpu
-        summary["available_cpu_share"] = max(available_cpu, 0.0)
 
-    return summary
 
+def _assert_capacity_for_payload(payload: Dict[str, Any], summary: Dict[str, Any]) -> None:
+    """Validate requested container resources against current free capacity."""
+    free = _compute_free_resources(summary)
+    shortages: List[str] = []
 
-def _get_managed_containers_summary(force: bool = False) -> Dict[str, Any]:
-    _initialize_managed_containers_state(force=force)
-    with _MANAGED_CONTAINERS_STATE_LOCK:
-        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())
-        initial_totals = _MANAGED_CONTAINERS_STATE.get("initial_totals", {})
-    if not base_summary:
-        return {}
-    return _compose_managed_containers_summary(records, pending, base_summary, initial_totals)
-
-
-def _reserve_container_resources(payload: Dict[str, Any], *, device_id: str, request_id: Optional[str]) -> str:
-    _initialize_managed_containers_state()
-    ram_mib = int(payload.get("ram_mib") or 0)
-    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:
-        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())
-        initial_totals = _MANAGED_CONTAINERS_STATE.get("initial_totals", {})
-        summary = _compose_managed_containers_summary(records, pending, base_summary, initial_totals)
-
-        available_ram = summary.get("available_ram_mib")
-        if available_ram is not None and ram_mib > available_ram:
-            raise RuntimeError("Not enough RAM to create this container.")
-        available_disk = summary.get("available_disk_gib")
-        if available_disk is not None and disk_gib > available_disk:
-            raise RuntimeError("Not enough disk space to create this container.")
-        available_cpu = summary.get("available_cpu_share")
-        if available_cpu is not None and cpu_share > available_cpu:
-            raise RuntimeError("Not enough CPU capacity to create this container.")
-
-        _MANAGED_CONTAINERS_STATE["pending"][reservation_id] = {
-            "reservation_id": reservation_id,
-            "device_id": device_id,
-            "request_id": request_id,
-            "ram_mib": ram_mib,
-            "disk_gib": disk_gib,
-            "cpu_share": cpu_share,
-            "created_at": datetime.utcnow().isoformat() + "Z",
-        }
-    return reservation_id
+    req_ram = float(payload.get("ram_mib", 0))
+    free_ram = free.get("ram_mib")
+    if free_ram is not None and req_ram > free_ram:
+        shortages.append(f"RAM (need {int(req_ram)} MiB, free {int(free_ram)} MiB)")
 
+    req_disk = float(payload.get("disk_gib", 0))
+    free_disk = free.get("disk_gib")
+    if free_disk is not None and req_disk > free_disk:
+        shortages.append(f"Disk (need {req_disk:.1f} GiB, free {free_disk:.1f} GiB)")
 
-def _release_container_reservation(reservation_id: Optional[str]) -> None:
-    if not reservation_id:
-        return
-    with _MANAGED_CONTAINERS_STATE_LOCK:
-        _MANAGED_CONTAINERS_STATE.get("pending", {}).pop(reservation_id, None)
+    req_cpu = float(payload.get("cpus", 0))
+    free_cpu = free.get("cpu_share")
+    if free_cpu is not None and req_cpu > free_cpu:
+        shortages.append(f"CPU (need {req_cpu:.2f} vCPU, free {free_cpu:.2f} vCPU)")
+
+    if shortages:
+        raise RuntimeError(f"Insufficient resources: {', '.join(shortages)}")
+
+
+def _get_managed_containers_summary(force: bool = False) -> Dict[str, Any]:
+    def _refresh_container_statuses(records: List[Dict[str, Any]], config: Dict[str, Any] | None) -> None:
+        if not records or not config:
+            return
+        try:
+            proxmox = _connect_proxmox(config)
+            node = _get_node_from_config(config)
+            statuses = {
+                str(ct.get("vmid")): (ct.get("status") or "unknown").lower()
+                for ct in proxmox.nodes(node).lxc.get()
+            }
+        except Exception as exc:  # pragma: no cover - best effort
+            logger.debug("Failed to refresh container statuses: %s", exc)
+            return
+        for record in records:
+            vmid = record.get("vmid")
+            if vmid is None:
+                continue
+            try:
+                vmid_key = str(int(vmid))
+            except (ValueError, TypeError):
+                continue
+            status = statuses.get(vmid_key)
+            if status:
+                record["status"] = status
+
+    now = time.monotonic()
+    with _MANAGED_CONTAINERS_CACHE_LOCK:
+        cache_ts = _MANAGED_CONTAINERS_CACHE["timestamp"]
+        cached = _MANAGED_CONTAINERS_CACHE["summary"]
+    if not force and cached and now - cache_ts < _MANAGED_CONTAINERS_CACHE_TTL_S:
+        return cached
+    config = _load_config()
+    records = _load_managed_container_records()
+    _refresh_container_statuses(records, config)
+    summary = _build_full_container_summary(records, config)
+    with _MANAGED_CONTAINERS_CACHE_LOCK:
+        _MANAGED_CONTAINERS_CACHE["timestamp"] = now
+        _MANAGED_CONTAINERS_CACHE["summary"] = summary
+    return summary
 
 
 def _format_rootfs(storage: str, disk_gib: int, storage_type: str) -> str:
@@ -1277,6 +1154,20 @@ def _start_container(proxmox: Any, node: str, vmid: int) -> Tuple[Dict[str, Any]
         logger.info("Container %s already running (%ss)", vmid, uptime)
         return status, 0.0
 
+    # Validate capacity using the same math as the dashboard and serialize allocation.
+    with _CAPACITY_LOCK:
+        summary = _get_managed_containers_summary(force=True)
+        cfg = proxmox.nodes(node).lxc(vmid).config.get()
+        payload = {
+            "ram_mib": _to_mib(cfg.get("memory")),
+            "disk_gib": _pick_container_disk_gib("lxc", cfg, {"rootfs": cfg.get("rootfs")}),
+            "cpus": _pick_container_cpu_share("lxc", cfg, {}),
+        }
+        try:
+            _assert_capacity_for_payload(payload, summary)
+        except RuntimeError as exc:
+            raise RuntimeError(f"Not enough resources to start container {vmid}: {exc}") from exc
+
     upid = proxmox.nodes(node).lxc(vmid).status.start.post()
     return _wait_for_task(proxmox, node, upid)
 
@@ -1294,25 +1185,11 @@ def _delete_container(proxmox: Any, node: str, vmid: int) -> Tuple[Dict[str, Any
     return _wait_for_task(proxmox, node, upid)
 
 
-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:
-        if reservation_id:
-            _MANAGED_CONTAINERS_STATE["pending"].pop(reservation_id, None)
-        _MANAGED_CONTAINERS_STATE["records"][str(vmid)] = payload.copy()
-
-
-def _unregister_container_record(vmid: int) -> None:
-    _initialize_managed_containers_state()
-    with _MANAGED_CONTAINERS_STATE_LOCK:
-        _MANAGED_CONTAINERS_STATE["records"].pop(str(vmid), None)
-
-
-def _write_container_record(vmid: int, payload: Dict[str, Any], reservation_id: Optional[str] = None) -> None:
+def _write_container_record(vmid: int, payload: Dict[str, Any]) -> None:
     _ensure_containers_dir()
     path = CONTAINERS_DIR / f"ct-{vmid}.json"
     path.write_text(json.dumps(payload, indent=2), encoding="utf-8")
-    _register_container_record(vmid, payload, reservation_id=reservation_id)
+    _invalidate_managed_containers_cache()
 
 
 def _read_container_record(vmid: int) -> Dict[str, Any]:
@@ -1332,7 +1209,7 @@ def _remove_container_record(vmid: int) -> None:
     path = CONTAINERS_DIR / f"ct-{vmid}.json"
     if path.exists():
         path.unlink()
-    _unregister_container_record(vmid)
+        _invalidate_managed_containers_cache()
 
 
 def _build_container_payload(message: Dict[str, Any], config: Dict[str, Any]) -> Dict[str, Any]:
@@ -1438,15 +1315,6 @@ def _su_command(user: str, command: str) -> str:
     return f"su - {user} -s /bin/sh -c {shlex.quote(command)}"
 
 
-def _resolve_portacode_cli_path(vmid: int, user: str) -> str:
-    """Resolve the full path to the portacode CLI inside the container."""
-    res = _run_pct(vmid, _su_command(user, "command -v portacode"))
-    path = (res.get("stdout") or "").strip()
-    if path:
-        return path
-    return "portacode"
-
-
 def _run_pct_check(vmid: int, cmd: str) -> Dict[str, Any]:
     res = _run_pct(vmid, cmd)
     if res["returncode"] != 0:
@@ -1889,14 +1757,12 @@ def _allocate_vmid(proxmox: Any) -> int:
     return int(proxmox.cluster.nextid.get())
 
 
-def _instantiate_container(
-    proxmox: Any, node: str, payload: Dict[str, Any], vmid: Optional[int] = None
-) -> Tuple[int, float]:
+def _instantiate_container(proxmox: Any, node: str, payload: Dict[str, Any]) -> Tuple[int, float]:
     from proxmoxer.core import ResourceException
 
     storage_type = _get_storage_type(proxmox.nodes(node).storage.get(), payload["storage"])
     rootfs = _format_rootfs(payload["storage"], payload["disk_gib"], storage_type)
-    vmid = vmid or _allocate_vmid(proxmox)
+    vmid = _allocate_vmid(proxmox)
     if not payload.get("hostname"):
         payload["hostname"] = f"ct{vmid}"
     try:
@@ -1928,43 +1794,6 @@ def _instantiate_container(
         raise RuntimeError(f"Failed to create container: {exc}") from exc
 
 
-def _cleanup_failed_container(
-    proxmox: Any, node: str, vmid: int, provisioning_id: Optional[str]
-) -> None:
-    from proxmoxer.core import ResourceException
-
-    try:
-        cfg = proxmox.nodes(node).lxc(str(vmid)).config.get()
-    except ResourceException as exc:
-        msg = str(exc).lower()
-        if "does not exist" in msg or "not found" in msg:
-            return
-        logger.warning("Failed to inspect container %s after create failure: %s", vmid, exc)
-        return
-    except Exception as exc:  # pragma: no cover - best effort
-        logger.warning("Failed to inspect container %s after create failure: %s", vmid, exc)
-        return
-
-    description = (cfg or {}).get("description") or ""
-    if provisioning_id and provisioning_id not in description:
-        logger.warning(
-            "Skipping cleanup for vmid=%s; provisioning marker mismatch", vmid
-        )
-        return
-
-    try:
-        status = proxmox.nodes(node).lxc(str(vmid)).status.current.get()
-        if status.get("status") == "running":
-            _stop_container(proxmox, node, vmid)
-    except Exception as exc:  # pragma: no cover - best effort
-        logger.warning("Failed to stop container %s after create failure: %s", vmid, exc)
-
-    try:
-        _delete_container(proxmox, node, vmid)
-    except Exception as exc:  # pragma: no cover - best effort
-        logger.warning("Failed to delete container %s after create failure: %s", vmid, exc)
-
-
 class CreateProxmoxContainerHandler(SyncHandler):
     """Provision a new managed LXC container via the Proxmox API."""
 
@@ -2067,281 +1896,226 @@ class CreateProxmoxContainerHandler(SyncHandler):
             _validate_environment,
         )
 
-        node = config.get("node") or DEFAULT_NODE_NAME
-        payload = _build_container_payload(message, config)
-        payload["cpulimit"] = float(payload["cpus"])
-        payload["cores"] = int(max(math.ceil(payload["cpus"]), 1))
-        payload["memory"] = int(payload["ram_mib"])
-        payload["node"] = node
+        def _create_container():
+            proxmox = _connect_proxmox(config)
+            node = config.get("node") or DEFAULT_NODE_NAME
+            payload = _build_container_payload(message, config)
+            payload["cpulimit"] = float(payload["cpus"])
+            payload["cores"] = int(max(math.ceil(payload["cpus"]), 1))
+            payload["memory"] = int(payload["ram_mib"])
+            payload["node"] = node
+            # Validate against current free resources (same math as dashboard charts) with serialization.
+            with _CAPACITY_LOCK:
+                summary = _get_managed_containers_summary(force=True)
+                try:
+                    _assert_capacity_for_payload(payload, summary)
+                except RuntimeError as exc:
+                    raise RuntimeError(f"Not enough resources to create the container safely: {exc}") from exc
+                vmid, _ = _instantiate_container(proxmox, node, payload)
+            logger.debug(
+                "Provisioning container node=%s template=%s ram=%s cpu=%s storage=%s",
+                node,
+                payload["template"],
+                payload["ram_mib"],
+                payload["cpus"],
+                payload["storage"],
+            )
+            payload["vmid"] = vmid
+            payload["created_at"] = datetime.utcnow().isoformat() + "Z"
+            payload["status"] = "creating"
+            payload["device_id"] = device_id
+            _write_container_record(vmid, payload)
+            return proxmox, node, vmid, payload
+
+        proxmox, node, vmid, payload = _run_lifecycle_step(
+            "create_container",
+            "Creating container",
+            "Provisioning the LXC container…",
+            "Container created.",
+            _create_container,
+        )
+
+        def _start_container_step():
+            _start_container(proxmox, node, vmid)
 
-        reservation_id = _reserve_container_resources(
-            payload, device_id=device_id, request_id=request_id
+        _run_lifecycle_step(
+            "start_container",
+            "Starting container",
+            "Booting the container…",
+            "Container startup completed.",
+            _start_container_step,
         )
-        provisioning_id = secrets.token_hex(6)
-        payload["description"] = f"{payload.get('description', MANAGED_MARKER)};provisioning_id={provisioning_id}"
+        _update_container_record(vmid, {"status": "running"})
 
-        def _provision_background() -> None:
-            nonlocal current_step_index
-            proxmox: Any = None
-            vmid: Optional[int] = None
-            created_record = False
-            try:
-                def _create_container():
-                    nonlocal proxmox, vmid, created_record
-                    proxmox = _connect_proxmox(config)
-                    logger.debug(
-                        "Provisioning container node=%s template=%s ram=%s cpu=%s storage=%s",
-                        node,
-                        payload["template"],
-                        payload["ram_mib"],
-                        payload["cpus"],
-                        payload["storage"],
-                    )
-                    try:
-                        vmid = _allocate_vmid(proxmox)
-                        vmid, _ = _instantiate_container(proxmox, node, payload, vmid=vmid)
-                    except Exception:
-                        _release_container_reservation(reservation_id)
-                        if vmid is not None:
-                            _cleanup_failed_container(proxmox, node, vmid, provisioning_id)
-                        raise
-                    payload["vmid"] = vmid
-                    payload["created_at"] = datetime.utcnow().isoformat() + "Z"
-                    payload["status"] = "creating"
-                    payload["device_id"] = device_id
-                    try:
-                        _write_container_record(vmid, payload, reservation_id=reservation_id)
-                        created_record = True
-                    except Exception:
-                        _release_container_reservation(reservation_id)
-                        _cleanup_failed_container(proxmox, node, vmid, provisioning_id)
-                        raise
-                    return proxmox, node, vmid, payload
-
-                proxmox, _, vmid, payload_local = _run_lifecycle_step(
-                    "create_container",
-                    "Creating container",
-                    "Provisioning the LXC container…",
-                    "Container created.",
-                    _create_container,
-                )
+        def _bootstrap_progress_callback(
+            step_index: int,
+            total: int,
+            step: Dict[str, Any],
+            status: str,
+            result: Optional[Dict[str, Any]],
+        ):
+            label = step.get("display_name") or _friendly_step_label(step.get("name", "bootstrap"))
+            error_summary = (result or {}).get("error_summary") or (result or {}).get("error")
+            attempt = (result or {}).get("attempt")
+            if status == "in_progress":
+                message_text = f"{label} is running…"
+            elif status == "completed":
+                message_text = f"{label} completed."
+            elif status == "retrying":
+                attempt_desc = f" (attempt {attempt})" if attempt else ""
+                message_text = f"{label} failed{attempt_desc}; retrying…"
+            else:
+                message_text = f"{label} failed"
+                if error_summary:
+                    message_text += f": {error_summary}"
+            details: Dict[str, Any] = {}
+            if attempt:
+                details["attempt"] = attempt
+            if error_summary:
+                details["error_summary"] = error_summary
+            _emit_progress_event(
+                self,
+                step_index=step_index,
+                total_steps=total,
+                step_name=step.get("name", "bootstrap"),
+                step_label=label,
+                status=status,
+                message=message_text,
+                phase="bootstrap",
+                request_id=request_id,
+                details=details or None,
+                on_behalf_of_device=device_id,
+            )
 
-                def _start_container_step():
-                    _start_container(proxmox, node, vmid)
+        public_key, steps = _bootstrap_portacode(
+            vmid,
+            payload["username"],
+            payload["password"],
+            payload["ssh_public_key"],
+            steps=bootstrap_steps,
+            progress_callback=_bootstrap_progress_callback,
+            start_index=current_step_index,
+            total_steps=total_steps,
+            default_public_key=device_public_key if has_device_keypair else None,
+        )
+        current_step_index += len(bootstrap_steps)
+
+        service_installed = False
+        if has_device_keypair:
+            logger.info(
+                "deploying dashboard-provided Portacode keypair (device_id=%s) into container %s",
+                device_id,
+                vmid,
+            )
+            _deploy_device_keypair(
+                vmid,
+                payload["username"],
+                device_private_key,
+                device_public_key,
+            )
+            service_installed = True
+            service_start_index = current_step_index
 
-                _run_lifecycle_step(
-                    "start_container",
-                    "Starting container",
-                    "Booting the container…",
-                    "Container startup completed.",
-                    _start_container_step,
-                )
-                _update_container_record(vmid, {"status": "running"})
-
-                def _bootstrap_progress_callback(
-                    step_index: int,
-                    total: int,
-                    step: Dict[str, Any],
-                    status: str,
-                    result: Optional[Dict[str, Any]],
-                ):
-                    label = step.get("display_name") or _friendly_step_label(step.get("name", "bootstrap"))
-                    error_summary = (result or {}).get("error_summary") or (result or {}).get("error")
-                    attempt = (result or {}).get("attempt")
-                    if status == "in_progress":
-                        message_text = f"{label} is running…"
-                    elif status == "completed":
-                        message_text = f"{label} completed."
-                    elif status == "retrying":
-                        attempt_desc = f" (attempt {attempt})" if attempt else ""
-                        message_text = f"{label} failed{attempt_desc}; retrying…"
-                    else:
-                        message_text = f"{label} failed"
-                        if error_summary:
-                            message_text += f": {error_summary}"
-                    details: Dict[str, Any] = {}
-                    if attempt:
-                        details["attempt"] = attempt
-                    if error_summary:
-                        details["error_summary"] = error_summary
-                    _emit_progress_event(
-                        self,
-                        step_index=step_index,
-                        total_steps=total,
-                        step_name=step.get("name", "bootstrap"),
-                        step_label=label,
-                        status=status,
-                        message=message_text,
-                        phase="bootstrap",
-                        request_id=request_id,
-                        details=details or None,
-                        on_behalf_of_device=device_id,
-                    )
-
-                public_key, steps = _bootstrap_portacode(
-                    vmid,
-                    payload_local["username"],
-                    payload_local["password"],
-                    payload_local["ssh_public_key"],
-                    steps=bootstrap_steps,
-                    progress_callback=_bootstrap_progress_callback,
-                    start_index=current_step_index,
-                    total_steps=total_steps,
-                    default_public_key=device_public_key if has_device_keypair else None,
-                )
-                current_step_index += len(bootstrap_steps)
-
-                service_installed = False
-                if has_device_keypair:
-                    logger.info(
-                        "deploying dashboard-provided Portacode keypair (device_id=%s) into container %s",
-                        device_id,
-                        vmid,
-                    )
-                    _deploy_device_keypair(
-                        vmid,
-                        payload_local["username"],
-                        device_private_key,
-                        device_public_key,
-                    )
-                    service_installed = True
-                    service_start_index = current_step_index
-
-                    auth_step_name = "setup_device_authentication"
-                    auth_label = "Setting up device authentication"
-                    _emit_progress_event(
-                        self,
-                        step_index=service_start_index,
-                        total_steps=total_steps,
-                        step_name=auth_step_name,
-                        step_label=auth_label,
-                        status="in_progress",
-                        message="Notifying the server of the new device…",
-                        phase="service",
-                        request_id=request_id,
-                        on_behalf_of_device=device_id,
-                    )
-                    _emit_progress_event(
-                        self,
-                        step_index=service_start_index,
-                        total_steps=total_steps,
-                        step_name=auth_step_name,
-                        step_label=auth_label,
-                        status="completed",
-                        message="Authentication metadata recorded.",
-                        phase="service",
-                        request_id=request_id,
-                        on_behalf_of_device=device_id,
-                    )
-
-                    install_step = service_start_index + 1
-                    install_label = "Launching Portacode service"
-                    _emit_progress_event(
-                        self,
-                        step_index=install_step,
-                        total_steps=total_steps,
-                        step_name="launch_portacode_service",
-                        step_label=install_label,
-                        status="in_progress",
-                        message="Running sudo portacode service install…",
-                        phase="service",
-                        request_id=request_id,
-                        on_behalf_of_device=device_id,
-                    )
-
-                    cli_path = _resolve_portacode_cli_path(vmid, payload_local["username"])
-                    cmd = _su_command(
-                        payload_local["username"],
-                        f"sudo -S {shlex.quote(cli_path)} service install",
-                    )
-                    res = _run_pct(vmid, cmd, input_text=payload_local["password"] + "\n")
-
-                    if res["returncode"] != 0:
-                        _emit_progress_event(
-                            self,
-                            step_index=install_step,
-                            total_steps=total_steps,
-                            step_name="launch_portacode_service",
-                            step_label=install_label,
-                            status="failed",
-                            message=f"{install_label} failed: {res.get('stderr') or res.get('stdout')}",
-                            phase="service",
-                            request_id=request_id,
-                            details={
-                                "stderr": res.get("stderr"),
-                                "stdout": res.get("stdout"),
-                            },
-                            on_behalf_of_device=device_id,
-                        )
-                        raise RuntimeError(res.get("stderr") or res.get("stdout") or "Service install failed")
-
-                    _emit_progress_event(
-                        self,
-                        step_index=install_step,
-                        total_steps=total_steps,
-                        step_name="launch_portacode_service",
-                        step_label=install_label,
-                        status="completed",
-                        message="Portacode service install finished.",
-                        phase="service",
-                        request_id=request_id,
-                        on_behalf_of_device=device_id,
-                    )
-
-                    logger.info(
-                        "create_proxmox_container: portacode service install completed inside ct %s", vmid
-                    )
-
-                    current_step_index += 2
-
-                _emit_host_event(
-                    self,
-                    {
-                        "event": "proxmox_container_created",
-                        "success": True,
-                        "message": f"Container {vmid} is ready and Portacode key captured.",
-                        "ctid": str(vmid),
-                        "public_key": public_key,
-                        "container": {
-                            "vmid": vmid,
-                            "hostname": payload_local["hostname"],
-                            "template": payload_local["template"],
-                            "storage": payload_local["storage"],
-                            "disk_gib": payload_local["disk_gib"],
-                            "ram_mib": payload_local["ram_mib"],
-                            "cpus": payload_local["cpus"],
-                        },
-                        "setup_steps": steps,
-                        "device_id": device_id,
-                        "on_behalf_of_device": device_id,
-                        "service_installed": service_installed,
-                        "request_id": request_id,
-                    },
-                )
-            except Exception as exc:
-                if reservation_id and not created_record:
-                    _release_container_reservation(reservation_id)
-                if vmid is not None and proxmox and node:
-                    _cleanup_failed_container(proxmox, node, vmid, provisioning_id)
-                    _remove_container_record(vmid)
-                _emit_host_event(
+            auth_step_name = "setup_device_authentication"
+            auth_label = "Setting up device authentication"
+            _emit_progress_event(
+                self,
+                step_index=service_start_index,
+                total_steps=total_steps,
+                step_name=auth_step_name,
+                step_label=auth_label,
+                status="in_progress",
+                message="Notifying the server of the new device…",
+                phase="service",
+                request_id=request_id,
+                on_behalf_of_device=device_id,
+            )
+            _emit_progress_event(
+                self,
+                step_index=service_start_index,
+                total_steps=total_steps,
+                step_name=auth_step_name,
+                step_label=auth_label,
+                status="completed",
+                message="Authentication metadata recorded.",
+                phase="service",
+                request_id=request_id,
+                on_behalf_of_device=device_id,
+            )
+
+            install_step = service_start_index + 1
+            install_label = "Launching Portacode service"
+            _emit_progress_event(
+                self,
+                step_index=install_step,
+                total_steps=total_steps,
+                step_name="launch_portacode_service",
+                step_label=install_label,
+                status="in_progress",
+                message="Running sudo portacode service install…",
+                phase="service",
+                request_id=request_id,
+                on_behalf_of_device=device_id,
+            )
+
+            cmd = _su_command(payload["username"], "sudo -S portacode service install")
+            res = _run_pct(vmid, cmd, input_text=payload["password"] + "\n")
+
+            if res["returncode"] != 0:
+                _emit_progress_event(
                     self,
-                    {
-                        "event": "error",
-                        "message": str(exc),
-                        "device_id": device_id,
-                        "request_id": request_id,
+                    step_index=install_step,
+                    total_steps=total_steps,
+                    step_name="launch_portacode_service",
+                    step_label=install_label,
+                    status="failed",
+                    message=f"{install_label} failed: {res.get('stderr') or res.get('stdout')}",
+                    phase="service",
+                    request_id=request_id,
+                    details={
+                        "stderr": res.get("stderr"),
+                        "stdout": res.get("stdout"),
                     },
+                    on_behalf_of_device=device_id,
                 )
+                raise RuntimeError(res.get("stderr") or res.get("stdout") or "Service install failed")
 
-        threading.Thread(target=_provision_background, daemon=True).start()
+            _emit_progress_event(
+                self,
+                step_index=install_step,
+                total_steps=total_steps,
+                step_name="launch_portacode_service",
+                step_label=install_label,
+                status="completed",
+                message="Portacode service install finished.",
+                phase="service",
+                request_id=request_id,
+                on_behalf_of_device=device_id,
+            )
+
+            logger.info("create_proxmox_container: portacode service install completed inside ct %s", vmid)
+
+            current_step_index += 2
 
         return {
-            "event": "proxmox_container_accepted",
+            "event": "proxmox_container_created",
             "success": True,
-            "message": "Provisioning accepted; resources reserved.",
+            "message": f"Container {vmid} is ready and Portacode key captured.",
+            "ctid": str(vmid),
+            "public_key": public_key,
+            "container": {
+                "vmid": vmid,
+                "hostname": payload["hostname"],
+                "template": payload["template"],
+                "storage": payload["storage"],
+                "disk_gib": payload["disk_gib"],
+                "ram_mib": payload["ram_mib"],
+                "cpus": payload["cpus"],
+            },
+            "setup_steps": steps,
             "device_id": device_id,
-            "request_id": request_id,
+            "on_behalf_of_device": device_id,
+            "service_installed": service_installed,
         }
 
 
@@ -2416,8 +2190,7 @@ class StartPortacodeServiceHandler(SyncHandler):
             on_behalf_of_device=on_behalf_of_device,
         )
 
-        cli_path = _resolve_portacode_cli_path(vmid, user)
-        cmd = _su_command(user, f"sudo -S {shlex.quote(cli_path)} service install")
+        cmd = _su_command(user, "sudo -S portacode service install")
         res = _run_pct(vmid, cmd, input_text=password + "\n")
 
         if res["returncode"] != 0:

portacode/service.py

@@ -6,7 +6,6 @@ runs ``portacode connect`` automatically at login / boot.
 Platforms implemented:
 
 • Linux (systemd **user** service)        – no root privileges required
-• Linux (OpenRC service)                  – system-wide (e.g., Alpine)
 • macOS (launchd LaunchAgent plist)       – per-user
 • Windows (Task Scheduler *ONLOGON* task) – highest privilege, current user
 
@@ -27,7 +26,6 @@ import os
 from typing import Protocol
 import shutil
 import pwd
-import tempfile
 
 __all__ = [
     "ServiceManager",
@@ -201,129 +199,6 @@ class _SystemdUserService:
             return (status or "") + "\n--- recent logs ---\n" + (journal or "<no logs>")
 
 
-# ---------------------------------------------------------------------------
-# Linux – OpenRC implementation (e.g., Alpine)
-# ---------------------------------------------------------------------------
-class _OpenRCService:
-    NAME = "portacode"
-
-    def __init__(self) -> None:
-        self.init_path = Path("/etc/init.d") / self.NAME
-        self.wrapper_path = Path("/usr/local/share/portacode/connect_service.sh")
-        self.user = os.environ.get("SUDO_USER") or os.environ.get("USER") or os.getlogin()
-        try:
-            self.home = Path(pwd.getpwnam(self.user).pw_dir)
-        except KeyError:
-            self.home = Path("/root") if self.user == "root" else Path(f"/home/{self.user}")
-        self.python = shutil.which("python3") or sys.executable
-        self.log_dir = Path("/var/log/portacode")
-        self.log_path = self.log_dir / "connect.log"
-
-    def _run(self, *args: str) -> subprocess.CompletedProcess[str]:
-        prefix = ["sudo"] if os.geteuid() != 0 else []
-        cmd = [*prefix, *args]
-        return subprocess.run(cmd, text=True, capture_output=True)
-
-    def _write_init_script(self) -> None:
-        self._write_wrapper_script()
-        script = textwrap.dedent(f"""
-            #!/sbin/openrc-run
-            description="Portacode persistent connection"
-
-            command="{self.wrapper_path}"
-            command_user="{self.user}"
-            command_background="yes"
-            pidfile="/run/portacode.pid"
-            directory="{self.home}"
-
-            depend() {{
-                need net
-            }}
-
-            start_pre() {{
-                checkpath --directory --mode 0755 /var/log/portacode
-                checkpath --directory --mode 0755 /usr/local/share/portacode
-                touch "{self.log_path}"
-                chown {self.user} "{self.log_path}"
-                chown {self.user} /var/log/portacode
-            }}
-        """).lstrip()
-
-        tmp_path = Path(tempfile.gettempdir()) / f"portacode-init-{os.getpid()}"
-        tmp_path.write_text(script)
-        if os.geteuid() != 0:
-            self._run("install", "-m", "755", str(tmp_path), str(self.init_path))
-        else:
-            self.init_path.parent.mkdir(parents=True, exist_ok=True)
-            shutil.copyfile(tmp_path, self.init_path)
-            self.init_path.chmod(0o755)
-        try:
-            tmp_path.unlink()
-        except Exception:
-            pass
-    
-    def _write_wrapper_script(self) -> None:
-        script = textwrap.dedent(f"""
-            #!/bin/sh
-            cd "{self.home}"
-            exec "{self.python}" -m portacode connect --non-interactive >> "{self.log_path}" 2>&1
-        """).lstrip()
-        tmp_path = Path(tempfile.gettempdir()) / f"portacode-wrapper-{os.getpid()}"
-        tmp_path.write_text(script)
-        if os.geteuid() != 0:
-            self._run("install", "-m", "755", str(tmp_path), str(self.wrapper_path))
-        else:
-            self.wrapper_path.parent.mkdir(parents=True, exist_ok=True)
-            shutil.copyfile(tmp_path, self.wrapper_path)
-            self.wrapper_path.chmod(0o755)
-        try:
-            tmp_path.unlink()
-        except Exception:
-            pass
-
-    def install(self) -> None:
-        self._write_init_script()
-        self._run("rc-update", "add", self.NAME, "default")
-        self._run("rc-service", self.NAME, "start")
-
-    def uninstall(self) -> None:
-        self._run("rc-service", self.NAME, "stop")
-        self._run("rc-update", "del", self.NAME, "default")
-        if self.init_path.exists():
-            if os.geteuid() != 0:
-                self._run("rm", "-f", str(self.init_path))
-            else:
-                self.init_path.unlink()
-
-    def start(self) -> None:
-        self._run("rc-service", self.NAME, "start")
-
-    def stop(self) -> None:
-        self._run("rc-service", self.NAME, "stop")
-
-    def status(self) -> str:
-        res = self._run("rc-service", self.NAME, "status")
-        out = (res.stdout or res.stderr or "").strip().lower()
-        if "started" in out or "running" in out:
-            return "running"
-        if "stopped" in out:
-            return "stopped"
-        return out or "unknown"
-
-    def status_verbose(self) -> str:
-        res = self._run("rc-service", self.NAME, "status")
-        status = res.stdout or res.stderr or ""
-        log_tail = "<no logs>"
-        try:
-            if self.log_path.exists():
-                with self.log_path.open("r", encoding="utf-8", errors="ignore") as fh:
-                    lines = fh.readlines()
-                log_tail = "".join(lines[-20:]) or "<no logs>"
-        except Exception:
-            pass
-        return (status or "").rstrip() + "\n--- recent logs ---\n" + log_tail
-
-
 # ---------------------------------------------------------------------------
 # macOS – launchd (LaunchAgent) implementation
 # ---------------------------------------------------------------------------
@@ -547,13 +422,9 @@ class _WindowsTask:
 def get_manager(system_mode: bool = False) -> ServiceManager:
     system = platform.system().lower()
     if system == "linux":
-        if shutil.which("systemctl"):
-            return _SystemdUserService(system_mode=system_mode)  # type: ignore[return-value]
-        if shutil.which("rc-service") or Path("/sbin/openrc").exists():
-            return _OpenRCService()  # type: ignore[return-value]
-        raise RuntimeError("Unsupported Linux init system (no systemctl or rc-service found)")
+        return _SystemdUserService(system_mode=system_mode)  # type: ignore[return-value]
     if system == "darwin":
         return _LaunchdService()      # type: ignore[return-value]
     if system.startswith("windows") or system == "windows":
         return _WindowsTask()         # type: ignore[return-value]
-    raise RuntimeError(f"Unsupported platform: {system}") 
+    raise RuntimeError(f"Unsupported platform: {system}") 

{portacode-1.4.17.dist-info → portacode-1.4.17.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: portacode
-Version: 1.4.17
+Version: 1.4.17.dev1
 Summary: Portacode CLI client and SDK
 Home-page: https://github.com/portacode/portacode
 Author: Meena Erian

{portacode-1.4.17.dist-info → portacode-1.4.17.dev1.dist-info}/RECORD

@@ -1,13 +1,13 @@
 portacode/README.md,sha256=4dKtpvR8LNgZPVz37GmkQCMWIr_u25Ao63iW56s7Ke4,775
 portacode/__init__.py,sha256=oB3sV1wXr-um-RXio73UG8E5Xx6cF2ZVJveqjNmC-vQ,1086
 portacode/__main__.py,sha256=jmHTGC1hzmo9iKJLv-SSYe9BSIbPPZ2IOpecI03PlTs,296
-portacode/_version.py,sha256=8lzbms9BpD-Oht4SHc7EY9GwLJHe1VkS9qzxWPibYsY,706
+portacode/_version.py,sha256=30JbXF45c9c1UEsvLScl1Hcz0g1qPk9RGMCBErXUK0c,719
 portacode/cli.py,sha256=mGLKoZ-T2FBF7IA9wUq0zyG0X9__-A1ao7gajjcVRH8,21828
 portacode/data.py,sha256=5-s291bv8J354myaHm1Y7CQZTZyRzMU3TGe5U4hb-FA,1591
 portacode/keypair.py,sha256=0OO4vHDcF1XMxCDqce61xFTlFwlTcmqe5HyGsXFEt7s,5838
 portacode/logging_categories.py,sha256=9m-BYrjyHh1vjZYBQT4JhAh6b_oYUhIWayO-noH1cSE,5063
 portacode/pairing.py,sha256=OzSuc0GhrknrDrny4aBU6IUnmKzRDTtocuDpyaVnyrs,3116
-portacode/service.py,sha256=8dX9bmJ97r8UuM4PJMICQ_D8kWpMPRIdTgPJfsOKmrM,21617
+portacode/service.py,sha256=p-HHMOAl20QsdcJydcZ74Iqes-wl8G8HItdSim30pUk,16537
 portacode/connection/README.md,sha256=f9rbuIEKa7cTm9C98rCiBbEtbiIXQU11esGSNhSMiJg,883
 portacode/connection/__init__.py,sha256=atqcVGkViIEd7pRa6cP2do07RJOM0UWpbnz5zXjGktU,250
 portacode/connection/client.py,sha256=jtLb9_YufqPkzi9t8VQH3iz_JEMisbtY6a8L9U5weiU,14181
@@ -22,7 +22,7 @@ portacode/connection/handlers/diff_handlers.py,sha256=iYTIRCcpEQ03vIPKZCsMTE5aZb
 portacode/connection/handlers/file_handlers.py,sha256=nAJH8nXnX07xxD28ngLpgIUzcTuRwZBNpEGEKdRqohw,39507
 portacode/connection/handlers/project_aware_file_handlers.py,sha256=AqgMnDqX2893T2NsrvUSCwjN5VKj4Pb2TN0S_SuboOE,9803
 portacode/connection/handlers/project_state_handlers.py,sha256=v6ZefGW9i7n1aZLq2jOGumJIjYb6aHlPI4m1jkYewm8,1686
-portacode/connection/handlers/proxmox_infra.py,sha256=6Av5QeNQGh38U0kRzoB4ZICmSrRaWLT3YXHoAqUisv4,99102
+portacode/connection/handlers/proxmox_infra.py,sha256=afndfVsjcHWHsa8F2PkRnHmc67c39k5VMmJeUoSSnok,87601
 portacode/connection/handlers/registry.py,sha256=qXGE60sYEWg6ZtVQzFcZ5YI2XWR6lMgw4hAL9x5qR1I,6181
 portacode/connection/handlers/session.py,sha256=uNGfiO_1B9-_yjJKkpvmbiJhIl6b-UXlT86UTfd6WYE,42219
 portacode/connection/handlers/system_handlers.py,sha256=fr12QpOr_Z8KYGUU-AYrTQwRPAcrLK85hvj3SEq1Kw8,14757
@@ -65,7 +65,7 @@ portacode/utils/__init__.py,sha256=NgBlWTuNJESfIYJzP_3adI1yJQJR0XJLRpSdVNaBAN0,3
 portacode/utils/diff_apply.py,sha256=4Oi7ft3VUCKmiUE4VM-OeqO7Gk6H7PF3WnN4WHXtjxI,15157
 portacode/utils/diff_renderer.py,sha256=S76StnQ2DLfsz4Gg0m07UwPfRp8270PuzbNaQq-rmYk,13850
 portacode/utils/ntp_clock.py,sha256=VqCnWCTehCufE43W23oB-WUdAZGeCcLxkmIOPwInYHc,2499
-portacode-1.4.17.dist-info/licenses/LICENSE,sha256=2FGbCnUDgRYuQTkB1O1dUUpu5CVAjK1j4_p6ack9Z54,1066
+portacode-1.4.17.dev1.dist-info/licenses/LICENSE,sha256=2FGbCnUDgRYuQTkB1O1dUUpu5CVAjK1j4_p6ack9Z54,1066
 test_modules/README.md,sha256=Do_agkm9WhSzueXjRAkV_xEj6Emy5zB3N3VKY5Roce8,9274
 test_modules/__init__.py,sha256=1LcbHodIHsB0g-g4NGjSn6AMuCoGbymvXPYLOb6Z7F0,53
 test_modules/test_device_online.py,sha256=QtYq0Dq9vME8Gp2O4fGSheqVf8LUtpsSKosXXk56gGM,1654
@@ -91,8 +91,8 @@ testing_framework/core/playwright_manager.py,sha256=Tw46qwxIhOFkS48C2IWIQHHNpEe-
 testing_framework/core/runner.py,sha256=j2QwNJmAxVBmJvcbVS7DgPJUKPNzqfLmt_4NNdaKmZU,19297
 testing_framework/core/shared_cli_manager.py,sha256=BESSNtyQb7BOlaOvZmm04T8Uezjms4KCBs2MzTxvzYQ,8790
 testing_framework/core/test_discovery.py,sha256=2FZ9fJ8Dp5dloA-fkgXoJ_gCMC_nYPBnA3Hs2xlagzM,4928
-portacode-1.4.17.dist-info/METADATA,sha256=aGOO0qvH294SN-7MqFeLFJ9x3Em1cnRu-CKPq_zVAUY,13046
-portacode-1.4.17.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-portacode-1.4.17.dist-info/entry_points.txt,sha256=lLUUL-BM6_wwe44Xv0__5NQ1BnAz6jWjSMFvZdWW3zU,48
-portacode-1.4.17.dist-info/top_level.txt,sha256=TGhTYUxfW8SyVZc_zGgzjzc24gGT7nSw8Qf73liVRKM,41
-portacode-1.4.17.dist-info/RECORD,,
+portacode-1.4.17.dev1.dist-info/METADATA,sha256=fiXLmOIToLe48UzncEAQCZnpib1ITZpl0gS06M5fmFA,13051
+portacode-1.4.17.dev1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+portacode-1.4.17.dev1.dist-info/entry_points.txt,sha256=lLUUL-BM6_wwe44Xv0__5NQ1BnAz6jWjSMFvZdWW3zU,48
+portacode-1.4.17.dev1.dist-info/top_level.txt,sha256=TGhTYUxfW8SyVZc_zGgzjzc24gGT7nSw8Qf73liVRKM,41
+portacode-1.4.17.dev1.dist-info/RECORD,,