portacode 1.4.15.dev26__tar.gz → 1.4.16__tar.gz

{portacode-1.4.15.dev26 → portacode-1.4.16}/PKG-INFO

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

{portacode-1.4.15.dev26 → portacode-1.4.16}/portacode/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.4.15.dev26'
-__version_tuple__ = version_tuple = (1, 4, 15, 'dev26')
+__version__ = version = '1.4.16'
+__version_tuple__ = version_tuple = (1, 4, 16)
 
 __commit_id__ = commit_id = None

{portacode-1.4.15.dev26 → portacode-1.4.16}/portacode/connection/handlers/WEBSOCKET_PROTOCOL.md

@@ -381,6 +381,7 @@ Starts a previously provisioned, Portacode-managed LXC container. Handled by [`S
 **Payload Fields:**
 
 *   `ctid` (string, required): Identifier of the container to start.
+*   `child_device_id` (string, required): Dashboard `Device.id` of the container that triggered the request; the handler validates the CT belongs to that device before issuing the start.
 
 **Responses:**
 
@@ -394,6 +395,7 @@ Stops a running Portacode-managed container. Handled by [`StopProxmoxContainerHa
 **Payload Fields:**
 
 *   `ctid` (string, required): Identifier of the container to stop.
+*   `child_device_id` (string, required): Dashboard `Device.id` that owns the container; the handler rejects the request if the CT is mapped to another device.
 
 **Responses:**
 
@@ -407,6 +409,7 @@ Deletes a managed container from Proxmox (stopping it first if necessary) and re
 **Payload Fields:**
 
 *   `ctid` (string, required): Identifier of the container to delete.
+*   `child_device_id` (string, required): Dashboard `Device.id` that should own the container metadata being purged.
 
 **Responses:**
 
@@ -1133,22 +1136,43 @@ Provides system information in response to a `system_info` action. Handled by [`
                     *   `bridge` (string): The bridge interface configured (typically `vmbr1`).
                     *   `health` (string|null): `"healthy"` when the connectivity verification succeeded.
                 *   `node_status` (object|null): Status response returned by the Proxmox API when validating the token.
-                *   `managed_containers` (object): Cached summary of the Portacode-managed containers:
-                    *   `updated_at` (string): ISO timestamp when this snapshot was last refreshed.
-                    *   `count` (integer): Number of managed containers.
-                    *   `total_ram_mib` (integer): RAM footprint summed across all containers.
-                    *   `total_disk_gib` (integer): Disk footprint summed across all containers.
-                    *   `total_cpu_share` (number): CPU shares requested across all containers.
-                    *   `containers` (array[object]): Container summaries with the following fields:
-                        *   `vmid` (string|null): Numeric CT ID.
-                        *   `hostname` (string|null): Hostname configured in the CT.
-                        *   `template` (string|null): Template identifier used.
-                        *   `storage` (string|null): Storage pool backing the rootfs.
-                        *   `disk_gib` (integer): Rootfs size in GiB.
-                        *   `ram_mib` (integer): Memory size in MiB.
-                        *   `cpu_share` (number): vCPU-equivalent share requested at creation.
-                        *   `status` (string): Lowercase lifecycle status (e.g., `running`, `stopped`, `deleted`).
-                        *   `created_at` (string|null): ISO timestamp recorded when the CT was provisioned.
+                    *   `managed_containers` (object): Cached summary of the Portacode-managed containers:
+                        *   `updated_at` (string): ISO timestamp when this snapshot was last refreshed.
+                        *   `count` (integer): Number of managed containers.
+                        *   `total_ram_mib` (integer): RAM footprint summed across all containers.
+                        *   `total_disk_gib` (integer): Disk footprint summed across all containers.
+                        *   `total_cpu_share` (number): CPU shares requested across all containers.
+                        *   `containers` (array[object]): Container summaries with the following fields:
+                            *   `vmid` (string|null): Numeric CT ID.
+                            *   `hostname` (string|null): Hostname configured in the CT.
+                            *   `template` (string|null): Template identifier used.
+                            *   `storage` (string|null): Storage pool backing the rootfs.
+                            *   `disk_gib` (integer): Rootfs size in GiB.
+                            *   `ram_mib` (integer): Memory size in MiB.
+                            *   `cpu_share` (number): vCPU-equivalent share requested at creation.
+                            *   `status` (string): Lowercase lifecycle status (e.g., `running`, `stopped`, `deleted`).
+                            *   `created_at` (string|null): ISO timestamp recorded when the CT was provisioned.
+                            *   `managed` (boolean): `true` for Portacode-managed entries.
+                            *   `matches_default_storage` (boolean): `true` when this container is backed by the default storage pool used for new Portacode containers.
+                            *   `type` (string): Either `lxc` or `qemu`, indicating whether we enumerated the container from the LXC or QEMU APIs.
+                        *   `unmanaged_containers` (array[object]): Facts about containers Portacode did not provision; fields mirror the managed list but are marked `managed=false`.
+                            *   `reserve_on_boot` (boolean): `true` when the CT is configured to start at boot; this flag is used to decide if its RAM and CPU allocations count toward the available totals.
+                    *   `unmanaged_count` (integer): Number of unmanaged containers detected on the node.
+                    *   `allocated_ram_mib` (integer): Total RAM reserved by both managed and unmanaged containers.
+                    *   `allocated_disk_gib` (integer): Total disk reserved by both managed and unmanaged containers.
+                    *   `allocated_cpu_share` (number): Total CPU shares requested by both managed and unmanaged containers.
+                    *   `available_ram_mib` (integer|null): Remaining RAM after subtracting all reservations from the host total (null when unavailable).
+                    *   `available_disk_gib` (integer|null): Remaining disk GB after subtracting allocations from the host total.
+                    *   `available_cpu_share` (number|null): Remaining CPU shares after allocations.
+                    *   `host_total_ram_mib` (integer|null): Host memory capacity observed via Proxmox.
+                    *   `host_total_disk_gib` (integer|null): Host disk capacity observed via Proxmox.
+                    *   `host_total_cpu_cores` (integer|null): Number of CPU cores reported by Proxmox.
+                    *   `default_storage` (string|null): Storage pool name selected during infrastructure configuration.
+                    *   `default_storage_snapshot` (object|null): Fresh stats for the default storage pool:
+                        *   `storage` (string): Storage pool identifier.
+                        *   `total_gib` (integer|null): Capacity of the storage pool.
+                        *   `avail_gib` (integer|null): Available space remaining.
+                        *   `used_gib` (integer|null): Space already consumed.
     *   `portacode_version` (string): Installed CLI version returned by `portacode.__version__`.
 
 ### `proxmox_infra_configured`

{portacode-1.4.15.dev26 → portacode-1.4.16}/portacode/connection/handlers/project_state/manager.py

@@ -21,6 +21,24 @@ from .git_manager import GitManager
 from .file_system_watcher import FileSystemWatcher
 from ....logging_categories import get_categorized_logger, LogCategory
 
+def _deterministic_file_tab_id(file_path: str) -> str:
+    try:
+        resolved = os.path.abspath(file_path)
+        mtime = int(Path(resolved).stat().st_mtime)
+    except OSError:
+        mtime = "unknown"
+        resolved = os.path.abspath(file_path)
+    return f"{resolved}:{mtime}"
+
+def _deterministic_diff_tab_id(
+    file_path: str,
+    from_ref: str,
+    to_ref: str,
+    from_hash: Optional[str],
+    to_hash: Optional[str]
+) -> str:
+    return f"diff:{os.path.abspath(file_path)}:{from_ref}:{to_ref}:{from_hash or ''}:{to_hash or ''}"
+
 logger = get_categorized_logger(__name__)
 
 # Global singleton instance
@@ -657,10 +675,10 @@ class ProjectStateManager:
         # Create new file tab using tab factory
         from ..tab_factory import get_tab_factory
         tab_factory = get_tab_factory()
-        
+
         try:
             logger.info(f"About to create tab for file: {file_path}")
-            new_tab = await tab_factory.create_file_tab(file_path)
+            new_tab = await tab_factory.create_file_tab(file_path, tab_id=_deterministic_file_tab_id(file_path))
             logger.info(f"Tab created successfully, adding to project state")
             project_state.open_tabs[tab_key] = new_tab
             if set_active:
@@ -842,7 +860,11 @@ class ProjectStateManager:
             diff_title = f"{os.path.basename(file_path)} ({' '.join(title_parts)})"
             
             diff_tab = await tab_factory.create_diff_tab_with_title(
-                file_path, original_content, modified_content, diff_title, 
+                file_path,
+                original_content,
+                modified_content,
+                diff_title,
+                tab_id=_deterministic_diff_tab_id(file_path, from_ref, to_ref, from_hash, to_hash),
                 diff_details=diff_details
             )
             

{portacode-1.4.15.dev26 → portacode-1.4.16}/portacode/connection/handlers/proxmox_infra.py

@@ -7,6 +7,7 @@ import json
 import logging
 import math
 import os
+import re
 import secrets
 import shlex
 import shutil
@@ -248,6 +249,217 @@ def _pick_storage(storages: Iterable[Dict[str, Any]]) -> str:
     return candidates[0].get("storage", "")
 
 
+def _bytes_to_gib(value: Any) -> float:
+    try:
+        return float(value) / 1024**3
+    except (TypeError, ValueError):
+        return 0.0
+
+
+def _bytes_to_mib(value: Any) -> float:
+    try:
+        return float(value) / 1024**2
+    except (TypeError, ValueError):
+        return 0.0
+
+
+def _size_token_to_gib(token: str) -> float:
+    match = re.match(r"^\s*([0-9]+(?:\.[0-9]+)?)\s*([KMGTP])?([iI]?[bB])?\s*$", token)
+    if not match:
+        return 0.0
+    number = float(match.group(1))
+    unit = (match.group(2) or "").upper()
+    scale = {
+        "": 1,
+        "K": 1024**1,
+        "M": 1024**2,
+        "G": 1024**3,
+        "T": 1024**4,
+        "P": 1024**5,
+    }.get(unit, 1)
+    return (number * scale) / 1024**3
+
+
+def _extract_size_gib(value: Any) -> float:
+    if not value:
+        return 0.0
+    text = str(value)
+    for part in text.split(","):
+        if "size=" in part:
+            token = part.split("=", 1)[1]
+            return _size_token_to_gib(token)
+    return _size_token_to_gib(text)
+
+
+def _extract_storage_token(value: Any) -> str:
+    if not value:
+        return "unknown"
+    text = str(value)
+    if ":" in text:
+        return text.split(":", 1)[0].strip() or "unknown"
+    return text.strip() or "unknown"
+
+
+def _storage_from_lxc(cfg: Dict[str, Any], entry: Dict[str, Any]) -> str:
+    rootfs = cfg.get("rootfs") or entry.get("rootfs")
+    storage = _extract_storage_token(rootfs)
+    if storage != "unknown":
+        return storage
+    for idx in range(0, 10):
+        mp_value = cfg.get(f"mp{idx}")
+        storage = _extract_storage_token(mp_value)
+        if storage != "unknown":
+            return storage
+    return "unknown"
+
+
+def _storage_from_qemu(cfg: Dict[str, Any]) -> str:
+    preferred_keys: List[str] = []
+    for prefix in ("scsi", "virtio", "sata", "ide"):
+        preferred_keys.extend(f"{prefix}{idx}" for idx in range(0, 6))
+    seen = set()
+    for key in preferred_keys:
+        value = cfg.get(key)
+        if value is None:
+            continue
+        seen.add(key)
+        text = str(value)
+        if "media=cdrom" in text or "cloudinit" in text:
+            continue
+        storage = _extract_storage_token(text)
+        if storage != "unknown":
+            return storage
+    for key in sorted(cfg.keys()):
+        if key in seen:
+            continue
+        if not any(key.startswith(prefix) for prefix in ("scsi", "virtio", "sata", "ide")):
+            continue
+        value = cfg.get(key)
+        if value is None:
+            continue
+        text = str(value)
+        if "media=cdrom" in text or "cloudinit" in text:
+            continue
+        storage = _extract_storage_token(text)
+        if storage != "unknown":
+            return storage
+    for key in ("efidisk0", "tpmstate0"):
+        storage = _extract_storage_token(cfg.get(key))
+        if storage != "unknown":
+            return storage
+    return "unknown"
+
+
+def _primary_lxc_disk(cfg: Dict[str, Any], entry: Dict[str, Any]) -> str:
+    return str(cfg.get("rootfs") or entry.get("rootfs") or "")
+
+
+def _primary_qemu_disk(cfg: Dict[str, Any]) -> str:
+    preferred_keys: List[str] = []
+    for prefix in ("scsi", "virtio", "sata", "ide"):
+        preferred_keys.extend(f"{prefix}{idx}" for idx in range(0, 6))
+    seen = set()
+    for key in preferred_keys:
+        value = cfg.get(key)
+        if value is None:
+            continue
+        seen.add(key)
+        text = str(value)
+        if "media=cdrom" in text or "cloudinit" in text:
+            continue
+        return text
+    for key in sorted(cfg.keys()):
+        if key in seen:
+            continue
+        if not any(key.startswith(prefix) for prefix in ("scsi", "virtio", "sata", "ide")):
+            continue
+        value = cfg.get(key)
+        if value is None:
+            continue
+        text = str(value)
+        if "media=cdrom" in text or "cloudinit" in text:
+            continue
+        return text
+    return ""
+
+
+def _pick_container_storage(kind: str, cfg: Dict[str, Any], entry: Dict[str, Any]) -> str:
+    storage = _extract_storage_token(cfg.get("storage") or entry.get("storage"))
+    if storage != "unknown":
+        return storage
+    if kind == "lxc":
+        return _storage_from_lxc(cfg, entry)
+    return _storage_from_qemu(cfg)
+
+
+def _pick_container_disk_gib(kind: str, cfg: Dict[str, Any], entry: Dict[str, Any]) -> float:
+    if kind == "lxc":
+        size = _extract_size_gib(_primary_lxc_disk(cfg, entry))
+        if size:
+            return size
+    else:
+        size = _extract_size_gib(_primary_qemu_disk(cfg))
+        if size:
+            return size
+    for candidate in (entry.get("maxdisk"), entry.get("disk"), cfg.get("disk")):
+        if candidate is None or candidate == 0:
+            continue
+        return _bytes_to_gib(candidate)
+    return 0.0
+
+
+def _to_mib(value: Any) -> float:
+    try:
+        val = float(value)
+    except (TypeError, ValueError):
+        return 0.0
+    if val <= 0:
+        return 0.0
+    # Heuristic: large values are bytes, smaller ones are already MiB.
+    return _bytes_to_mib(val) if val > 10000 else val
+
+
+def _pick_container_ram_mib(kind: str, cfg: Dict[str, Any], entry: Dict[str, Any]) -> float:
+    for candidate in (cfg.get("memory"), entry.get("maxmem"), entry.get("mem")):
+        ram = _to_mib(candidate)
+        if ram:
+            return ram
+    return 0.0
+
+
+def _safe_float(value: Any) -> float:
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return 0.0
+
+
+def _pick_container_cpu_share(kind: str, cfg: Dict[str, Any], entry: Dict[str, Any]) -> float:
+    if kind == "lxc":
+        for key in ("cpulimit", "cores", "cpus"):
+            val = _safe_float(cfg.get(key))
+            if val:
+                return val
+        return _safe_float(entry.get("cpus"))
+
+    cores = _safe_float(cfg.get("cores"))
+    sockets = _safe_float(cfg.get("sockets")) or 1.0
+    if cores:
+        return cores * sockets
+    val = _safe_float(cfg.get("vcpus"))
+    if val:
+        return val
+    val = _safe_float(entry.get("cpus") or entry.get("maxcpu"))
+    if val:
+        return val
+    return 0.0
+
+
+def _parse_onboot_flag(value: Any) -> bool:
+    text = str(value).strip().lower()
+    return text in {"1", "true", "yes", "on"}
+
+
 def _write_bridge_config(bridge: str) -> None:
     begin = f"# Portacode INFRA BEGIN {bridge}"
     end = f"# Portacode INFRA END {bridge}"
@@ -410,6 +622,7 @@ def _build_managed_containers_summary(records: List[Dict[str, Any]]) -> Dict[str
         containers.append(
             {
                 "vmid": str(_as_int(record.get("vmid"))) if record.get("vmid") is not None else None,
+                "device_id": record.get("device_id"),
                 "hostname": record.get("hostname"),
                 "template": record.get("template"),
                 "storage": record.get("storage"),
@@ -431,6 +644,139 @@ def _build_managed_containers_summary(records: List[Dict[str, Any]]) -> Dict[str
     }
 
 
+def _build_full_container_summary(records: List[Dict[str, Any]], config: Dict[str, Any]) -> Dict[str, Any]:
+    base_summary = _build_managed_containers_summary(records)
+    if not config or not config.get("token_value"):
+        return base_summary
+
+    try:
+        proxmox = _connect_proxmox(config)
+        node = _get_node_from_config(config)
+    except Exception as exc:  # pragma: no cover - best effort
+        logger.debug("Unable to extend container summary with Proxmox data: %s", exc)
+        return base_summary
+
+    default_storage = (config.get("default_storage") or "").strip()
+    record_map: Dict[str, Dict[str, Any]] = {}
+    for record in records:
+        vmid = record.get("vmid")
+        if vmid is None:
+            continue
+        try:
+            vmid_key = str(int(vmid))
+        except (ValueError, TypeError):
+            continue
+        record_map[vmid_key] = record
+
+    managed_entries: List[Dict[str, Any]] = []
+    unmanaged_entries: List[Dict[str, Any]] = []
+    allocated_ram = 0.0
+    allocated_disk = 0.0
+    allocated_cpu = 0.0
+
+    def _process_entries(kind: str, getter: str) -> None:
+        nonlocal allocated_ram, allocated_disk, allocated_cpu
+        entries = getattr(proxmox.nodes(node), getter).get()
+        for entry in entries:
+            vmid = entry.get("vmid")
+            if vmid is None:
+                continue
+            vmid_str = str(vmid)
+            cfg: Dict[str, Any] = {}
+            try:
+                cfg = getattr(proxmox.nodes(node), getter)(vmid_str).config.get() or {}
+            except Exception as exc:  # pragma: no cover - best effort
+                logger.debug("Failed to load %s config for %s: %s", kind, vmid_str, exc)
+                cfg = {}
+
+            record = record_map.get(vmid_str)
+            description = cfg.get("description") or ""
+            managed = bool(record) or MANAGED_MARKER in description
+            hostname = entry.get("name") or cfg.get("hostname") or (record.get("hostname") if record else None)
+            storage = _pick_container_storage(kind, cfg, entry)
+            disk_gib = _pick_container_disk_gib(kind, cfg, entry)
+            ram_mib = _pick_container_ram_mib(kind, cfg, entry)
+            cpu_share = _pick_container_cpu_share(kind, cfg, entry)
+            reserve_on_boot = _parse_onboot_flag(cfg.get("onboot"))
+            matches_default_storage = bool(default_storage and storage and storage.lower() == default_storage.lower())
+
+            base_entry = {
+                "type": kind,
+                "vmid": vmid_str,
+                "hostname": hostname,
+                "status": (entry.get("status") or "unknown").lower(),
+                "storage": storage,
+                "disk_gib": disk_gib,
+                "ram_mib": ram_mib,
+                "cpu_share": cpu_share,
+                "reserve_on_boot": reserve_on_boot,
+                "matches_default_storage": matches_default_storage,
+                "managed": managed,
+            }
+
+            if managed:
+                merged = base_entry | {
+                    "device_id": record.get("device_id") if record else None,
+                    "template": record.get("template") if record else None,
+                    "created_at": record.get("created_at") if record else None,
+                }
+                managed_entries.append(merged)
+            else:
+                unmanaged_entries.append(base_entry)
+
+            if managed or reserve_on_boot:
+                allocated_ram += ram_mib
+                allocated_cpu += cpu_share
+            if managed or matches_default_storage:
+                allocated_disk += disk_gib
+
+    _process_entries("lxc", "lxc")
+    _process_entries("qemu", "qemu")
+
+    memory_info = {}
+    cpu_info = {}
+    try:
+        node_status = proxmox.nodes(node).status.get()
+        memory_info = node_status.get("memory") or {}
+        cpu_info = node_status.get("cpuinfo") or {}
+    except Exception as exc:  # pragma: no cover - best effort
+        logger.debug("Unable to read node status for resource totals: %s", exc)
+
+    host_total_ram_mib = _bytes_to_mib(memory_info.get("total"))
+    used_ram_mib = _bytes_to_mib(memory_info.get("used"))
+    available_ram_mib = max(host_total_ram_mib - used_ram_mib, 0.0) if host_total_ram_mib else None
+    host_total_cpu_cores = _safe_float(cpu_info.get("cores"))
+    available_cpu_share = max(host_total_cpu_cores - allocated_cpu, 0.0) if host_total_cpu_cores else None
+
+    host_total_disk_gib = None
+    available_disk_gib = None
+    if default_storage:
+        try:
+            storage_status = proxmox.nodes(node).storage(default_storage).status.get()
+            host_total_disk_gib = _bytes_to_gib(storage_status.get("total"))
+            available_disk_gib = _bytes_to_gib(storage_status.get("avail"))
+        except Exception as exc:  # pragma: no cover - best effort
+            logger.debug("Unable to read storage status for %s: %s", default_storage, exc)
+
+    summary = base_summary.copy()
+    summary["containers"] = managed_entries
+    summary["count"] = len(managed_entries)
+    summary["total_ram_mib"] = int(sum(entry.get("ram_mib") or 0 for entry in managed_entries))
+    summary["total_disk_gib"] = int(sum(entry.get("disk_gib") or 0 for entry in managed_entries))
+    summary["total_cpu_share"] = round(sum(entry.get("cpu_share") or 0 for entry in managed_entries), 2)
+    summary["unmanaged_containers"] = unmanaged_entries
+    summary["allocated_ram_mib"] = round(allocated_ram, 2)
+    summary["allocated_disk_gib"] = round(allocated_disk, 2)
+    summary["allocated_cpu_share"] = round(allocated_cpu, 2)
+    summary["host_total_ram_mib"] = int(host_total_ram_mib) if host_total_ram_mib else None
+    summary["host_total_disk_gib"] = host_total_disk_gib
+    summary["host_total_cpu_cores"] = host_total_cpu_cores if host_total_cpu_cores else None
+    summary["available_ram_mib"] = int(available_ram_mib) if available_ram_mib is not None else None
+    summary["available_disk_gib"] = available_disk_gib
+    summary["available_cpu_share"] = available_cpu_share if available_cpu_share is not None else None
+    return summary
+
+
 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:
@@ -466,7 +812,7 @@ def _get_managed_containers_summary(force: bool = False) -> Dict[str, Any]:
     config = _load_config()
     records = _load_managed_container_records()
     _refresh_container_statuses(records, config)
-    summary = _build_managed_containers_summary(records)
+    summary = _build_full_container_summary(records, config)
     with _MANAGED_CONTAINERS_CACHE_LOCK:
         _MANAGED_CONTAINERS_CACHE["timestamp"] = now
         _MANAGED_CONTAINERS_CACHE["summary"] = summary
@@ -876,12 +1222,17 @@ def _parse_ctid(message: Dict[str, Any]) -> int:
 
 
 def _ensure_container_managed(
-    proxmox: Any, node: str, vmid: int
+    proxmox: Any, node: str, vmid: int, *, device_id: Optional[str] = None
 ) -> Tuple[Dict[str, Any], Dict[str, Any]]:
     record = _read_container_record(vmid)
     ct_cfg = proxmox.nodes(node).lxc(str(vmid)).config.get()
     if not ct_cfg or MANAGED_MARKER not in (ct_cfg.get("description") or ""):
         raise RuntimeError(f"Container {vmid} is not managed by Portacode.")
+    record_device_id = record.get("device_id")
+    if device_id and str(record_device_id or "") != str(device_id):
+        raise RuntimeError(
+            f"Container {vmid} is managed for device {record_device_id!r}, not {device_id!r}."
+        )
     return record, ct_cfg
 
 
@@ -1835,10 +2186,13 @@ class StartProxmoxContainerHandler(SyncHandler):
 
     def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
         vmid = _parse_ctid(message)
+        child_device_id = (message.get("child_device_id") or "").strip()
+        if not child_device_id:
+            raise ValueError("child_device_id is required for start_proxmox_container")
         config = _ensure_infra_configured()
         proxmox = _connect_proxmox(config)
         node = _get_node_from_config(config)
-        _ensure_container_managed(proxmox, node, vmid)
+        _ensure_container_managed(proxmox, node, vmid, device_id=child_device_id)
 
         status, elapsed = _start_container(proxmox, node, vmid)
         _update_container_record(vmid, {"status": "running"})
@@ -1865,10 +2219,13 @@ class StopProxmoxContainerHandler(SyncHandler):
 
     def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
         vmid = _parse_ctid(message)
+        child_device_id = (message.get("child_device_id") or "").strip()
+        if not child_device_id:
+            raise ValueError("child_device_id is required for stop_proxmox_container")
         config = _ensure_infra_configured()
         proxmox = _connect_proxmox(config)
         node = _get_node_from_config(config)
-        _ensure_container_managed(proxmox, node, vmid)
+        _ensure_container_managed(proxmox, node, vmid, device_id=child_device_id)
 
         status, elapsed = _stop_container(proxmox, node, vmid)
         final_status = status.get("status") or "stopped"
@@ -1901,10 +2258,13 @@ class RemoveProxmoxContainerHandler(SyncHandler):
 
     def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
         vmid = _parse_ctid(message)
+        child_device_id = (message.get("child_device_id") or "").strip()
+        if not child_device_id:
+            raise ValueError("child_device_id is required for remove_proxmox_container")
         config = _ensure_infra_configured()
         proxmox = _connect_proxmox(config)
         node = _get_node_from_config(config)
-        _ensure_container_managed(proxmox, node, vmid)
+        _ensure_container_managed(proxmox, node, vmid, device_id=child_device_id)
 
         stop_status, stop_elapsed = _stop_container(proxmox, node, vmid)
         delete_status, delete_elapsed = _delete_container(proxmox, node, vmid)