portacode 1.4.16.dev10__py3-none-any.whl → 1.4.16.dev11__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.16.dev10'
-__version_tuple__ = version_tuple = (1, 4, 16, 'dev10')
+__version__ = version = '1.4.16.dev11'
+__version_tuple__ = version_tuple = (1, 4, 16, 'dev11')
 
 __commit_id__ = commit_id = None

portacode/connection/handlers/proxmox_infra.py

@@ -19,7 +19,7 @@ import time
 import threading
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence, Set, Tuple
+from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence, Tuple
 
 import platformdirs
 
@@ -202,67 +202,66 @@ def _current_time_iso() -> str:
     return datetime.now(timezone.utc).isoformat()
 
 
-def _to_int(value: Any, default: int = 0) -> int:
+def _parse_iso_timestamp(value: str) -> Optional[datetime]:
+    if not value:
+        return None
+    text = value
+    if text.endswith("Z"):
+        text = text[:-1] + "+00:00"
     try:
-        return int(value)
-    except (TypeError, ValueError):
-        return default
+        return datetime.fromisoformat(text)
+    except ValueError:
+        return None
+
+
+def _templates_need_refresh(config: Dict[str, Any]) -> bool:
+    if not config or not config.get("token_value"):
+        return False
+    last = _parse_iso_timestamp(config.get("templates_last_refreshed") or "")
+    if not last:
+        return True
+    return (datetime.now(timezone.utc) - last).total_seconds() >= TEMPLATES_REFRESH_INTERVAL_S
 
 
-def _to_float(value: Any, default: float = 0.0) -> float:
+def _ensure_templates_refreshed_on_startup(config: Dict[str, Any]) -> None:
+    if not _templates_need_refresh(config):
+        return
     try:
-        return float(value)
-    except (TypeError, ValueError):
-        return default
+        client = _build_proxmox_client_from_config(config)
+        node = config.get("node") or _pick_node(client)
+        storages = client.nodes(node).storage.get()
+        templates = _list_templates(client, node, storages)
+        if templates:
+            config["templates"] = templates
+            config["templates_last_refreshed"] = _current_time_iso()
+            _save_config(config)
+    except Exception as exc:
+        logger.warning("Unable to refresh Proxmox templates on startup: %s", exc)
 
 
-def _calculate_available(total: Optional[float], used: float) -> Optional[float]:
-    if total is None:
-        return None
-    delta = total - used
-    return delta if delta >= 0 else 0.0
+def _pick_storage(storages: Iterable[Dict[str, Any]]) -> str:
+    candidates = [s for s in storages if "rootdir" in s.get("content", "") and s.get("avail", 0) > 0]
+    if not candidates:
+        candidates = [s for s in storages if "rootdir" in s.get("content", "")]
+    if not candidates:
+        return ""
+    candidates.sort(key=lambda entry: entry.get("avail", 0), reverse=True)
+    return candidates[0].get("storage", "")
 
 
-def _normalize_bytes(value: Any) -> float:
-    if isinstance(value, (int, float)):
-        return float(value)
-    text = str(value or "").strip()
-    if not text:
-        return 0.0
-    match = re.match(r"(?i)^\s*([0-9]*\.?[0-9]+)\s*([kmgtp]?i?b?)?\s*$", text)
-    if not match:
-        return 0.0
-    number = match.group(1)
-    unit = (match.group(2) or "").lower()
+def _bytes_to_gib(value: Any) -> float:
     try:
-        value = float(number)
-    except ValueError:
+        return float(value) / 1024**3
+    except (TypeError, ValueError):
         return 0.0
-    if unit.startswith("k"):
-        return value * 1024
-    if unit.startswith("m"):
-        return value * 1024**2
-    if unit.startswith("g"):
-        return value * 1024**3
-    if unit.startswith("t"):
-        return value * 1024**4
-    if unit.startswith("p"):
-        return value * 1024**5
-    return value
-
 
-def _bytes_to_mib(value: Any) -> int:
-    return int(round(_normalize_bytes(value) / (1024**2)))
-
-
-def _bytes_to_gib(value: Any) -> int:
-    return int(round(_normalize_bytes(value) / (1024**3)))
 
+def _bytes_to_mib(value: Any) -> float:
+    try:
+        return float(value) / 1024**2
+    except (TypeError, ValueError):
+        return 0.0
 
-def _normalize_storage_name(name: Any) -> str:
-    if not name:
-        return ""
-    return str(name).strip().lower()
 
 def _size_token_to_gib(token: str) -> float:
     match = re.match(r"^\s*([0-9]+(?:\.[0-9]+)?)\s*([KMGTP])?([iI]?[bB])?\s*$", token)
@@ -272,11 +271,11 @@ def _size_token_to_gib(token: str) -> float:
     unit = (match.group(2) or "").upper()
     scale = {
         "": 1,
-        "K": 1024 ** 1,
-        "M": 1024 ** 2,
-        "G": 1024 ** 3,
-        "T": 1024 ** 4,
-        "P": 1024 ** 5,
+        "K": 1024**1,
+        "M": 1024**2,
+        "G": 1024**3,
+        "T": 1024**4,
+        "P": 1024**5,
     }.get(unit, 1)
     return (number * scale) / 1024**3
 
@@ -292,7 +291,7 @@ def _extract_size_gib(value: Any) -> float:
     return _size_token_to_gib(text)
 
 
-def _extract_storage(value: Any) -> str:
+def _extract_storage_token(value: Any) -> str:
     if not value:
         return "unknown"
     text = str(value)
@@ -303,12 +302,12 @@ def _extract_storage(value: Any) -> str:
 
 def _storage_from_lxc(cfg: Dict[str, Any], entry: Dict[str, Any]) -> str:
     rootfs = cfg.get("rootfs") or entry.get("rootfs")
-    storage = _extract_storage(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(mp_value)
+        storage = _extract_storage_token(mp_value)
         if storage != "unknown":
             return storage
     return "unknown"
@@ -318,7 +317,7 @@ 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[str] = set()
+    seen = set()
     for key in preferred_keys:
         value = cfg.get(key)
         if value is None:
@@ -327,7 +326,7 @@ def _storage_from_qemu(cfg: Dict[str, Any]) -> str:
         text = str(value)
         if "media=cdrom" in text or "cloudinit" in text:
             continue
-        storage = _extract_storage(text)
+        storage = _extract_storage_token(text)
         if storage != "unknown":
             return storage
     for key in sorted(cfg.keys()):
@@ -341,11 +340,11 @@ def _storage_from_qemu(cfg: Dict[str, Any]) -> str:
         text = str(value)
         if "media=cdrom" in text or "cloudinit" in text:
             continue
-        storage = _extract_storage(text)
+        storage = _extract_storage_token(text)
         if storage != "unknown":
             return storage
     for key in ("efidisk0", "tpmstate0"):
-        storage = _extract_storage(cfg.get(key))
+        storage = _extract_storage_token(cfg.get(key))
         if storage != "unknown":
             return storage
     return "unknown"
@@ -359,7 +358,7 @@ 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[str] = set()
+    seen = set()
     for key in preferred_keys:
         value = cfg.get(key)
         if value is None:
@@ -384,8 +383,8 @@ def _primary_qemu_disk(cfg: Dict[str, Any]) -> str:
     return ""
 
 
-def _pick_storage(kind: str, cfg: Dict[str, Any], entry: Dict[str, Any]) -> str:
-    storage = _extract_storage(cfg.get("storage") or entry.get("storage"))
+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":
@@ -393,7 +392,7 @@ def _pick_storage(kind: str, cfg: Dict[str, Any], entry: Dict[str, Any]) -> str:
     return _storage_from_qemu(cfg)
 
 
-def _pick_disk_gib(kind: str, cfg: Dict[str, Any], entry: Dict[str, Any]) -> float:
+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:
@@ -402,68 +401,63 @@ def _pick_disk_gib(kind: str, cfg: Dict[str, Any], entry: Dict[str, Any]) -> flo
         size = _extract_size_gib(_primary_qemu_disk(cfg))
         if size:
             return size
-    for candidate in (entry.get("maxdisk"), entry.get("disk")):
-        if candidate in {None, 0}:
+    for candidate in (entry.get("maxdisk"), entry.get("disk"), cfg.get("disk")):
+        if candidate is None or candidate == 0:
             continue
-        return _normalize_bytes(candidate) / 1024**3
-    cfg_disk = cfg.get("disk")
-    if cfg_disk not in (None, 0):
-        return _normalize_bytes(cfg_disk) / 1024**3
+        return _bytes_to_gib(candidate)
     return 0.0
 
 
-def _parse_bool_flag(value: Any) -> bool:
-    if isinstance(value, bool):
-        return value
-    text = str(value or "").strip().lower()
-    return text in {"1", "true", "yes", "on"}
-
-
-def _parse_iso_timestamp(value: str) -> Optional[datetime]:
-    if not value:
-        return None
-    text = value
-    if text.endswith("Z"):
-        text = text[:-1] + "+00:00"
+def _to_mib(value: Any) -> float:
     try:
-        return datetime.fromisoformat(text)
-    except ValueError:
-        return None
+        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 _templates_need_refresh(config: Dict[str, Any]) -> bool:
-    if not config or not config.get("token_value"):
-        return False
-    last = _parse_iso_timestamp(config.get("templates_last_refreshed") or "")
-    if not last:
-        return True
-    return (datetime.now(timezone.utc) - last).total_seconds() >= TEMPLATES_REFRESH_INTERVAL_S
+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 _ensure_templates_refreshed_on_startup(config: Dict[str, Any]) -> None:
-    if not _templates_need_refresh(config):
-        return
+def _safe_float(value: Any) -> float:
     try:
-        client = _build_proxmox_client_from_config(config)
-        node = config.get("node") or _pick_node(client)
-        storages = client.nodes(node).storage.get()
-        templates = _list_templates(client, node, storages)
-        if templates:
-            config["templates"] = templates
-            config["templates_last_refreshed"] = _current_time_iso()
-            _save_config(config)
-    except Exception as exc:
-        logger.warning("Unable to refresh Proxmox templates on startup: %s", exc)
+        return float(value)
+    except (TypeError, ValueError):
+        return 0.0
 
 
-def _pick_storage(storages: Iterable[Dict[str, Any]]) -> str:
-    candidates = [s for s in storages if "rootdir" in s.get("content", "") and s.get("avail", 0) > 0]
-    if not candidates:
-        candidates = [s for s in storages if "rootdir" in s.get("content", "")]
-    if not candidates:
-        return ""
-    candidates.sort(key=lambda entry: entry.get("avail", 0), reverse=True)
-    return candidates[0].get("storage", "")
+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:
@@ -599,104 +593,35 @@ def _load_managed_container_records() -> List[Dict[str, Any]]:
     return records
 
 
-def _extract_host_totals(node_status: Dict[str, Any] | None) -> Tuple[Optional[int], Optional[int], Optional[int]]:
-    if not node_status:
-        return None, None, None
-    memory_total = node_status.get("memory", {}).get("total")
-    disk_total = node_status.get("disk", {}).get("total")
-    cpu_cores = node_status.get("cpuinfo", {}).get("cores")
-    host_ram = _bytes_to_mib(memory_total) if memory_total is not None else None
-    host_disk = _bytes_to_gib(disk_total) if disk_total is not None else None
-    host_cpu = _to_int(cpu_cores) if cpu_cores is not None else None
-    return host_ram, host_disk, host_cpu
-
-
-def _build_unmanaged_container_entry(
-    ct: Dict[str, Any],
-    cfg: Dict[str, Any],
-    vmid: str,
-    default_storage: str | None,
-    *,
-    entry_type: str = "lxc",
-) -> Dict[str, Any]:
-    ram_mib = _to_int(cfg.get("memory")) or _bytes_to_mib(ct.get("maxmem"))
-    disk_gib = int(round(_pick_disk_gib(entry_type, cfg, ct)))
-    cpu_share = _to_float(
-        cfg.get("cpulimit")
-        or cfg.get("cpus")
-        or cfg.get("cores")
-        or ct.get("cpus")
-        or ct.get("cpu")
-    )
-    hostname = ct.get("name") or cfg.get("hostname") or f"ct{vmid}"
-    storage = _pick_storage(entry_type, cfg, ct)
-    status = (ct.get("status") or "unknown").lower()
-    reserved = _parse_bool_flag(cfg.get("onboot"))
-    storage_matches_default = _storage_matches_default(storage, default_storage)
-    return {
-        "vmid": vmid,
-        "hostname": hostname,
-        "template": cfg.get("ostemplate"),
-        "storage": storage,
-        "disk_gib": disk_gib,
-        "ram_mib": ram_mib,
-        "cpu_share": cpu_share,
-        "reserve_on_boot": reserved,
-        "matches_default_storage": storage_matches_default,
-        "type": entry_type,
-        "status": status,
-        "managed": False,
-    }
-
-
-def _get_storage_snapshot(proxmox: Any, node: str, storage_name: str | None) -> Dict[str, Any] | None:
-    if not storage_name:
-        return None
-    try:
-        storage = proxmox.nodes(node).storage(storage_name).status.get()
-    except Exception as exc:
-        logger.debug("Unable to read storage status %s:%s: %s", node, storage_name, exc)
-        return None
-    total_bytes = storage.get("total")
-    avail_bytes = storage.get("avail")
-    used_bytes = storage.get("used")
-    return {
-        "storage": storage_name,
-        "total_gib": _bytes_to_gib(total_bytes) if total_bytes is not None else None,
-        "avail_gib": _bytes_to_gib(avail_bytes) if avail_bytes is not None else None,
-        "used_gib": _bytes_to_gib(used_bytes) if used_bytes is not None else None,
-    }
-
-
-def _storage_matches_default(storage_name: Any, default_storage: str | None) -> bool:
-    if not default_storage:
-        return True
-    return _normalize_storage_name(storage_name) == _normalize_storage_name(default_storage)
-
-
-def _build_managed_containers_summary(
-    records: List[Dict[str, Any]],
-    unmanaged_records: List[Dict[str, Any]],
-    node_status: Dict[str, Any] | None,
-    storage_snapshot: Dict[str, Any] | None,
-    default_storage: str | None,
-) -> Dict[str, Any]:
-    managed_containers: List[Dict[str, Any]] = []
+def _build_managed_containers_summary(records: List[Dict[str, Any]]) -> Dict[str, Any]:
     total_ram = 0
     total_disk = 0
     total_cpu_share = 0.0
+    containers: List[Dict[str, Any]] = []
 
-    for record in sorted(records, key=lambda entry: _to_int(entry.get("vmid"))):
-        ram_mib = _to_int(record.get("ram_mib"))
-        disk_gib = _to_int(record.get("disk_gib"))
-        cpu_share = _to_float(record.get("cpus"))
+    def _as_int(value: Any) -> int:
+        try:
+            return int(value)
+        except (TypeError, ValueError):
+            return 0
+
+    def _as_float(value: Any) -> float:
+        try:
+            return float(value)
+        except (TypeError, ValueError):
+            return 0.0
+
+    for record in sorted(records, key=lambda entry: _as_int(entry.get("vmid"))):
+        ram_mib = _as_int(record.get("ram_mib"))
+        disk_gib = _as_int(record.get("disk_gib"))
+        cpu_share = _as_float(record.get("cpus"))
         total_ram += ram_mib
         total_disk += disk_gib
         total_cpu_share += cpu_share
         status = (record.get("status") or "unknown").lower()
-        managed_containers.append(
+        containers.append(
             {
-                "vmid": str(_to_int(record.get("vmid"))) if record.get("vmid") is not None else None,
+                "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"),
@@ -706,131 +631,177 @@ def _build_managed_containers_summary(
                 "cpu_share": cpu_share,
                 "created_at": record.get("created_at"),
                 "status": status,
-                "managed": True,
-                "matches_default_storage": _storage_matches_default(record.get("storage"), default_storage),
             }
         )
 
-    unmanaged_total_ram = sum(
-        _to_int(entry.get("ram_mib"))
-        for entry in unmanaged_records
-        if entry.get("reserve_on_boot")
-    )
-    unmanaged_total_disk = sum(
-        _to_int(entry.get("disk_gib"))
-        for entry in unmanaged_records
-        if entry.get("matches_default_storage")
-    )
-    unmanaged_total_cpu = sum(
-        _to_float(entry.get("cpu_share"))
-        for entry in unmanaged_records
-        if entry.get("reserve_on_boot")
-    )
-
-    allocated_ram = total_ram + unmanaged_total_ram
-    allocated_disk = total_disk + unmanaged_total_disk
-    allocated_cpu = total_cpu_share + unmanaged_total_cpu
-
-    host_ram_node, host_disk_node, host_cpu_node = _extract_host_totals(node_status)
-    storage_host_disk = storage_snapshot.get("total_gib") if storage_snapshot else None
-    host_ram = host_ram_node
-    host_disk = storage_host_disk if storage_host_disk is not None else host_disk_node
-    host_cpu = host_cpu_node
-
-
     return {
         "updated_at": datetime.utcnow().isoformat() + "Z",
-        "count": len(managed_containers),
+        "count": len(containers),
         "total_ram_mib": total_ram,
         "total_disk_gib": total_disk,
         "total_cpu_share": round(total_cpu_share, 2),
-        "containers": managed_containers,
-        "unmanaged_containers": unmanaged_records,
-        "unmanaged_count": len(unmanaged_records),
-        "allocated_ram_mib": allocated_ram,
-        "allocated_disk_gib": allocated_disk,
-        "allocated_cpu_share": round(allocated_cpu, 2),
-        "available_ram_mib": _calculate_available(host_ram, allocated_ram) if host_ram is not None else None,
-        "available_disk_gib": _calculate_available(host_disk, allocated_disk) if host_disk is not None else None,
-        "available_cpu_share": _calculate_available(host_cpu, allocated_cpu) if host_cpu is not None else None,
-        "host_total_ram_mib": host_ram,
-        "host_total_disk_gib": host_disk,
-        "host_total_cpu_cores": host_cpu,
-        "default_storage": default_storage,
-        "default_storage_snapshot": storage_snapshot,
+        "containers": containers,
     }
 
 
+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,
-        managed_vmids: Set[str],
-        default_storage: str | None,
-    ) -> Tuple[Dict[str, str], List[Dict[str, Any]], Dict[str, Any] | None, Dict[str, Any] | None]:
-        statuses: Dict[str, str] = {}
-        unmanaged: List[Dict[str, Any]] = []
-        node_status: Dict[str, Any] | None = None
-        if not config:
-            return statuses, unmanaged, node_status, None
-        proxmox = None
-        node = None
+    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)
-            node_status = proxmox.nodes(node).status.get()
-            for ct in proxmox.nodes(node).lxc.get():
-                vmid_val = ct.get("vmid")
-                if vmid_val is None:
-                    continue
-                vmid_key = str(_to_int(vmid_val))
-                statuses[vmid_key] = (ct.get("status") or "unknown").lower()
-                if vmid_key in managed_vmids:
-                    continue
-                cfg: Dict[str, Any] = {}
-                try:
-                    cfg = proxmox.nodes(node).lxc(vmid_key).config.get() or {}
-                except Exception as exc:  # pragma: no cover - best effort
-                    logger.debug("Failed to read config for container %s: %s", vmid_key, exc)
-                description = (cfg.get("description") or "")
-                if MANAGED_MARKER in description:
-                    continue
-                unmanaged.append(
-                    _build_unmanaged_container_entry(ct, cfg, vmid_key, default_storage, entry_type="lxc")
-                )
-            for vm in proxmox.nodes(node).qemu.get():
-                vmid_val = vm.get("vmid")
-                if vmid_val is None:
-                    continue
-                vmid_key = str(_to_int(vmid_val))
-                statuses[vmid_key] = (vm.get("status") or "unknown").lower()
-                if vmid_key in managed_vmids:
-                    continue
-                cfg: Dict[str, Any] = {}
-                try:
-                    cfg = proxmox.nodes(node).qemu(vmid_key).config.get() or {}
-                except Exception as exc:
-                    logger.debug("Failed to read config for VM %s: %s", vmid_key, exc)
-                description = (cfg.get("description") or "")
-                if MANAGED_MARKER in description:
-                    continue
-                unmanaged.append(
-                    _build_unmanaged_container_entry(
-                        vm,
-                        cfg,
-                        vmid_key,
-                        default_storage,
-                        entry_type="qemu",
-                    )
-                )
+            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)
-        storage_snapshot = (
-            _get_storage_snapshot(proxmox, node, default_storage)
-            if proxmox and node
-            else None
-        )
-        return statuses, unmanaged, node_status, storage_snapshot
+            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:
@@ -840,22 +811,8 @@ def _get_managed_containers_summary(force: bool = False) -> Dict[str, Any]:
         return cached
     config = _load_config()
     records = _load_managed_container_records()
-    managed_vmids: Set[str] = {
-        str(_to_int(record.get("vmid"))) for record in records if record.get("vmid") is not None
-    }
-    default_storage = config.get("default_storage") if config else None
-    statuses, unmanaged, node_status, storage_snapshot = _refresh_container_statuses(
-        records, config, managed_vmids, default_storage
-    )
-    for record in records:
-        vmid = record.get("vmid")
-        if vmid is None:
-            continue
-        vmid_key = str(_to_int(vmid))
-        status = statuses.get(vmid_key)
-        if status:
-            record["status"] = status
-    summary = _build_managed_containers_summary(records, unmanaged, node_status, storage_snapshot, default_storage)
+    _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

{portacode-1.4.16.dev10.dist-info → portacode-1.4.16.dev11.dist-info}/METADATA

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

{portacode-1.4.16.dev10.dist-info → portacode-1.4.16.dev11.dist-info}/RECORD

@@ -1,7 +1,7 @@
 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=xQIvOHyr77yXKzNXQJL1rE01nrJdvUnM7LX3jaSU684,721
+portacode/_version.py,sha256=ZsUlJUljVebwmjOdkxbUPcwi8iyVjIuyBU9g68awYpA,721
 portacode/cli.py,sha256=mGLKoZ-T2FBF7IA9wUq0zyG0X9__-A1ao7gajjcVRH8,21828
 portacode/data.py,sha256=5-s291bv8J354myaHm1Y7CQZTZyRzMU3TGe5U4hb-FA,1591
 portacode/keypair.py,sha256=0OO4vHDcF1XMxCDqce61xFTlFwlTcmqe5HyGsXFEt7s,5838
@@ -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=5XUUzr24bs-QOMpuVPq071ZDAmhadKiMs2E-wO62kMw,86709
+portacode/connection/handlers/proxmox_infra.py,sha256=-zAmaOTCTJaic8sclb5Z0DVCl_pU7XePo86NKohi3gc,85295
 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.16.dev10.dist-info/licenses/LICENSE,sha256=2FGbCnUDgRYuQTkB1O1dUUpu5CVAjK1j4_p6ack9Z54,1066
+portacode-1.4.16.dev11.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.16.dev10.dist-info/METADATA,sha256=CYVCSXxYLiRseul0OVvOLRWWp2-Lv1u737bm-qT1hVk,13052
-portacode-1.4.16.dev10.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-portacode-1.4.16.dev10.dist-info/entry_points.txt,sha256=lLUUL-BM6_wwe44Xv0__5NQ1BnAz6jWjSMFvZdWW3zU,48
-portacode-1.4.16.dev10.dist-info/top_level.txt,sha256=TGhTYUxfW8SyVZc_zGgzjzc24gGT7nSw8Qf73liVRKM,41
-portacode-1.4.16.dev10.dist-info/RECORD,,
+portacode-1.4.16.dev11.dist-info/METADATA,sha256=nEvtzLLbq9J8jG-kubMsNMRQ07YdtEczInIarfWpGhY,13052
+portacode-1.4.16.dev11.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+portacode-1.4.16.dev11.dist-info/entry_points.txt,sha256=lLUUL-BM6_wwe44Xv0__5NQ1BnAz6jWjSMFvZdWW3zU,48
+portacode-1.4.16.dev11.dist-info/top_level.txt,sha256=TGhTYUxfW8SyVZc_zGgzjzc24gGT7nSw8Qf73liVRKM,41
+portacode-1.4.16.dev11.dist-info/RECORD,,