clonebox 0.1.25__py3-none-any.whl

clonebox/container.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+
+import json
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from clonebox.models import ContainerConfig
+
+
+class ContainerCloner:
+    def __init__(self, engine: str = "auto"):
+        self.engine = self._resolve_engine(engine)
+
+    def _resolve_engine(self, engine: str) -> str:
+        if engine == "auto":
+            return self.detect_engine()
+        if engine not in {"podman", "docker"}:
+            raise ValueError("engine must be one of: auto, podman, docker")
+        if shutil.which(engine) is None:
+            raise RuntimeError(f"Container engine not found: {engine}")
+        self._run([engine, "--version"], check=True)
+        return engine
+
+    def detect_engine(self) -> str:
+        if shutil.which("podman") is not None:
+            try:
+                self._run(["podman", "--version"], check=True)
+                return "podman"
+            except Exception:
+                pass
+
+        if shutil.which("docker") is not None:
+            try:
+                self._run(["docker", "--version"], check=True)
+                return "docker"
+            except Exception:
+                pass
+
+        raise RuntimeError("No container engine found (podman/docker)")
+
+    def _run(
+        self,
+        cmd: List[str],
+        check: bool = True,
+        capture_output: bool = True,
+        text: bool = True,
+    ) -> subprocess.CompletedProcess:
+        return subprocess.run(cmd, check=check, capture_output=capture_output, text=text)
+
+    def build_dockerfile(self, config: ContainerConfig) -> str:
+        lines: List[str] = [f"FROM {config.image}"]
+
+        if config.packages:
+            pkgs = " ".join(config.packages)
+            lines.append(
+                "RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y "
+                + pkgs
+                + " && rm -rf /var/lib/apt/lists/*"
+            )
+
+        lines.append("WORKDIR /workspace")
+        lines.append('CMD ["bash"]')
+        return "\n".join(lines) + "\n"
+
+    def build_image(self, config: ContainerConfig, tag: Optional[str] = None) -> str:
+        if tag is None:
+            tag = f"{config.name}:latest"
+
+        dockerfile = self.build_dockerfile(config)
+        workspace = Path(config.workspace).resolve()
+
+        with tempfile.NamedTemporaryFile(prefix="clonebox-dockerfile-", delete=False) as f:
+            dockerfile_path = Path(f.name)
+            f.write(dockerfile.encode())
+
+        try:
+            self._run(
+                [
+                    self.engine,
+                    "build",
+                    "-f",
+                    str(dockerfile_path),
+                    "-t",
+                    tag,
+                    str(workspace),
+                ],
+                check=True,
+            )
+        finally:
+            try:
+                dockerfile_path.unlink()
+            except Exception:
+                pass
+
+        return tag
+
+    def up(self, config: ContainerConfig, detach: bool = False, remove: bool = True) -> None:
+        engine = self._resolve_engine(config.engine if config.engine != "auto" else self.engine)
+
+        image = config.image
+        if config.packages:
+            image = self.build_image(config)
+
+        cmd: List[str] = [engine, "run"]
+        cmd.append("-d" if detach else "-it")
+
+        if remove:
+            cmd.append("--rm")
+
+        cmd.extend(["--name", config.name])
+        cmd.extend(["-w", "/workspace"])
+
+        env_file = Path(config.workspace) / ".env"
+        if config.env_from_dotenv and env_file.exists():
+            cmd.extend(["--env-file", str(env_file)])
+
+        for src, dst in config.mounts.items():
+            cmd.extend(["-v", f"{src}:{dst}"])
+
+        for p in config.ports:
+            cmd.extend(["-p", p])
+
+        cmd.append(image)
+
+        if detach:
+            cmd.extend(["sleep", "infinity"])
+        else:
+            cmd.append("bash")
+
+        subprocess.run(cmd, check=True)
+
+    def stop(self, name: str) -> None:
+        subprocess.run([self.engine, "stop", name], check=True)
+
+    def rm(self, name: str, force: bool = False) -> None:
+        cmd = [self.engine, "rm"]
+        if force:
+            cmd.append("-f")
+        cmd.append(name)
+        subprocess.run(cmd, check=True)
+
+    def ps(self, all: bool = False) -> List[Dict[str, Any]]:
+        if self.engine == "podman":
+            cmd = ["podman", "ps", "--format", "json"]
+            if all:
+                cmd.append("-a")
+            result = self._run(cmd, check=True)
+            try:
+                parsed = json.loads(result.stdout or "[]")
+            except json.JSONDecodeError:
+                return []
+
+            items: List[Dict[str, Any]] = []
+            for c in parsed:
+                name = ""
+                names = c.get("Names")
+                if isinstance(names, list) and names:
+                    name = str(names[0])
+                elif isinstance(names, str):
+                    name = names
+
+                items.append(
+                    {
+                        "name": name,
+                        "image": c.get("Image") or c.get("ImageName") or "",
+                        "status": c.get("State") or c.get("Status") or "",
+                        "ports": c.get("Ports") or [],
+                    }
+                )
+            return items
+
+        cmd = ["docker", "ps", "--format", "{{.Names}}\t{{.Image}}\t{{.Status}}\t{{.Ports}}"]
+        if all:
+            cmd.insert(2, "-a")
+
+        result = self._run(cmd, check=True)
+        items: List[Dict[str, Any]] = []
+        for line in (result.stdout or "").splitlines():
+            if not line.strip():
+                continue
+            parts = line.split("\t")
+            name = parts[0] if len(parts) > 0 else ""
+            image = parts[1] if len(parts) > 1 else ""
+            status = parts[2] if len(parts) > 2 else ""
+            ports = parts[3] if len(parts) > 3 else ""
+            items.append({"name": name, "image": image, "status": status, "ports": ports})
+        return items

clonebox/dashboard.py

@@ -0,0 +1,133 @@
+import json
+import subprocess
+import sys
+from typing import Any, List
+
+from fastapi import FastAPI
+from fastapi.responses import HTMLResponse, JSONResponse
+
+app = FastAPI(title="CloneBox Dashboard")
+
+
+def _run_clonebox(args: List[str]) -> subprocess.CompletedProcess:
+    return subprocess.run(
+        [sys.executable, "-m", "clonebox"] + args,
+        capture_output=True,
+        text=True,
+    )
+
+
+def _render_table(title: str, headers: List[str], rows: List[List[str]]) -> str:
+    head_html = "".join(f"<th>{h}</th>" for h in headers)
+    body_html = "".join(
+        "<tr>" + "".join(f"<td>{c}</td>" for c in row) + "</tr>" for row in rows
+    )
+
+    return (
+        f"<h2>{title}</h2>"
+        "<table>"
+        f"<thead><tr>{head_html}</tr></thead>"
+        f"<tbody>{body_html}</tbody>"
+        "</table>"
+    )
+
+
+@app.get("/", response_class=HTMLResponse)
+async def dashboard() -> str:
+    return """
+<!DOCTYPE html>
+<html>
+<head>
+  <title>CloneBox Dashboard</title>
+  <script src="https://unpkg.com/htmx.org@1.9.10"></script>
+  <style>
+    body { font-family: system-ui, -apple-system, sans-serif; margin: 20px; }
+    table { border-collapse: collapse; width: 100%; margin-bottom: 24px; }
+    th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
+    th { background: #f6f6f6; }
+    code { background: #f6f6f6; padding: 2px 4px; border-radius: 4px; }
+  </style>
+</head>
+<body>
+  <h1>CloneBox Dashboard</h1>
+  <p>Auto-refresh every 5s. JSON endpoints: <code>/api/vms.json</code>, <code>/api/containers.json</code></p>
+
+  <div id="vms" hx-get="/api/vms" hx-trigger="load, every 5s">Loading VMs...</div>
+  <div id="containers" hx-get="/api/containers" hx-trigger="load, every 5s">Loading containers...</div>
+</body>
+</html>
+"""
+
+
+@app.get("/api/vms", response_class=HTMLResponse)
+async def api_vms() -> str:
+    proc = _run_clonebox(["list", "--json"])
+    if proc.returncode != 0:
+        return f"<pre>clonebox list failed:\n{proc.stderr}</pre>"
+
+    try:
+        items: List[dict[str, Any]] = json.loads(proc.stdout or "[]")
+    except json.JSONDecodeError:
+        return f"<pre>Invalid JSON from clonebox list:\n{proc.stdout}</pre>"
+
+    if not items:
+        return "<h2>VMs</h2><p><em>No VMs found.</em></p>"
+
+    rows = [[str(i.get("name", "")), str(i.get("state", "")), str(i.get("uuid", ""))] for i in items]
+    return _render_table("VMs", ["Name", "State", "UUID"], rows)
+
+
+@app.get("/api/containers", response_class=HTMLResponse)
+async def api_containers() -> str:
+    proc = _run_clonebox(["container", "ps", "--json", "-a"])
+    if proc.returncode != 0:
+        return f"<pre>clonebox container ps failed:\n{proc.stderr}</pre>"
+
+    try:
+        items: List[dict[str, Any]] = json.loads(proc.stdout or "[]")
+    except json.JSONDecodeError:
+        return f"<pre>Invalid JSON from clonebox container ps:\n{proc.stdout}</pre>"
+
+    if not items:
+        return "<h2>Containers</h2><p><em>No containers found.</em></p>"
+
+    rows = [
+        [
+            str(i.get("name", "")),
+            str(i.get("image", "")),
+            str(i.get("status", "")),
+            str(i.get("ports", "")),
+        ]
+        for i in items
+    ]
+    return _render_table("Containers", ["Name", "Image", "Status", "Ports"], rows)
+
+
+@app.get("/api/vms.json")
+async def api_vms_json() -> JSONResponse:
+    proc = _run_clonebox(["list", "--json"])
+    if proc.returncode != 0:
+        return JSONResponse({"error": proc.stderr, "stdout": proc.stdout}, status_code=500)
+
+    try:
+        return JSONResponse(json.loads(proc.stdout or "[]"))
+    except json.JSONDecodeError:
+        return JSONResponse({"error": "invalid_json", "stdout": proc.stdout}, status_code=500)
+
+
+@app.get("/api/containers.json")
+async def api_containers_json() -> JSONResponse:
+    proc = _run_clonebox(["container", "ps", "--json", "-a"])
+    if proc.returncode != 0:
+        return JSONResponse({"error": proc.stderr, "stdout": proc.stdout}, status_code=500)
+
+    try:
+        return JSONResponse(json.loads(proc.stdout or "[]"))
+    except json.JSONDecodeError:
+        return JSONResponse({"error": "invalid_json", "stdout": proc.stdout}, status_code=500)
+
+
+def run_dashboard(port: int = 8080) -> None:
+    import uvicorn
+
+    uvicorn.run(app, host="127.0.0.1", port=port)