portacode 1.4.11.dev0__py3-none-any.whl → 1.4.11.dev5__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.11.dev0'
-__version_tuple__ = version_tuple = (1, 4, 11, 'dev0')
+__version__ = version = '1.4.11.dev5'
+__version_tuple__ = version_tuple = (1, 4, 11, 'dev5')
 
 __commit_id__ = commit_id = None

portacode/cli.py

@@ -405,6 +405,45 @@ def send_control(message: str, gateway: str | None) -> None:  # noqa: D401 – C
         finally:
             await mgr.stop()
 
+        asyncio.run(_run())
+
+
+@cli.command("revert_proxmox_infra")
+@click.option("--gateway", "gateway", "-g", help="Gateway websocket URL (overrides env/ default)")
+def revert_proxmox_infra(gateway: str | None) -> None:  # noqa: D401 – Click callback
+    """Revert the Proxmox infrastructure configuration stored on this device."""
+
+    target_gateway = gateway or os.getenv(GATEWAY_ENV) or GATEWAY_URL
+
+    async def _run() -> None:
+        keypair = get_or_create_keypair()
+        mgr = ConnectionManager(target_gateway, keypair, debug=False)
+        await mgr.start()
+
+        for _ in range(20):
+            if mgr.mux is not None:
+                break
+            await asyncio.sleep(0.1)
+        if mgr.mux is None:
+            click.echo("Failed to initialise connection – aborting.")
+            await mgr.stop()
+            return
+
+        ctl = mgr.mux.get_channel(0)
+        await ctl.send({"cmd": "revert_proxmox_infra"})
+
+        try:
+            with click.progressbar(length=30, label="Waiting for revert response") as bar:
+                for _ in range(30):
+                    try:
+                        reply = await asyncio.wait_for(ctl.recv(), timeout=0.1)
+                        click.echo(click.style("< " + json.dumps(reply, indent=2), fg="cyan"))
+                    except asyncio.TimeoutError:
+                        pass
+                    bar.update(1)
+        finally:
+            await mgr.stop()
+
     asyncio.run(_run())
 
 

portacode/connection/handlers/WEBSOCKET_PROTOCOL.md

@@ -322,7 +322,7 @@ This action does not require any payload fields.
 
 ### `setup_proxmox_infra`
 
-Configures a Proxmox node for Portacode infrastructure usage (API token storage, default storage selection, and bridge setup). Handled by [`ConfigureProxmoxInfraHandler`](./proxmox_infra.py).
+Configures a Proxmox node for Portacode infrastructure usage (API token validation, automatic storage/template detection, bridge/NAT setup, and connectivity verification). Handled by [`ConfigureProxmoxInfraHandler`](./proxmox_infra.py).
 
 **Payload Fields:**
 
@@ -333,7 +333,52 @@ Configures a Proxmox node for Portacode infrastructure usage (API token storage,
 **Responses:**
 
 *   On success, the device will emit a [`proxmox_infra_configured`](#proxmox_infra_configured-event) event with the persisted infra snapshot.
-*   On failure, the device will emit an [`error`](#error) event with details (e.g., permission issues, missing proxmoxer/dnsmasq, or missing root privileges).
+*   On failure, the device will emit an [`error`](#error) event with details (e.g., permission issues, missing proxmoxer/dnsmasq, missing root privileges, or failed network verification).
+
+### `revert_proxmox_infra`
+
+Reverts the Proxmox infrastructure network changes and clears the stored API token. Handled by [`RevertProxmoxInfraHandler`](./proxmox_infra.py).
+
+**Payload Fields:**
+
+This action does not require any payload fields.
+
+**Responses:**
+
+*   On success, the device will emit a [`proxmox_infra_reverted`](#proxmox_infra_reverted-event) event containing the cleared snapshot.
+
+### `create_proxmox_container`
+
+Creates a Portacode-managed LXC container, starts it, and bootstraps the Portacode service by running the commands from [`proxmox_management/setup_portacode.py`](../../proxmox_management/setup_portacode.py). Handled by [`CreateProxmoxContainerHandler`](./proxmox_infra.py).
+
+**Payload Fields:**
+
+*   `template` (string, required): Template identifier to use for the CT (e.g., `local:vztmpl/ubuntu-22.04-standard_22.04-1_amd64.tar.zst`).
+*   `disk_gib` (integer, optional): Rootfs size in GiB (defaults to 32).
+*   `ram_mib` (integer, optional): Memory size in MiB (defaults to 2048).
+*   `cpus` (integer, optional): Number of CPU cores (defaults to 1).
+*   `hostname` (string, optional): Desired hostname inside the container; defaults to `ct<vmid>`.
+*   `username` (string, optional): OS user to provision (defaults to `svcuser`).
+*   `password` (string, optional): Password for the user (used only during provisioning).
+*   `ssh_key` (string, optional): SSH public key to add to the user.
+
+**Responses:**
+
+*   On success, the device will emit a [`proxmox_container_created`](#proxmox_container_created-event) event that includes the Portacode auth key produced inside the container.
+*   On failure, the device will emit an [`error`](#error) event.
+
+### `proxmox_container_created`
+
+Emitted after a successful `create_proxmox_container` action. Contains the new container ID, the Portacode public key produced inside the container, and the bootstrap logs.
+
+**Event Fields:**
+
+*   `success` (boolean): True when the CT and Portacode bootstrap succeed.
+*   `message` (string): Human-readable summary (e.g., `Container 103 is ready`).
+*   `ctid` (string): The numeric CT ID.
+*   `public_key` (string): Portacode public auth key created inside the new container.
+*   `container` (object): Metadata such as `vmid`, `hostname`, `template`, `storage`, `disk_gib`, `ram_mib`, and `cpus`.
+*   `setup_steps` (array[object]): Detailed bootstrap step results (name, stdout/stderr, elapsed time, and status).
 
 ### `clock_sync_request`
 
@@ -993,6 +1038,7 @@ Provides system information in response to a `system_info` action. Handled by [`
                 *   `applied` (boolean): True when the bridge/NAT services were successfully configured.
                 *   `message` (string|null): Informational text about the network setup attempt.
                 *   `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.
     *   `portacode_version` (string): Installed CLI version returned by `portacode.__version__`.
 
@@ -1006,6 +1052,29 @@ Emitted after a successful `setup_proxmox_infra` action. The event reports the s
 *   `message` (string): User-facing summary (e.g., "Proxmox infrastructure configured").
 *   `infra` (object): Same snapshot described under [`system_info`](#system_info-event) `proxmox.infra`.
 
+### `proxmox_infra_reverted`
+
+Emitted after a successful `revert_proxmox_infra` action. Indicates the infra config is no longer present and the network was restored.
+
+**Event Fields:**
+
+*   `success` (boolean): True when the revert completed.
+*   `message` (string): Summary (e.g., "Proxmox infrastructure configuration reverted").
+*   `infra` (object): Snapshot with `configured=false` (matching [`system_info`](#system_info-event) `proxmox.infra`).
+
+### `proxmox_container_created`
+
+Emitted after a successful `create_proxmox_container` action to report the newly created CT, its Portacode public key, and the bootstrap logs.
+
+**Event Fields:**
+
+*   `success` (boolean): True when the CT provisioning and `portacode connect` steps complete.
+*   `message` (string): Human-readable summary (e.g., `Container 102 is ready`).
+*   `ctid` (string): The container ID that was created.
+*   `public_key` (string): Portacode public auth key discovered inside the container.
+*   `container` (object): Metadata such as `vmid`, `hostname`, `template`, `storage`, `disk_gib`, `ram_mib`, and `cpus`.
+*   `setup_steps` (array[object]): Detailed bootstrap step reports including stdout/stderr, elapsed time, and pass/fail status.
+
 ### <a name="clock_sync_response"></a>`clock_sync_response`
 
 Reply sent by the gateway immediately after receiving a `clock_sync_request`. Devices use this event plus the measured round-trip time to keep their local `ntp_clock` offset accurate.

portacode/connection/handlers/__init__.py

@@ -14,6 +14,7 @@ from .terminal_handlers import (
     TerminalListHandler,
 )
 from .system_handlers import SystemInfoHandler
+from .update_handler import UpdatePortacodeHandler
 from .file_handlers import (
     FileReadHandler,
     FileWriteHandler,
@@ -40,8 +41,11 @@ from .project_state_handlers import (
     ProjectStateGitRevertHandler,
     ProjectStateGitCommitHandler,
 )
-from .update_handler import UpdatePortacodeHandler
-from .proxmox_infra import ConfigureProxmoxInfraHandler
+from .proxmox_infra import (
+    ConfigureProxmoxInfraHandler,
+    CreateProxmoxContainerHandler,
+    RevertProxmoxInfraHandler,
+)
 
 __all__ = [
     "BaseHandler",
@@ -54,6 +58,7 @@ __all__ = [
     "TerminalListHandler",
     "SystemInfoHandler",
     "ConfigureProxmoxInfraHandler",
+    "CreateProxmoxContainerHandler",
     # File operation handlers (optional - register as needed)
     "FileReadHandler",
     "FileWriteHandler", 
@@ -80,4 +85,5 @@ __all__ = [
     "ProjectStateGitRevertHandler",
     "ProjectStateGitCommitHandler",
     "UpdatePortacodeHandler",
+    "RevertProxmoxInfraHandler",
 ] 

portacode/connection/handlers/proxmox_infra.py

@@ -9,9 +9,10 @@ import shutil
 import stat
 import subprocess
 import sys
+import time
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Dict, Iterable, List, Tuple
+from typing import Any, Dict, Iterable, List, Optional, Tuple
 
 import platformdirs
 
@@ -21,6 +22,10 @@ logger = logging.getLogger(__name__)
 
 CONFIG_DIR = Path(platformdirs.user_config_dir("portacode"))
 CONFIG_PATH = CONFIG_DIR / "proxmox_infra.json"
+REPO_ROOT = Path(__file__).resolve().parents[3]
+NET_SETUP_SCRIPT = REPO_ROOT / "proxmox_management" / "net_setup.py"
+CONTAINERS_DIR = CONFIG_DIR / "containers"
+MANAGED_MARKER = "portacode-managed:true"
 
 DEFAULT_HOST = "localhost"
 DEFAULT_NODE_NAME = os.uname().nodename.split(".", 1)[0]
@@ -214,10 +219,352 @@ def _ensure_bridge(bridge: str = DEFAULT_BRIDGE) -> Dict[str, Any]:
     return {"applied": True, "bridge": bridge, "message": f"Bridge {bridge} configured"}
 
 
+def _verify_connectivity(timeout: float = 5.0) -> bool:
+    try:
+        _call_subprocess(["/bin/ping", "-c", "2", "1.1.1.1"], check=True, timeout=timeout)
+        return True
+    except (subprocess.CalledProcessError, subprocess.TimeoutExpired):
+        return False
+
+
+def _revert_bridge() -> None:
+    try:
+        if NET_SETUP_SCRIPT.exists():
+            _call_subprocess([sys.executable, str(NET_SETUP_SCRIPT), "revert"], check=True)
+    except Exception as exc:
+        logger.warning("Proxmox bridge revert failed: %s", exc)
+
+
+def _ensure_containers_dir() -> None:
+    CONTAINERS_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def _format_rootfs(storage: str, disk_gib: int, storage_type: str) -> str:
+    if storage_type in ("lvm", "lvmthin"):
+        return f"{storage}:{disk_gib}"
+    return f"{storage}:{disk_gib}G"
+
+
+def _get_storage_type(storages: Iterable[Dict[str, Any]], storage_name: str) -> str:
+    for entry in storages:
+        if entry.get("storage") == storage_name:
+            return entry.get("type", "")
+    return ""
+
+
+def _validate_positive_int(value: Any, default: int) -> int:
+    try:
+        candidate = int(value)
+        if candidate > 0:
+            return candidate
+    except Exception:
+        pass
+    return default
+
+
+def _wait_for_task(proxmox: Any, node: str, upid: str) -> Tuple[Dict[str, Any], float]:
+    start = time.time()
+    while True:
+        status = proxmox.nodes(node).tasks(upid).status.get()
+        if status.get("status") == "stopped":
+            return status, time.time() - start
+        time.sleep(1)
+
+
+def _list_running_managed(proxmox: Any, node: str) -> List[Tuple[str, Dict[str, Any]]]:
+    entries = []
+    for ct in proxmox.nodes(node).lxc.get():
+        if ct.get("status") != "running":
+            continue
+        vmid = str(ct.get("vmid"))
+        cfg = proxmox.nodes(node).lxc(vmid).config.get()
+        if cfg and MANAGED_MARKER in (cfg.get("description") or ""):
+            entries.append((vmid, cfg))
+    return entries
+
+
+def _start_container(proxmox: Any, node: str, vmid: int) -> Tuple[Dict[str, Any], float]:
+    status = proxmox.nodes(node).lxc(vmid).status.current.get()
+    if status.get("status") == "running":
+        uptime = status.get("uptime", 0)
+        logger.info("Container %s already running (%ss)", vmid, uptime)
+        return status, 0.0
+
+    node_status = proxmox.nodes(node).status.get()
+    mem_total_mb = int(node_status.get("memory", {}).get("total", 0) // (1024**2))
+    cores_total = int(node_status.get("cpuinfo", {}).get("cores", 0))
+
+    running = _list_running_managed(proxmox, node)
+    used_mem_mb = sum(int(cfg.get("memory", 0)) for _, cfg in running)
+    used_cores = sum(int(cfg.get("cores", 0)) for _, cfg in running)
+
+    target_cfg = proxmox.nodes(node).lxc(vmid).config.get()
+    target_mem_mb = int(target_cfg.get("memory", 0))
+    target_cores = int(target_cfg.get("cores", 0))
+
+    if mem_total_mb and used_mem_mb + target_mem_mb > mem_total_mb:
+        raise RuntimeError("Not enough RAM to start this container safely.")
+    if cores_total and used_cores + target_cores > cores_total:
+        raise RuntimeError("Not enough CPU cores to start this container safely.")
+
+    upid = proxmox.nodes(node).lxc(vmid).status.start.post()
+    return _wait_for_task(proxmox, node, upid)
+
+
+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")
+
+
+def _build_container_payload(message: Dict[str, Any], config: Dict[str, Any]) -> Dict[str, Any]:
+    templates = config.get("templates") or []
+    default_template = templates[0] if templates else ""
+    template = message.get("template") or default_template
+    if not template:
+        raise ValueError("Container template is required.")
+
+    bridge = config.get("network", {}).get("bridge", DEFAULT_BRIDGE)
+    hostname = (message.get("hostname") or "").strip()
+    disk_gib = _validate_positive_int(message.get("disk_gib") or message.get("disk"), 32)
+    ram_mib = _validate_positive_int(message.get("ram_mib") or message.get("ram"), 2048)
+    cpus = _validate_positive_int(message.get("cpus"), 1)
+    storage = message.get("storage") or config.get("default_storage") or ""
+    if not storage:
+        raise ValueError("Storage pool could not be determined.")
+
+    user = (message.get("username") or "svcuser").strip() or "svcuser"
+    password = message.get("password") or ""
+    ssh_key = (message.get("ssh_key") or "").strip()
+
+    payload = {
+        "template": template,
+        "storage": storage,
+        "disk_gib": disk_gib,
+        "ram_mib": ram_mib,
+        "cpus": cpus,
+        "hostname": hostname,
+        "net0": f"name=eth0,bridge={bridge},ip=dhcp",
+        "unprivileged": 1,
+        "swap_mb": 0,
+        "username": user,
+        "password": password,
+        "ssh_public_key": ssh_key,
+        "description": MANAGED_MARKER,
+    }
+    return payload
+
+
+def _connect_proxmox(config: Dict[str, Any]) -> Any:
+    ProxmoxAPI = _ensure_proxmoxer()
+    return ProxmoxAPI(
+        config.get("host", DEFAULT_HOST),
+        user=config.get("user"),
+        token_name=config.get("token_name"),
+        token_value=config.get("token_value"),
+        verify_ssl=config.get("verify_ssl", False),
+        timeout=60,
+    )
+
+
+def _run_pct(vmid: int, cmd: str) -> Dict[str, Any]:
+    full = ["pct", "exec", str(vmid), "--", "bash", "-lc", cmd]
+    start = time.time()
+    proc = subprocess.run(full, text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    return {
+        "cmd": cmd,
+        "returncode": proc.returncode,
+        "stdout": proc.stdout.strip(),
+        "stderr": proc.stderr.strip(),
+        "elapsed_s": round(time.time() - start, 2),
+    }
+
+
+def _run_pct_check(vmid: int, cmd: str) -> Dict[str, Any]:
+    res = _run_pct(vmid, cmd)
+    if res["returncode"] != 0:
+        raise RuntimeError(res.get("stderr") or res.get("stdout") or "command failed")
+    return res
+
+
+def _portacode_connect_and_read_key(vmid: int, user: str, timeout_s: int = 10) -> Dict[str, Any]:
+    cmd = ["pct", "exec", str(vmid), "--", "bash", "-lc", f"su - {user} -c 'portacode connect'"]
+    proc = subprocess.Popen(cmd, text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    start = time.time()
+
+    data_dir_cmd = f"su - {user} -c 'echo -n ${{XDG_DATA_HOME:-$HOME/.local/share}}'"
+    data_dir = _run_pct_check(vmid, data_dir_cmd)["stdout"].strip()
+    key_dir = f"{data_dir}/portacode/keys"
+    pub_path = f"{key_dir}/id_portacode.pub"
+    priv_path = f"{key_dir}/id_portacode"
+
+    def file_size(path: str) -> Optional[int]:
+        stat_cmd = f"su - {user} -c 'test -s {path} && stat -c %s {path}'"
+        res = _run_pct(vmid, stat_cmd)
+        if res["returncode"] != 0:
+            return None
+        try:
+            return int(res["stdout"].strip())
+        except ValueError:
+            return None
+
+    last_pub = last_priv = None
+    stable = 0
+    while time.time() - start < timeout_s:
+        if proc.poll() is not None:
+            out, err = proc.communicate(timeout=1)
+            return {
+                "ok": False,
+                "error": "portacode connect exited before keys were created",
+                "stdout": (out or "").strip(),
+                "stderr": (err or "").strip(),
+            }
+        pub_size = file_size(pub_path)
+        priv_size = file_size(priv_path)
+        if pub_size and priv_size:
+            if pub_size == last_pub and priv_size == last_priv:
+                stable += 1
+            else:
+                stable = 0
+            last_pub, last_priv = pub_size, priv_size
+            if stable >= 1:
+                break
+        time.sleep(1)
+
+    if stable < 1:
+        proc.terminate()
+        try:
+            proc.wait(timeout=3)
+        except subprocess.TimeoutExpired:
+            proc.kill()
+        out, err = proc.communicate(timeout=1)
+        return {
+            "ok": False,
+            "error": "timed out waiting for portacode key files",
+            "stdout": (out or "").strip(),
+            "stderr": (err or "").strip(),
+        }
+
+    proc.terminate()
+    try:
+        proc.wait(timeout=3)
+    except subprocess.TimeoutExpired:
+        proc.kill()
+
+    key_res = _run_pct(vmid, f"su - {user} -c 'cat {pub_path}'")
+    return {
+        "ok": True,
+        "public_key": key_res["stdout"].strip(),
+    }
+
+
+def _summarize_error(res: Dict[str, Any]) -> str:
+    text = f"{res.get('stdout','')}\n{res.get('stderr','')}"
+    if "No space left on device" in text:
+        return "Disk full inside container; increase rootfs or clean apt cache."
+    if "Unable to acquire the dpkg frontend lock" in text or "lock-frontend" in text:
+        return "Another apt/dpkg process is running; retry after it finishes."
+    if "Temporary failure resolving" in text or "Could not resolve" in text:
+        return "DNS/network resolution failed inside container."
+    if "Failed to fetch" in text:
+        return "Package repo fetch failed; check network and apt sources."
+    return "Command failed; see stdout/stderr for details."
+
+
+def _run_setup_steps(vmid: int, steps: List[Dict[str, Any]], user: str) -> Tuple[List[Dict[str, Any]], bool]:
+    results: List[Dict[str, Any]] = []
+    for step in steps:
+        if step.get("type") == "portacode_connect":
+            res = _portacode_connect_and_read_key(vmid, user, timeout_s=step.get("timeout_s", 10))
+            res["name"] = step["name"]
+            results.append(res)
+            if not res.get("ok"):
+                return results, False
+            continue
+
+        attempts = 0
+        while True:
+            attempts += 1
+            res = _run_pct(vmid, step["cmd"])
+            res["name"] = step["name"]
+            res["attempt"] = attempts
+            if res["returncode"] != 0:
+                res["error_summary"] = _summarize_error(res)
+            results.append(res)
+            if res["returncode"] == 0:
+                break
+            retry_on = step.get("retry_on", [])
+            if attempts >= step.get("retries", 0) + 1:
+                return results, False
+            if any(tok in (res.get("stderr", "") + res.get("stdout", "")) for tok in retry_on):
+                time.sleep(step.get("retry_delay_s", 3))
+                continue
+            return results, False
+    return results, True
+
+
+def _bootstrap_portacode(vmid: int, user: str, password: str, ssh_key: str) -> Tuple[str, List[Dict[str, Any]]]:
+    steps = [
+        {
+            "name": "apt_update",
+            "cmd": "apt-get update -y",
+            "retries": 4,
+            "retry_delay_s": 5,
+            "retry_on": [
+                "Temporary failure resolving",
+                "Could not resolve",
+                "Failed to fetch",
+            ],
+        },
+        {
+            "name": "install_deps",
+            "cmd": "apt-get install -y python3 python3-pip sudo --fix-missing",
+            "retries": 5,
+            "retry_delay_s": 5,
+            "retry_on": [
+                "lock-frontend",
+                "Unable to acquire the dpkg frontend lock",
+                "Temporary failure resolving",
+                "Could not resolve",
+                "Failed to fetch",
+            ],
+        },
+        {"name": "user_exists", "cmd": f"id -u {user} >/dev/null 2>&1 || adduser --disabled-password --gecos '' {user}", "retries": 0},
+        {"name": "add_sudo", "cmd": f"usermod -aG sudo {user}", "retries": 0},
+    ]
+    if password:
+        steps.append({"name": "set_password", "cmd": f"echo '{user}:{password}' | chpasswd", "retries": 0})
+    if ssh_key:
+        steps.append({
+            "name": "add_ssh_key",
+            "cmd": f"install -d -m 700 /home/{user}/.ssh && echo '{ssh_key}' >> /home/{user}/.ssh/authorized_keys && chown -R {user}:{user} /home/{user}/.ssh",
+            "retries": 0,
+        })
+    steps.extend([
+        {"name": "pip_upgrade", "cmd": "python3 -m pip install --upgrade pip", "retries": 0},
+        {"name": "install_portacode", "cmd": "python3 -m pip install --upgrade portacode", "retries": 0},
+        {"name": "portacode_connect", "type": "portacode_connect", "timeout_s": 30},
+    ])
+
+    results, ok = _run_setup_steps(vmid, steps, user)
+    if not ok:
+        raise RuntimeError("Portacode bootstrap steps failed.")
+    key_step = next((entry for entry in results if entry.get("name") == "portacode_connect"), None)
+    public_key = key_step.get("public_key") if key_step else None
+    if not public_key:
+        raise RuntimeError("Portacode connect did not return a public key.")
+    return public_key, results
+
+
 def build_snapshot(config: Dict[str, Any]) -> Dict[str, Any]:
-    if not config:
-        return {"configured": False}
     network = config.get("network", {})
+    base_network = {
+        "applied": network.get("applied", False),
+        "message": network.get("message"),
+        "bridge": network.get("bridge", DEFAULT_BRIDGE),
+    }
+    if not config:
+        return {"configured": False, "network": base_network}
     return {
         "configured": True,
         "host": config.get("host"),
@@ -227,11 +574,7 @@ def build_snapshot(config: Dict[str, Any]) -> Dict[str, Any]:
         "default_storage": config.get("default_storage"),
         "templates": config.get("templates") or [],
         "last_verified": config.get("last_verified"),
-        "network": {
-            "applied": network.get("applied", False),
-            "message": network.get("message"),
-            "bridge": network.get("bridge", DEFAULT_BRIDGE),
-        },
+        "network": base_network,
     }
 
 
@@ -254,6 +597,13 @@ def configure_infrastructure(token_identifier: str, token_value: str, verify_ssl
     network: Dict[str, Any] = {}
     try:
         network = _ensure_bridge()
+        # Wait for network convergence before validating connectivity
+        time.sleep(2)
+        if _verify_connectivity():
+            network["health"] = "healthy"
+        else:
+            network = {"applied": False, "bridge": DEFAULT_BRIDGE, "message": "Connectivity check failed; bridge reverted"}
+            _revert_bridge()
     except PermissionError as exc:
         network = {"applied": False, "message": str(exc), "bridge": DEFAULT_BRIDGE}
         logger.warning("Bridge setup skipped: %s", exc)
@@ -287,6 +637,124 @@ def get_infra_snapshot() -> Dict[str, Any]:
     return snapshot
 
 
+def revert_infrastructure() -> Dict[str, Any]:
+    _revert_bridge()
+    if CONFIG_PATH.exists():
+        CONFIG_PATH.unlink()
+    snapshot = build_snapshot({})
+    snapshot["network"] = snapshot.get("network", {})
+    snapshot["network"]["applied"] = False
+    snapshot["network"]["message"] = "Reverted to previous network state"
+    snapshot["network"]["bridge"] = DEFAULT_BRIDGE
+    return snapshot
+
+
+def _allocate_vmid(proxmox: Any) -> int:
+    return int(proxmox.cluster.nextid.get())
+
+
+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 = _allocate_vmid(proxmox)
+    if not payload.get("hostname"):
+        payload["hostname"] = f"ct{vmid}"
+    try:
+        upid = proxmox.nodes(node).lxc.create(
+            vmid=vmid,
+            hostname=payload["hostname"],
+            ostemplate=payload["template"],
+            rootfs=rootfs,
+            memory=int(payload["ram_mib"]),
+            swap=int(payload.get("swap_mb", 0)),
+            cores=int(payload.get("cpus", 1)),
+            cpuunits=int(payload.get("cpuunits", 256)),
+            net0=payload["net0"],
+            unprivileged=int(payload.get("unprivileged", 1)),
+            description=payload.get("description", MANAGED_MARKER),
+            password=payload.get("password") or None,
+            ssh_public_keys=payload.get("ssh_public_key") or None,
+        )
+        status, elapsed = _wait_for_task(proxmox, node, upid)
+        return vmid, elapsed
+    except ResourceException as exc:
+        raise RuntimeError(f"Failed to create container: {exc}") from exc
+
+
+class CreateProxmoxContainerHandler(SyncHandler):
+    """Provision a new managed LXC container via the Proxmox API."""
+
+    @property
+    def command_name(self) -> str:
+        return "create_proxmox_container"
+
+    def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        logger.info("create_proxmox_container command received")
+        if os.geteuid() != 0:
+            logger.error("container creation rejected: not running as root")
+            raise PermissionError("Container creation requires root privileges.")
+
+        config = _load_config()
+        if not config or not config.get("token_value"):
+            logger.error("container creation rejected: infra not configured")
+            raise ValueError("Proxmox infrastructure is not configured.")
+        if not config.get("network", {}).get("applied"):
+            logger.error("container creation rejected: network bridge not applied")
+            raise RuntimeError("Proxmox bridge setup must be applied before creating containers.")
+
+        proxmox = _connect_proxmox(config)
+        node = config.get("node") or DEFAULT_NODE_NAME
+        payload = _build_container_payload(message, config)
+        payload["cpuunits"] = max(int(payload["cpus"] * 1024), 10)
+        payload["memory"] = int(payload["ram_mib"])
+        payload["node"] = node
+        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, _ = _instantiate_container(proxmox, node, payload)
+        except Exception as exc:
+            logger.exception("container instantiation failed")
+            raise
+
+        payload["vmid"] = vmid
+        payload["created_at"] = datetime.utcnow().isoformat() + "Z"
+        _write_container_record(vmid, payload)
+
+        try:
+            _start_container(proxmox, node, vmid)
+            public_key, steps = _bootstrap_portacode(vmid, payload["username"], payload["password"], payload["ssh_public_key"])
+        except Exception:
+            logger.exception("failed to start/setup container %s", vmid)
+            raise
+
+        return {
+            "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["hostname"],
+                "template": payload["template"],
+                "storage": payload["storage"],
+                "disk_gib": payload["disk_gib"],
+                "ram_mib": payload["ram_mib"],
+                "cpus": payload["cpus"],
+            },
+            "setup_steps": steps,
+        }
+
+
 class ConfigureProxmoxInfraHandler(SyncHandler):
     @property
     def command_name(self) -> str:
@@ -305,3 +773,18 @@ class ConfigureProxmoxInfraHandler(SyncHandler):
             "message": "Proxmox infrastructure configured",
             "infra": snapshot,
         }
+
+
+class RevertProxmoxInfraHandler(SyncHandler):
+    @property
+    def command_name(self) -> str:
+        return "revert_proxmox_infra"
+
+    def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        snapshot = revert_infrastructure()
+        return {
+            "event": "proxmox_infra_reverted",
+            "success": True,
+            "message": "Proxmox infrastructure configuration reverted",
+            "infra": snapshot,
+        }

portacode/connection/handlers/system_handlers.py

@@ -1,4 +1,5 @@
 """System command handlers."""
+from __future__ import annotations
 
 import concurrent.futures
 import getpass
@@ -7,6 +8,7 @@ import logging
 import os
 import platform
 import shutil
+import subprocess
 import threading
 from pathlib import Path
 from typing import Any, Dict
@@ -128,18 +130,57 @@ def _get_playwright_info() -> Dict[str, Any]:
     return result
 
 
-def _get_proxmox_info() -> Dict[str, Any]:
-    """Detect if the current host is a Proxmox node."""
-    info: Dict[str, Any] = {"is_proxmox_node": False, "version": None}
+def _run_probe_command(cmd: list[str]) -> str | None:
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True, timeout=3)
+    except (subprocess.CalledProcessError, FileNotFoundError, subprocess.TimeoutExpired):
+        return None
+    return result.stdout.strip()
+
+
+def _parse_pveversion(output: str) -> str | None:
+    first_token = output.split(None, 1)[0] if output else ""
+    if not first_token:
+        return None
+    if "/" in first_token:
+        return first_token.split("/", 1)[1]
+    return first_token
+
+
+def _parse_dpkg_version(output: str) -> str | None:
+    for line in output.splitlines():
+        if line.lower().startswith("version:"):
+            return line.split(":", 1)[1].strip()
+    return None
+
+
+def _get_proxmox_version() -> str | None:
     release_file = Path("/etc/proxmox-release")
     if release_file.exists():
-        info["is_proxmox_node"] = True
         try:
-            info["version"] = release_file.read_text().strip()
+            return release_file.read_text().strip()
         except Exception:
-            info["version"] = None
-    elif Path("/etc/pve").exists():
+            pass
+    value = _run_probe_command(["pveversion"])
+    parsed = _parse_pveversion(value or "")
+    if parsed:
+        return parsed
+    for pkg in ("pve-manager", "proxmox-ve"):
+        pkg_output = _run_probe_command(["dpkg", "-s", pkg])
+        parsed = _parse_dpkg_version(pkg_output or "")
+        if parsed:
+            return parsed
+    return None
+
+
+def _get_proxmox_info() -> Dict[str, Any]:
+    """Detect if the current host is a Proxmox node."""
+    info: Dict[str, Any] = {"is_proxmox_node": False, "version": None}
+    if Path("/etc/proxmox-release").exists() or Path("/etc/pve").exists():
         info["is_proxmox_node"] = True
+    version = _get_proxmox_version()
+    if version:
+        info["version"] = version
     info["infra"] = get_infra_snapshot()
     return info
 

portacode/connection/terminal.py

@@ -53,6 +53,8 @@ from .handlers import (
     ProjectStateGitCommitHandler,
     UpdatePortacodeHandler,
     ConfigureProxmoxInfraHandler,
+    CreateProxmoxContainerHandler,
+    RevertProxmoxInfraHandler,
 )
 from .handlers.project_aware_file_handlers import (
     ProjectAwareFileWriteHandler,
@@ -474,6 +476,8 @@ class TerminalManager:
         self._command_registry.register(ProjectStateGitCommitHandler)
         # System management handlers
         self._command_registry.register(ConfigureProxmoxInfraHandler)
+        self._command_registry.register(CreateProxmoxContainerHandler)
+        self._command_registry.register(RevertProxmoxInfraHandler)
         self._command_registry.register(UpdatePortacodeHandler)
 
     # ---------------------------------------------------------------------

{portacode-1.4.11.dev0.dist-info → portacode-1.4.11.dev5.dist-info}/METADATA

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

{portacode-1.4.11.dev0.dist-info → portacode-1.4.11.dev5.dist-info}/RECORD

@@ -1,8 +1,8 @@
 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=V3stafZrckfijvIH49elVCm8cQ_x4AD5VnTvqB60X_0,719
-portacode/cli.py,sha256=R6BkYM-o2MCUETk-o2h-U_24E96EbVmQpIXJJY2H08Y,20387
+portacode/_version.py,sha256=etzGixK9D-N8iE-N-EQixfapn6X63fGLccK__6i42Js,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
@@ -12,20 +12,20 @@ portacode/connection/README.md,sha256=f9rbuIEKa7cTm9C98rCiBbEtbiIXQU11esGSNhSMiJ
 portacode/connection/__init__.py,sha256=atqcVGkViIEd7pRa6cP2do07RJOM0UWpbnz5zXjGktU,250
 portacode/connection/client.py,sha256=jtLb9_YufqPkzi9t8VQH3iz_JEMisbtY6a8L9U5weiU,14181
 portacode/connection/multiplex.py,sha256=L-TxqJ_ZEbfNEfu1cwxgJ5vUdyRzZjsMy2Kx1diiZys,5237
-portacode/connection/terminal.py,sha256=UpH3FywKSY2l07k76sa4B3n31ecb4Jm5QsvkTZPGCIo,44395
+portacode/connection/terminal.py,sha256=NFkbbJe4Rz5XUi1WYEf9kXJqH8ETqqC9tcQhVORG3Y8,44599
 portacode/connection/handlers/README.md,sha256=HsLZG1QK1JNm67HsgL6WoDg9nxzKXxwkc5fJPFJdX5g,12169
-portacode/connection/handlers/WEBSOCKET_PROTOCOL.md,sha256=De95QT1lT69moV64Qubhrxb7xE-j8lvSoD_-Svyhr9s,86690
-portacode/connection/handlers/__init__.py,sha256=4LuqzmVtD_O7EtN6TTGZc2Co6UD2dmPCJ_6qcIKEfz8,2496
+portacode/connection/handlers/WEBSOCKET_PROTOCOL.md,sha256=1cYtf0iJBtY_Q4dadmKSdcHd67zg1f2mf-Gnm4-oI08,90511
+portacode/connection/handlers/__init__.py,sha256=iiyF3smwiI0IeDYzWQTl2PPVfW6aSp-g2CSO1ZTo9Ho,2641
 portacode/connection/handlers/base.py,sha256=oENFb-Fcfzwk99Qx8gJQriEMiwSxwygwjOiuCH36hM4,10231
 portacode/connection/handlers/chunked_content.py,sha256=h6hXRmxSeOgnIxoU8CkmvEf2Odv-ajPrpHIe_W3GKcA,9251
 portacode/connection/handlers/diff_handlers.py,sha256=iYTIRCcpEQ03vIPKZCsMTE5aZbQw6sF04M3dM6rUV8Q,24477
 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=YocSgNus0TQPOEPUBuuXy-crhyCfpPZV3Mhlwo7iwQQ,10903
+portacode/connection/handlers/proxmox_infra.py,sha256=P9XjBuHkqRsJYK9Y_Ei7kTyK__cwkf2u-W5-3uVB_cw,29286
 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=KfmLC5WOZR7gMOrL9mf6_XLhK5VuDhzgOmOdLi0qyLw,9494
+portacode/connection/handlers/system_handlers.py,sha256=AKh7IbwptlLYrbSw5f-DHigvlaKHsg9lDP-lkAUm8cE,10755
 portacode/connection/handlers/tab_factory.py,sha256=yn93h6GASjD1VpvW1oqpax3EpoT0r7r97zFXxML1wdA,16173
 portacode/connection/handlers/terminal_handlers.py,sha256=HRwHW1GiqG1NtHVEqXHKaYkFfQEzCDDH6YIlHcb4XD8,11866
 portacode/connection/handlers/update_handler.py,sha256=f2K4LmG4sHJZ3LahzzoRtHBULTKkPUNwuyhwuAAg3RA,2054
@@ -64,7 +64,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.11.dev0.dist-info/licenses/LICENSE,sha256=2FGbCnUDgRYuQTkB1O1dUUpu5CVAjK1j4_p6ack9Z54,1066
+portacode-1.4.11.dev5.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
@@ -90,8 +90,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.11.dev0.dist-info/METADATA,sha256=XXzgUM_MnhswA3L7SOeRKjeG64Si7CWErIWs_atPhtY,13051
-portacode-1.4.11.dev0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-portacode-1.4.11.dev0.dist-info/entry_points.txt,sha256=lLUUL-BM6_wwe44Xv0__5NQ1BnAz6jWjSMFvZdWW3zU,48
-portacode-1.4.11.dev0.dist-info/top_level.txt,sha256=TGhTYUxfW8SyVZc_zGgzjzc24gGT7nSw8Qf73liVRKM,41
-portacode-1.4.11.dev0.dist-info/RECORD,,
+portacode-1.4.11.dev5.dist-info/METADATA,sha256=0TExN_oiooXn-VrOIp0aLXmIlzHNkZowv3z-aqy7rA4,13051
+portacode-1.4.11.dev5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+portacode-1.4.11.dev5.dist-info/entry_points.txt,sha256=lLUUL-BM6_wwe44Xv0__5NQ1BnAz6jWjSMFvZdWW3zU,48
+portacode-1.4.11.dev5.dist-info/top_level.txt,sha256=TGhTYUxfW8SyVZc_zGgzjzc24gGT7nSw8Qf73liVRKM,41
+portacode-1.4.11.dev5.dist-info/RECORD,,