clonebox 0.1.15__py3-none-any.whl → 0.1.16__py3-none-any.whl

clonebox/cli.py

@@ -58,6 +58,359 @@ def print_banner():
     console.print(f"  Version {__version__}\n", style="dim")
 
 
+def _resolve_vm_name_and_config_file(name: Optional[str]) -> tuple[str, Optional[Path]]:
+    config_file: Optional[Path] = None
+
+    if name and (name.startswith(".") or name.startswith("/") or name.startswith("~")):
+        target_path = Path(name).expanduser().resolve()
+        config_file = target_path / ".clonebox.yaml" if target_path.is_dir() else target_path
+        if config_file.exists():
+            config = load_clonebox_config(config_file)
+            return config["vm"]["name"], config_file
+        raise FileNotFoundError(f"Config not found: {config_file}")
+
+    if not name:
+        config_file = Path.cwd() / ".clonebox.yaml"
+        if config_file.exists():
+            config = load_clonebox_config(config_file)
+            return config["vm"]["name"], config_file
+        raise FileNotFoundError("No VM name specified and no .clonebox.yaml found")
+
+    return name, None
+
+
+def _qga_ping(vm_name: str, conn_uri: str) -> bool:
+    import subprocess
+
+    try:
+        result = subprocess.run(
+            [
+                "virsh",
+                "--connect",
+                conn_uri,
+                "qemu-agent-command",
+                vm_name,
+                json.dumps({"execute": "guest-ping"}),
+            ],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        return result.returncode == 0
+    except Exception:
+        return False
+
+
+def _qga_exec(vm_name: str, conn_uri: str, command: str, timeout: int = 10) -> Optional[str]:
+    import subprocess
+
+    try:
+        payload = {
+            "execute": "guest-exec",
+            "arguments": {
+                "path": "/bin/sh",
+                "arg": ["-c", command],
+                "capture-output": True,
+            },
+        }
+        exec_result = subprocess.run(
+            [
+                "virsh",
+                "--connect",
+                conn_uri,
+                "qemu-agent-command",
+                vm_name,
+                json.dumps(payload),
+            ],
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+        )
+        if exec_result.returncode != 0:
+            return None
+
+        resp = json.loads(exec_result.stdout)
+        pid = resp.get("return", {}).get("pid")
+        if not pid:
+            return None
+
+        import base64
+        import time
+
+        deadline = time.time() + timeout
+        while time.time() < deadline:
+            status_payload = {"execute": "guest-exec-status", "arguments": {"pid": pid}}
+            status_result = subprocess.run(
+                [
+                    "virsh",
+                    "--connect",
+                    conn_uri,
+                    "qemu-agent-command",
+                    vm_name,
+                    json.dumps(status_payload),
+                ],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            if status_result.returncode != 0:
+                return None
+
+            status_resp = json.loads(status_result.stdout)
+            ret = status_resp.get("return", {})
+            if not ret.get("exited", False):
+                time.sleep(0.3)
+                continue
+
+            out_data = ret.get("out-data")
+            if out_data:
+                return base64.b64decode(out_data).decode().strip()
+            return ""
+
+        return None
+    except Exception:
+        return None
+
+
+def run_vm_diagnostics(
+    vm_name: str,
+    conn_uri: str,
+    config_file: Optional[Path],
+    *,
+    verbose: bool = False,
+    json_output: bool = False,
+) -> dict:
+    import subprocess
+
+    result: dict = {
+        "vm": {"name": vm_name, "conn_uri": conn_uri},
+        "state": {},
+        "network": {},
+        "qga": {},
+        "cloud_init": {},
+        "mounts": {},
+        "health": {},
+    }
+
+    console.print(f"[bold cyan]🧪 Diagnostics: {vm_name}[/]\n")
+
+    try:
+        domstate = subprocess.run(
+            ["virsh", "--connect", conn_uri, "domstate", vm_name],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        result["state"] = {
+            "returncode": domstate.returncode,
+            "stdout": domstate.stdout.strip(),
+            "stderr": domstate.stderr.strip(),
+        }
+        if domstate.returncode == 0 and domstate.stdout.strip():
+            console.print(f"[green]✅ VM State: {domstate.stdout.strip()}[/]")
+        else:
+            console.print("[red]❌ VM State: unable to read[/]")
+            if verbose and domstate.stderr.strip():
+                console.print(f"[dim]{domstate.stderr.strip()}[/]")
+    except subprocess.TimeoutExpired:
+        result["state"] = {"error": "timeout"}
+        console.print("[red]❌ VM State: timeout[/]")
+        if json_output:
+            console.print_json(json.dumps(result))
+        return result
+
+    console.print("\n[bold]🔍 Checking VM network...[/]")
+    try:
+        domifaddr = subprocess.run(
+            ["virsh", "--connect", conn_uri, "domifaddr", vm_name],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        result["network"] = {
+            "returncode": domifaddr.returncode,
+            "stdout": domifaddr.stdout.strip(),
+            "stderr": domifaddr.stderr.strip(),
+        }
+        if domifaddr.stdout.strip():
+            console.print(f"[dim]{domifaddr.stdout.strip()}[/]")
+        else:
+            console.print("[yellow]⚠️  No interface address detected yet[/]")
+            if verbose and domifaddr.stderr.strip():
+                console.print(f"[dim]{domifaddr.stderr.strip()}[/]")
+    except Exception as e:
+        result["network"] = {"error": str(e)}
+        console.print(f"[yellow]⚠️  Cannot get IP: {e}[/]")
+
+    guest_agent_ready = _qga_ping(vm_name, conn_uri)
+    result["qga"]["ready"] = guest_agent_ready
+    if verbose:
+        console.print("\n[bold]🤖 QEMU Guest Agent...[/]")
+        console.print(f"{'[green]✅' if guest_agent_ready else '[red]❌'} QGA connected")
+
+        if not guest_agent_ready:
+            try:
+                dumpxml = subprocess.run(
+                    ["virsh", "--connect", conn_uri, "dumpxml", vm_name],
+                    capture_output=True,
+                    text=True,
+                    timeout=10,
+                )
+                has_qga_channel = False
+                if dumpxml.returncode == 0:
+                    has_qga_channel = "org.qemu.guest_agent.0" in dumpxml.stdout
+                result["qga"]["dumpxml_returncode"] = dumpxml.returncode
+                result["qga"]["has_channel"] = has_qga_channel
+                if dumpxml.stderr.strip():
+                    result["qga"]["dumpxml_stderr"] = dumpxml.stderr.strip()
+
+                console.print(
+                    f"[dim]Guest agent channel in VM XML: {'present' if has_qga_channel else 'missing'}[/]"
+                )
+            except Exception as e:
+                result["qga"]["dumpxml_error"] = str(e)
+
+            try:
+                ping_attempt = subprocess.run(
+                    [
+                        "virsh",
+                        "--connect",
+                        conn_uri,
+                        "qemu-agent-command",
+                        vm_name,
+                        json.dumps({"execute": "guest-ping"}),
+                    ],
+                    capture_output=True,
+                    text=True,
+                    timeout=10,
+                )
+                result["qga"]["ping_returncode"] = ping_attempt.returncode
+                result["qga"]["ping_stdout"] = ping_attempt.stdout.strip()
+                result["qga"]["ping_stderr"] = ping_attempt.stderr.strip()
+                if ping_attempt.stderr.strip():
+                    console.print(f"[dim]qemu-agent-command stderr: {ping_attempt.stderr.strip()}[/]")
+            except Exception as e:
+                result["qga"]["ping_error"] = str(e)
+
+            console.print("[dim]If channel is present, the agent inside VM may not be running yet.[/]")
+            console.print("[dim]Inside VM try: sudo systemctl status qemu-guest-agent && sudo systemctl restart qemu-guest-agent[/]")
+
+    console.print("\n[bold]☁️  Checking cloud-init status...[/]")
+    cloud_init_complete = False
+    if not guest_agent_ready:
+        result["cloud_init"] = {"status": "unknown", "reason": "qga_not_ready"}
+        console.print("[yellow]⏳ Cloud-init status: Unknown (QEMU guest agent not connected yet)[/]")
+    else:
+        ready_msg = _qga_exec(vm_name, conn_uri, "cat /var/log/clonebox-ready 2>/dev/null || true", timeout=10)
+        result["cloud_init"]["clonebox_ready_file"] = ready_msg
+        if ready_msg and "CloneBox VM ready" in ready_msg:
+            cloud_init_complete = True
+            result["cloud_init"]["status"] = "complete"
+            console.print("[green]✅ Cloud-init: Complete[/]")
+        else:
+            ci_status = _qga_exec(vm_name, conn_uri, "cloud-init status 2>/dev/null || true", timeout=10)
+            result["cloud_init"]["cloud_init_status"] = ci_status
+            result["cloud_init"]["status"] = "running"
+            console.print("[yellow]⏳ Cloud-init: Still running[/]")
+            if verbose and ci_status:
+                console.print(f"[dim]{ci_status}[/]")
+
+    console.print("\n[bold]💾 Checking mount status...[/]")
+    if not cloud_init_complete:
+        console.print("[dim]Mounts may not be ready until cloud-init completes.[/]")
+
+    mounts_detail: list[dict] = []
+    result["mounts"]["details"] = mounts_detail
+    if not guest_agent_ready:
+        console.print("[yellow]⏳ QEMU guest agent not connected yet - cannot verify mounts.[/]")
+        result["mounts"]["status"] = "unknown"
+    else:
+        if not config_file:
+            config_file = Path.cwd() / ".clonebox.yaml"
+
+        if not config_file.exists():
+            console.print("[dim]No .clonebox.yaml found - cannot check mounts[/]")
+            result["mounts"]["status"] = "no_config"
+        else:
+            config = load_clonebox_config(config_file)
+            all_paths = config.get("paths", {}).copy()
+            all_paths.update(config.get("app_data_paths", {}))
+            result["mounts"]["expected"] = list(all_paths.values())
+            mount_output = _qga_exec(vm_name, conn_uri, "mount | grep 9p || true", timeout=10) or ""
+            mounted_paths = [line.split()[2] for line in mount_output.split("\n") if line.strip()]
+            result["mounts"]["mounted_paths"] = mounted_paths
+
+            mount_table = Table(title="Mount Points", border_style="cyan", show_header=True)
+            mount_table.add_column("Guest Path", style="bold")
+            mount_table.add_column("Mounted", justify="center")
+            mount_table.add_column("Accessible", justify="center")
+            mount_table.add_column("Files", justify="right")
+
+            working_mounts = 0
+            total_mounts = 0
+            for _, guest_path in all_paths.items():
+                total_mounts += 1
+                is_mounted = any(guest_path == mp or guest_path in mp for mp in mounted_paths)
+                accessible = False
+                file_count: str = "?"
+
+                if is_mounted:
+                    test_out = _qga_exec(vm_name, conn_uri, f"test -d {guest_path} && echo yes || echo no", timeout=5)
+                    accessible = test_out == "yes"
+                    if accessible:
+                        count_str = _qga_exec(vm_name, conn_uri, f"ls -A {guest_path} 2>/dev/null | wc -l", timeout=5)
+                        if count_str and count_str.strip().isdigit():
+                            file_count = count_str.strip()
+
+                if is_mounted and accessible:
+                    working_mounts += 1
+
+                mount_table.add_row(
+                    guest_path,
+                    "[green]✅[/]" if is_mounted else "[red]❌[/]",
+                    "[green]✅[/]" if accessible else ("[red]❌[/]" if is_mounted else "[dim]N/A[/]"),
+                    file_count,
+                )
+                mounts_detail.append(
+                    {
+                        "guest_path": guest_path,
+                        "mounted": is_mounted,
+                        "accessible": accessible,
+                        "files": file_count,
+                    }
+                )
+
+            result["mounts"]["working"] = working_mounts
+            result["mounts"]["total"] = total_mounts
+            result["mounts"]["status"] = "ok" if working_mounts == total_mounts else "partial"
+
+            console.print(mount_table)
+            console.print(f"[dim]{working_mounts}/{total_mounts} mounts working[/]")
+
+    console.print("\n[bold]🏥 Health Check Status...[/]")
+    if not guest_agent_ready:
+        result["health"]["status"] = "unknown"
+        console.print("[dim]Health status: Not available yet (QEMU guest agent not ready)[/]")
+    else:
+        health_status = _qga_exec(vm_name, conn_uri, "cat /var/log/clonebox-health-status 2>/dev/null || true", timeout=10)
+        result["health"]["raw"] = health_status
+        if health_status and "HEALTH_STATUS=OK" in health_status:
+            result["health"]["status"] = "ok"
+            console.print("[green]✅ Health: All checks passed[/]")
+        elif health_status and "HEALTH_STATUS=FAILED" in health_status:
+            result["health"]["status"] = "failed"
+            console.print("[red]❌ Health: Some checks failed[/]")
+        else:
+            result["health"]["status"] = "not_run"
+            console.print("[yellow]⏳ Health check not yet run[/]")
+            if verbose and health_status:
+                console.print(f"[dim]{health_status}[/]")
+
+    if json_output:
+        console.print_json(json.dumps(result))
+    return result
+
+
 def interactive_mode():
     """Run the interactive VM creation wizard."""
     print_banner()
@@ -579,239 +932,177 @@ def cmd_list(args):
     console.print(table)
 
 
+def cmd_container_up(args):
+    """Start a container sandbox."""
+    try:
+        from clonebox.container import ContainerCloner
+        from clonebox.models import ContainerConfig
+    except ModuleNotFoundError as e:
+        raise ModuleNotFoundError(
+            "Container features require extra dependencies (e.g. pydantic). Install them to use 'clonebox container'."
+        ) from e
+
+    mounts: dict[str, str] = {}
+    for m in getattr(args, "mount", []) or []:
+        if ":" not in m:
+            raise ValueError(f"Invalid mount: {m} (expected HOST:CONTAINER)")
+        host, container_path = m.split(":", 1)
+        mounts[host] = container_path
+
+    cfg_kwargs: dict = {
+        "engine": getattr(args, "engine", "auto"),
+        "image": getattr(args, "image", "ubuntu:22.04"),
+        "workspace": Path(getattr(args, "path", ".")),
+        "extra_mounts": mounts,
+        "env_from_dotenv": not getattr(args, "no_dotenv", False),
+        "packages": getattr(args, "package", []) or [],
+        "ports": getattr(args, "port", []) or [],
+    }
+    if getattr(args, "name", None):
+        cfg_kwargs["name"] = args.name
+
+    cfg = ContainerConfig(**cfg_kwargs)
+
+    cloner = ContainerCloner(engine=cfg.engine)
+    cloner.up(cfg, detach=getattr(args, "detach", False))
+
+
+def cmd_container_ps(args):
+    """List containers."""
+    try:
+        from clonebox.container import ContainerCloner
+    except ModuleNotFoundError as e:
+        raise ModuleNotFoundError(
+            "Container features require extra dependencies (e.g. pydantic). Install them to use 'clonebox container'."
+        ) from e
+
+    cloner = ContainerCloner(engine=getattr(args, "engine", "auto"))
+    items = cloner.ps(all=getattr(args, "all", False))
+
+    if getattr(args, "json", False):
+        print(json.dumps(items, indent=2))
+        return
+
+    if not items:
+        console.print("[dim]No containers found.[/]")
+        return
+
+    table = Table(title="Containers", border_style="cyan")
+    table.add_column("Name", style="bold")
+    table.add_column("Image")
+    table.add_column("Status")
+    table.add_column("Ports")
+
+    for c in items:
+        table.add_row(
+            str(c.get("name", "")),
+            str(c.get("image", "")),
+            str(c.get("status", "")),
+            str(c.get("ports", "")),
+        )
+
+    console.print(table)
+
+
+def cmd_container_stop(args):
+    """Stop a container."""
+    try:
+        from clonebox.container import ContainerCloner
+    except ModuleNotFoundError as e:
+        raise ModuleNotFoundError(
+            "Container features require extra dependencies (e.g. pydantic). Install them to use 'clonebox container'."
+        ) from e
+
+    cloner = ContainerCloner(engine=getattr(args, "engine", "auto"))
+    cloner.stop(args.name)
+
+
+def cmd_container_rm(args):
+    """Remove a container."""
+    try:
+        from clonebox.container import ContainerCloner
+    except ModuleNotFoundError as e:
+        raise ModuleNotFoundError(
+            "Container features require extra dependencies (e.g. pydantic). Install them to use 'clonebox container'."
+        ) from e
+
+    cloner = ContainerCloner(engine=getattr(args, "engine", "auto"))
+    cloner.rm(args.name, force=getattr(args, "force", False))
+
+
+def cmd_container_down(args):
+    """Stop and remove a container."""
+    try:
+        from clonebox.container import ContainerCloner
+    except ModuleNotFoundError as e:
+        raise ModuleNotFoundError(
+            "Container features require extra dependencies (e.g. pydantic). Install them to use 'clonebox container'."
+        ) from e
+
+    cloner = ContainerCloner(engine=getattr(args, "engine", "auto"))
+    cloner.stop(args.name)
+    cloner.rm(args.name, force=True)
+
+
+def cmd_diagnose(args):
+    """Run detailed VM diagnostics (standalone)."""
+    name = args.name
+    user_session = getattr(args, "user", False)
+    conn_uri = "qemu:///session" if user_session else "qemu:///system"
+
+    try:
+        vm_name, config_file = _resolve_vm_name_and_config_file(name)
+    except FileNotFoundError as e:
+        console.print(f"[red]❌ {e}[/]")
+        return
+
+    run_vm_diagnostics(
+        vm_name,
+        conn_uri,
+        config_file,
+        verbose=getattr(args, "verbose", False),
+        json_output=getattr(args, "json", False),
+    )
+
+
 def cmd_status(args):
     """Check VM installation status and health from workstation."""
     import subprocess
-    
+
     name = args.name
     user_session = getattr(args, "user", False)
     conn_uri = "qemu:///session" if user_session else "qemu:///system"
-    
-    # If name is a path, load config to get VM name
-    if name and (name.startswith(".") or name.startswith("/") or name.startswith("~")):
-        target_path = Path(name).expanduser().resolve()
-        config_file = target_path / ".clonebox.yaml" if target_path.is_dir() else target_path
-        if config_file.exists():
-            config = load_clonebox_config(config_file)
-            name = config["vm"]["name"]
-        else:
-            console.print(f"[red]❌ Config not found: {config_file}[/]")
-            return
-    
-    if not name:
-        # Try current directory
-        config_file = Path.cwd() / ".clonebox.yaml"
-        if config_file.exists():
-            config = load_clonebox_config(config_file)
-            name = config["vm"]["name"]
-        else:
-            console.print("[red]❌ No VM name specified and no .clonebox.yaml found[/]")
-            return
-    
-    console.print(f"[bold cyan]📊 Checking VM status: {name}[/]\n")
-    
-    # Check VM state
+
     try:
-        result = subprocess.run(
-            ["virsh", "--connect", conn_uri, "domstate", name],
-            capture_output=True, text=True, timeout=5
-        )
-        vm_state = result.stdout.strip()
-        
-        if "running" in vm_state.lower():
-            console.print(f"[green]✅ VM State: {vm_state}[/]")
-        elif "shut off" in vm_state.lower():
-            console.print(f"[yellow]⏸️  VM State: {vm_state}[/]")
-            console.print("[dim]Start with: clonebox start .[/]")
-            return
-        else:
-            console.print(f"[dim]VM State: {vm_state}[/]")
-    except subprocess.TimeoutExpired:
-        console.print("[red]❌ Timeout checking VM state[/]")
-        return
-    except Exception as e:
-        console.print(f"[red]❌ Error: {e}[/]")
+        vm_name, config_file = _resolve_vm_name_and_config_file(name)
+    except FileNotFoundError as e:
+        console.print(f"[red]❌ {e}[/]")
         return
-    
-    # Get VM IP address
-    console.print("\n[bold]🔍 Checking VM network...[/]")
-    try:
-        result = subprocess.run(
-            ["virsh", "--connect", conn_uri, "domifaddr", name],
-            capture_output=True, text=True, timeout=10
-        )
-        if result.stdout.strip():
-            console.print(f"[dim]{result.stdout.strip()}[/]")
-            # Extract IP
-            for line in result.stdout.split('\n'):
-                if 'ipv4' in line.lower():
-                    parts = line.split()
-                    for p in parts:
-                        if '/' in p and '.' in p:
-                            ip = p.split('/')[0]
-                            console.print(f"[green]IP Address: {ip}[/]")
-                            break
-        else:
-            console.print("[yellow]⚠️  No IP address yet (VM may still be booting)[/]")
-    except Exception as e:
-        console.print(f"[yellow]⚠️  Cannot get IP: {e}[/]")
-    
-    # Check cloud-init status via console
-    console.print("\n[bold]☁️  Checking cloud-init status...[/]")
-    try:
-        # Use virsh console to check - this is tricky, so we check for the ready file
-        result = subprocess.run(
-            ["virsh", "--connect", conn_uri, "qemu-agent-command", name, 
-             '{"execute":"guest-exec","arguments":{"path":"/bin/cat","arg":["/var/log/clonebox-ready"],"capture-output":true}}'],
-            capture_output=True, text=True, timeout=10
-        )
-        if "CloneBox VM ready" in result.stdout or result.returncode == 0:
-            console.print("[green]✅ Cloud-init: Complete[/]")
-        else:
-            console.print("[yellow]⏳ Cloud-init: Still running (packages installing)[/]")
-    except Exception:
-        console.print("[yellow]⏳ Cloud-init status: Unknown (QEMU agent may not be ready)[/]")
-    
-    # Check mount status
-    console.print("\n[bold]💾 Checking mount status...[/]")
-    try:
-        # Load config to get expected mounts
-        config_file = Path.cwd() / ".clonebox.yaml"
-        if config_file.exists():
-            config = load_clonebox_config(config_file)
-            all_paths = config.get("paths", {}).copy()
-            all_paths.update(config.get("app_data_paths", {}))
-            
-            if all_paths:
-                # Check which mounts are active
-                result = subprocess.run(
-                    ["virsh", "--connect", conn_uri, "qemu-agent-command", name,
-                     '{"execute":"guest-exec","arguments":{"path":"/bin/sh","arg":["-c","mount | grep 9p"],"capture-output":true}}'],
-                    capture_output=True, text=True, timeout=10
-                )
-                
-                mount_table = Table(title="Mount Points", border_style="cyan", show_header=True)
-                mount_table.add_column("Guest Path", style="bold")
-                mount_table.add_column("Status", justify="center")
-                mount_table.add_column("Files", justify="right")
-                
-                mounted_paths = []
-                if result.returncode == 0 and "return" in result.stdout:
-                    # Parse guest-exec response for mount output
-                    import json
-                    try:
-                        resp = json.loads(result.stdout)
-                        if "return" in resp and "pid" in resp["return"]:
-                            # Get the output from guest-exec-status
-                            pid = resp["return"]["pid"]
-                            status_result = subprocess.run(
-                                ["virsh", "--connect", conn_uri, "qemu-agent-command", name,
-                                 f'{{"execute":"guest-exec-status","arguments":{{"pid":{pid}}}}}'],
-                                capture_output=True, text=True, timeout=5
-                            )
-                            if status_result.returncode == 0:
-                                status_resp = json.loads(status_result.stdout)
-                                if "return" in status_resp and "out-data" in status_resp["return"]:
-                                    import base64
-                                    mount_output = base64.b64decode(status_resp["return"]["out-data"]).decode()
-                                    mounted_paths = [line.split()[2] for line in mount_output.split('\n') if line.strip()]
-                    except:
-                        pass
-                
-                # Check each expected mount
-                working_mounts = 0
-                total_mounts = 0
-                for host_path, guest_path in all_paths.items():
-                    total_mounts += 1
-                    is_mounted = any(guest_path in mp for mp in mounted_paths)
-                    
-                    # Try to get file count
-                    file_count = "?"
-                    if is_mounted:
-                        try:
-                            count_result = subprocess.run(
-                                ["virsh", "--connect", conn_uri, "qemu-agent-command", name,
-                                 f'{{"execute":"guest-exec","arguments":{{"path":"/bin/sh","arg":["-c","ls -A {guest_path} 2>/dev/null | wc -l"],"capture-output":true}}}}'],
-                                capture_output=True, text=True, timeout=5
-                            )
-                            if count_result.returncode == 0:
-                                resp = json.loads(count_result.stdout)
-                                if "return" in resp and "pid" in resp["return"]:
-                                    pid = resp["return"]["pid"]
-                                    import time
-                                    time.sleep(0.5)
-                                    status_result = subprocess.run(
-                                        ["virsh", "--connect", conn_uri, "qemu-agent-command", name,
-                                         f'{{"execute":"guest-exec-status","arguments":{{"pid":{pid}}}}}'],
-                                        capture_output=True, text=True, timeout=5
-                                    )
-                                    if status_result.returncode == 0:
-                                        status_resp = json.loads(status_result.stdout)
-                                        if "return" in status_resp and "out-data" in status_resp["return"]:
-                                            file_count = base64.b64decode(status_resp["return"]["out-data"]).decode().strip()
-                        except:
-                            pass
-                    
-                    if is_mounted:
-                        status = "[green]✅ Mounted[/]"
-                        working_mounts += 1
-                    else:
-                        status = "[red]❌ Not mounted[/]"
-                    
-                    mount_table.add_row(guest_path, status, str(file_count))
-                
-                console.print(mount_table)
-                console.print(f"[dim]{working_mounts}/{total_mounts} mounts active[/]")
-                
-                if working_mounts < total_mounts:
-                    console.print("[yellow]⚠️  Some mounts are missing. Try remounting in VM:[/]")
-                    console.print("[dim]  sudo mount -a[/]")
-                    console.print("[dim]Or rebuild VM with: clonebox clone . --user --run --replace[/]")
-            else:
-                console.print("[dim]No mount points configured[/]")
-        else:
-            console.print("[dim]No .clonebox.yaml found - cannot check mounts[/]")
-    except Exception as e:
-        console.print(f"[yellow]⚠️  Cannot check mounts: {e}[/]")
-        console.print("[dim]QEMU guest agent may not be ready yet[/]")
-    
-    # Check health status if available
-    console.print("\n[bold]🏥 Health Check Status...[/]")
-    try:
-        result = subprocess.run(
-            ["virsh", "--connect", conn_uri, "qemu-agent-command", name,
-             '{"execute":"guest-exec","arguments":{"path":"/bin/cat","arg":["/var/log/clonebox-health-status"],"capture-output":true}}'],
-            capture_output=True, text=True, timeout=10
-        )
-        if "HEALTH_STATUS=OK" in result.stdout:
-            console.print("[green]✅ Health: All checks passed[/]")
-        elif "HEALTH_STATUS=FAILED" in result.stdout:
-            console.print("[red]❌ Health: Some checks failed[/]")
-        else:
-            console.print("[yellow]⏳ Health check not yet run[/]")
-    except Exception:
-        console.print("[dim]Health status: Not available yet[/]")
-    
+
+    run_vm_diagnostics(vm_name, conn_uri, config_file, verbose=False, json_output=False)
+
     # Show useful commands
     console.print("\n[bold]📋 Useful commands:[/]")
-    console.print(f"  [cyan]virt-viewer --connect {conn_uri} {name}[/]  # Open GUI")
-    console.print(f"  [cyan]virsh --connect {conn_uri} console {name}[/]  # Console access")
+    console.print(f"  [cyan]virt-viewer --connect {conn_uri} {vm_name}[/]  # Open GUI")
+    console.print(f"  [cyan]virsh --connect {conn_uri} console {vm_name}[/]  # Console access")
     console.print("  [dim]Inside VM:[/]")
     console.print("    [cyan]cat /var/log/clonebox-health.log[/]  # Full health report")
     console.print("    [cyan]sudo cloud-init status[/]  # Cloud-init status")
     console.print("    [cyan]clonebox-health[/]  # Re-run health check")
+    console.print("  [dim]On host:[/]")
+    console.print("    [cyan]clonebox test . --user --validate[/]  # Full validation (mounts/packages/services)")
     
     # Run full health check if requested
     if getattr(args, "health", False):
         console.print("\n[bold]🔄 Running full health check...[/]")
         try:
             result = subprocess.run(
-                ["virsh", "--connect", conn_uri, "qemu-agent-command", name,
+                ["virsh", "--connect", conn_uri, "qemu-agent-command", vm_name,
                  '{"execute":"guest-exec","arguments":{"path":"/usr/local/bin/clonebox-health","capture-output":true}}'],
                 capture_output=True, text=True, timeout=60
             )
             console.print("[green]Health check triggered. View results with:[/]")
-            console.print(f"  [cyan]virsh --connect {conn_uri} console {name}[/]")
+            console.print(f"  [cyan]virsh --connect {conn_uri} console {vm_name}[/]")
             console.print("  Then run: [cyan]cat /var/log/clonebox-health.log[/]")
         except Exception as e:
             console.print(f"[yellow]⚠️  Could not trigger health check: {e}[/]")
@@ -2050,6 +2341,64 @@ def main():
     )
     list_parser.set_defaults(func=cmd_list)
 
+    # Container command
+    container_parser = subparsers.add_parser("container", help="Manage container sandboxes")
+    container_parser.add_argument(
+        "--engine",
+        choices=["auto", "podman", "docker"],
+        default="auto",
+        help="Container engine: auto (default), podman, docker",
+    )
+    container_sub = container_parser.add_subparsers(dest="container_command", help="Container commands")
+
+    container_up = container_sub.add_parser("up", help="Start container")
+    container_up.add_argument("path", nargs="?", default=".", help="Workspace path")
+    container_up.add_argument("--name", help="Container name")
+    container_up.add_argument("--image", default="ubuntu:22.04", help="Container image")
+    container_up.add_argument("--detach", action="store_true", help="Run container in background")
+    container_up.add_argument(
+        "--mount",
+        action="append",
+        default=[],
+        help="Extra mount HOST:CONTAINER (repeatable)",
+    )
+    container_up.add_argument(
+        "--port",
+        action="append",
+        default=[],
+        help="Port mapping (e.g. 8080:80) (repeatable)",
+    )
+    container_up.add_argument(
+        "--package",
+        action="append",
+        default=[],
+        help="APT package to install in image (repeatable)",
+    )
+    container_up.add_argument(
+        "--no-dotenv",
+        action="store_true",
+        help="Do not load env vars from workspace .env",
+    )
+    container_up.set_defaults(func=cmd_container_up)
+
+    container_ps = container_sub.add_parser("ps", aliases=["ls"], help="List containers")
+    container_ps.add_argument("-a", "--all", action="store_true", help="Show all containers")
+    container_ps.add_argument("--json", action="store_true", help="Output JSON")
+    container_ps.set_defaults(func=cmd_container_ps)
+
+    container_stop = container_sub.add_parser("stop", help="Stop container")
+    container_stop.add_argument("name", help="Container name")
+    container_stop.set_defaults(func=cmd_container_stop)
+
+    container_rm = container_sub.add_parser("rm", help="Remove container")
+    container_rm.add_argument("name", help="Container name")
+    container_rm.add_argument("-f", "--force", action="store_true", help="Force remove")
+    container_rm.set_defaults(func=cmd_container_rm)
+
+    container_down = container_sub.add_parser("down", help="Stop and remove container")
+    container_down.add_argument("name", help="Container name")
+    container_down.set_defaults(func=cmd_container_down)
+
     # Detect command
     detect_parser = subparsers.add_parser("detect", help="Detect system state")
     detect_parser.add_argument("--json", action="store_true", help="Output as JSON")
@@ -2117,6 +2466,27 @@ def main():
     )
     status_parser.set_defaults(func=cmd_status)
 
+    # Diagnose command - detailed diagnostics from workstation
+    diagnose_parser = subparsers.add_parser(
+        "diagnose", aliases=["diag"], help="Run detailed VM diagnostics"
+    )
+    diagnose_parser.add_argument(
+        "name", nargs="?", default=None, help="VM name or '.' to use .clonebox.yaml"
+    )
+    diagnose_parser.add_argument(
+        "-u",
+        "--user",
+        action="store_true",
+        help="Use user session (qemu:///session)",
+    )
+    diagnose_parser.add_argument(
+        "--verbose", "-v", action="store_true", help="Show more low-level details"
+    )
+    diagnose_parser.add_argument(
+        "--json", action="store_true", help="Print diagnostics as JSON"
+    )
+    diagnose_parser.set_defaults(func=cmd_diagnose)
+
     # Export command - package VM for migration
     export_parser = subparsers.add_parser("export", help="Export VM and data for migration")
     export_parser.add_argument(

clonebox/cloner.py

@@ -668,7 +668,7 @@ fi
                 tag = f"mount{idx}"
                 # Use uid=1000,gid=1000 to give ubuntu user access to mounts
                 # mmap allows proper file mapping
-                mount_opts = "trans=virtio,version=9p2000.L,mmap,uid=1000,gid=1000"
+                mount_opts = "trans=virtio,version=9p2000.L,mmap,uid=1000,gid=1000,users"
                 mount_commands.append(f"  - mkdir -p {guest_path}")
                 mount_commands.append(f"  - chown 1000:1000 {guest_path}")
                 mount_commands.append(
@@ -679,34 +679,30 @@ fi
 
         # User-data
         # Add desktop environment if GUI is enabled
-        base_packages = []
+        runcmd_lines = []
+        base_packages = ["qemu-guest-agent"]
         if config.gui:
-            base_packages.extend([
-                "ubuntu-desktop-minimal",
-                "firefox",
-            ])
+            base_packages.extend(
+                [
+                    "ubuntu-desktop-minimal",
+                    "firefox",
+                ]
+            )
         
         all_packages = base_packages + list(config.packages)
-        packages_yaml = (
-            "\n".join(f"  - {pkg}" for pkg in all_packages) if all_packages else ""
-        )
-        
-        # Build runcmd - services, mounts, snaps, post_commands
-        runcmd_lines = []
-        
-        # Add service enablement
-        for svc in config.services:
-            runcmd_lines.append(f"  - systemctl enable --now {svc} || true")
-        
+        packages_yaml = "\n".join([f"  - {pkg}" for pkg in all_packages])
+
         # Add fstab entries for persistent mounts after reboot
         if fstab_entries:
-            runcmd_lines.append("  - echo '# CloneBox 9p mounts' >> /etc/fstab")
+            runcmd_lines.append("  - grep -q '^# CloneBox 9p mounts' /etc/fstab || echo '# CloneBox 9p mounts' >> /etc/fstab")
             for entry in fstab_entries:
-                runcmd_lines.append(f"  - echo '{entry}' >> /etc/fstab")
+                runcmd_lines.append(f"  - grep -qF \"{entry}\" /etc/fstab || echo '{entry}' >> /etc/fstab")
+            runcmd_lines.append("  - mount -a || true")
         
-        # Add mounts (immediate, before reboot)
-        for cmd in mount_commands:
-            runcmd_lines.append(cmd)
+        # Install APT packages
+        runcmd_lines.append("  - echo 'Installing APT packages...'")
+        for pkg in config.packages:
+            runcmd_lines.append(f"  - apt-get install -y {pkg} || true")
         
         # Install snap packages
         if config.snap_packages:
@@ -740,6 +736,8 @@ fi
             runcmd_lines.append("  - sleep 10 && reboot")
         
         runcmd_yaml = "\n".join(runcmd_lines) if runcmd_lines else ""
+        bootcmd_yaml = "\n".join(mount_commands) if mount_commands else ""
+        bootcmd_block = f"\nbootcmd:\n{bootcmd_yaml}\n" if bootcmd_yaml else ""
 
         # Remove power_state - using shutdown -r instead
         power_state_yaml = ""
@@ -765,6 +763,7 @@ chpasswd:
 # Update package cache and upgrade
 package_update: true
 package_upgrade: false
+{bootcmd_block}
 
 # Install packages (cloud-init waits for completion before runcmd)
 packages:
@@ -811,8 +810,6 @@ final_message: "CloneBox VM is ready after $UPTIME seconds"
         try:
             vm = self.conn.lookupByName(vm_name)
         except libvirt.libvirtError:
-            if ignore_not_found:
-                return False
             log(f"[red]❌ VM '{vm_name}' not found[/]")
             return False
 

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/models.py

@@ -4,7 +4,8 @@ Pydantic models for CloneBox configuration validation.
 """
 
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Literal, Optional
+from uuid import uuid4
 
 from pydantic import BaseModel, Field, field_validator, model_validator
 
@@ -124,5 +125,73 @@ class CloneBoxConfig(BaseModel):
         )
 
 
+class ContainerConfig(BaseModel):
+    name: str = Field(default_factory=lambda: f"clonebox-{uuid4().hex[:8]}")
+    engine: Literal["auto", "podman", "docker"] = "auto"
+    image: str = "ubuntu:22.04"
+    workspace: Path = Path(".")
+    extra_mounts: Dict[str, str] = Field(default_factory=dict)
+    env_from_dotenv: bool = True
+    packages: List[str] = Field(default_factory=list)
+    ports: List[str] = Field(default_factory=list)
+
+    @field_validator("name")
+    @classmethod
+    def name_must_be_valid(cls, v: str) -> str:
+        if not v or not v.strip():
+            raise ValueError("Container name cannot be empty")
+        if len(v) > 64:
+            raise ValueError("Container name must be <= 64 characters")
+        return v.strip()
+
+    @field_validator("extra_mounts")
+    @classmethod
+    def extra_mounts_must_be_absolute(cls, v: Dict[str, str]) -> Dict[str, str]:
+        for host_path, container_path in v.items():
+            if not str(host_path).startswith("/"):
+                raise ValueError(f"Host path must be absolute: {host_path}")
+            if not str(container_path).startswith("/"):
+                raise ValueError(f"Container path must be absolute: {container_path}")
+        return v
+
+    @field_validator("ports")
+    @classmethod
+    def ports_must_be_valid(cls, v: List[str]) -> List[str]:
+        for p in v:
+            if not isinstance(p, str) or not p.strip():
+                raise ValueError("Port mapping cannot be empty")
+            if ":" in p:
+                host, container = p.split(":", 1)
+                if not host.isdigit() or not container.isdigit():
+                    raise ValueError(f"Invalid port mapping: {p}")
+            else:
+                if not p.isdigit():
+                    raise ValueError(f"Invalid port value: {p}")
+        return v
+
+    @property
+    def mounts(self) -> Dict[str, str]:
+        mounts: Dict[str, str] = {
+            str(self.workspace.resolve()): "/workspace",
+        }
+        mounts.update(self.extra_mounts)
+        return mounts
+
+    def to_docker_run_cmd(self) -> List[str]:
+        if self.engine == "auto":
+            raise ValueError("engine must be resolved before generating run command")
+
+        cmd: List[str] = [self.engine, "run", "-it", "--rm", "--name", self.name]
+
+        for src, dst in self.mounts.items():
+            cmd.extend(["-v", f"{src}:{dst}"])
+
+        for p in self.ports:
+            cmd.extend(["-p", p])
+
+        cmd.append(self.image)
+        return cmd
+
+
 # Backwards compatibility alias
 VMConfigModel = CloneBoxConfig

{clonebox-0.1.15.dist-info → clonebox-0.1.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clonebox
-Version: 0.1.15
+Version: 0.1.16
 Summary: Clone your workstation environment to an isolated VM with selective apps, paths and services
 Author: CloneBox Team
 License: Apache-2.0

clonebox-0.1.16.dist-info/RECORD

@@ -0,0 +1,14 @@
+clonebox/__init__.py,sha256=C1J7Uwrp8H9Zopo5JgrQYzXg-PWls1JdqmE_0Qp1Tro,408
+clonebox/__main__.py,sha256=Fcoyzwwyz5-eC_sBlQk5a5RbKx8uodQz5sKJ190U0NU,135
+clonebox/cli.py,sha256=CwJ78Em2bma6jKNjrJYmM7B3rhzNDKDMLQ-3AEx00G4,98101
+clonebox/cloner.py,sha256=bSOOkfqvF1PaUhVke0GaFYz29-eA9CigiAILP-WDhjs,32221
+clonebox/container.py,sha256=tiYK1ZB-DhdD6A2FuMA0h_sRNkUI7KfYcJ0tFOcdyeM,6105
+clonebox/detector.py,sha256=4fu04Ty6KC82WkcJZ5UL5TqXpWYE7Kb7R0uJ-9dtbCk,21635
+clonebox/models.py,sha256=Uxz9eHov2epJpNYbl0ejaOX91iMSjqdHskGdC8-smVk,7789
+clonebox/validator.py,sha256=8HV3ahfiLkFDOH4UOmZr7-fGfhKep1Jlw1joJeWSaQE,15858
+clonebox-0.1.16.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+clonebox-0.1.16.dist-info/METADATA,sha256=ZT06tRqwiEyYiqnrkHchd30VZgwWo0Cb6NhRrMu00_g,35220
+clonebox-0.1.16.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+clonebox-0.1.16.dist-info/entry_points.txt,sha256=FES95Vi3btfViLEEoHdb8nikNxTqzaooi9ehZw9ZfWI,47
+clonebox-0.1.16.dist-info/top_level.txt,sha256=LdMo2cvCrEcRGH2M8JgQNVsCoszLV0xug6kx1JnaRjo,9
+clonebox-0.1.16.dist-info/RECORD,,

clonebox-0.1.15.dist-info/RECORD

@@ -1,13 +0,0 @@
-clonebox/__init__.py,sha256=C1J7Uwrp8H9Zopo5JgrQYzXg-PWls1JdqmE_0Qp1Tro,408
-clonebox/__main__.py,sha256=Fcoyzwwyz5-eC_sBlQk5a5RbKx8uodQz5sKJ190U0NU,135
-clonebox/cli.py,sha256=xo7PJx9XODx9dfIbmuikDncTIGtpU3aAW3-S4iCxv-s,86697
-clonebox/cloner.py,sha256=fVfphsPbsqW4ASnv4bkrDIL8Ks9aPUvxx-IOO_d2FTw,32102
-clonebox/detector.py,sha256=4fu04Ty6KC82WkcJZ5UL5TqXpWYE7Kb7R0uJ-9dtbCk,21635
-clonebox/models.py,sha256=l3z1gm4TAIKzikUrQQn9yfxI62vrQRuHQxV1uftY0fY,5260
-clonebox/validator.py,sha256=8HV3ahfiLkFDOH4UOmZr7-fGfhKep1Jlw1joJeWSaQE,15858
-clonebox-0.1.15.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-clonebox-0.1.15.dist-info/METADATA,sha256=Tg6u-MfJXaO2MrdlsnFFw584tGPrVINffw6ydx2OrH4,35220
-clonebox-0.1.15.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-clonebox-0.1.15.dist-info/entry_points.txt,sha256=FES95Vi3btfViLEEoHdb8nikNxTqzaooi9ehZw9ZfWI,47
-clonebox-0.1.15.dist-info/top_level.txt,sha256=LdMo2cvCrEcRGH2M8JgQNVsCoszLV0xug6kx1JnaRjo,9
-clonebox-0.1.15.dist-info/RECORD,,