clonebox 0.1.18__py3-none-any.whl → 0.1.20__py3-none-any.whl

clonebox/__init__.py

@@ -5,7 +5,7 @@ Selectively clone applications, paths and services to a new virtual machine
 with bind mounts instead of full disk cloning.
 """
 
-__version__ = "0.1.13"
+__version__ = "0.1.18"
 __author__ = "CloneBox Team"
 
 from clonebox.cloner import SelectiveVMCloner

clonebox/cli.py

@@ -22,7 +22,10 @@ from rich.table import Table
 
 from clonebox import __version__
 from clonebox.cloner import SelectiveVMCloner, VMConfig
+from clonebox.container import ContainerCloner
 from clonebox.detector import SystemDetector
+from clonebox.models import ContainerConfig
+from clonebox.profiles import merge_with_profile
 
 # Custom questionary style
 custom_style = Style(
@@ -234,9 +237,22 @@ def run_vm_diagnostics(
         if domifaddr.stdout.strip():
             console.print(f"[dim]{domifaddr.stdout.strip()}[/]")
         else:
-            console.print("[yellow]⚠️  No interface address detected yet[/]")
+            console.print("[yellow]⚠️  No interface address detected via virsh domifaddr[/]")
             if verbose and domifaddr.stderr.strip():
                 console.print(f"[dim]{domifaddr.stderr.strip()}[/]")
+            # Fallback: try to get IP via QEMU Guest Agent (useful for slirp/user networking)
+            if guest_agent_ready:
+                try:
+                    ip_out = _qga_exec(vm_name, conn_uri, "ip -4 -o addr show scope global | awk '{print $4}'", timeout=5)
+                    if ip_out and ip_out.strip():
+                        console.print(f"[green]IP (via QGA): {ip_out.strip()}[/]")
+                        result["network"]["qga_ip"] = ip_out.strip()
+                    else:
+                        console.print("[dim]IP: not available via QGA[/]")
+                except Exception as e:
+                    console.print(f"[dim]IP: QGA query failed ({e})[/]")
+            else:
+                console.print("[dim]IP: QEMU Guest Agent not connected[/]")
     except Exception as e:
         result["network"] = {"error": str(e)}
         console.print(f"[yellow]⚠️  Cannot get IP: {e}[/]")
@@ -703,7 +719,6 @@ def interactive_mode():
                 console.print("\n[bold]Inside the VM, mount shared folders with:[/]")
                 for idx, (host, guest) in enumerate(paths_mapping.items()):
                     console.print(f"  [cyan]sudo mount -t 9p -o trans=virtio mount{idx} {guest}[/]")
-
     except Exception as e:
         console.print(f"\n[red]❌ Error: {e}[/]")
         raise
@@ -905,15 +920,16 @@ def cmd_delete(args):
             console.print("[yellow]Cancelled.[/]")
             return
 
-    cloner = SelectiveVMCloner(user_session=getattr(args, "user", False))
-    cloner.delete_vm(name, delete_storage=not args.keep_storage, console=console)
-
 
 def cmd_list(args):
     """List all VMs."""
     cloner = SelectiveVMCloner(user_session=getattr(args, "user", False))
     vms = cloner.list_vms()
 
+    if getattr(args, "json", False):
+        print(json.dumps(vms, indent=2))
+        return
+
     if not vms:
         console.print("[dim]No VMs found.[/]")
         return
@@ -932,14 +948,6 @@ def cmd_list(args):
 
 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 = {}
     for m in getattr(args, "mount", []) or []:
         if ":" not in m:
@@ -959,21 +967,21 @@ def cmd_container_up(args):
     if getattr(args, "name", None):
         cfg_kwargs["name"] = args.name
 
+    profile_name = getattr(args, "profile", None)
+    if profile_name:
+        merged = merge_with_profile({"container": cfg_kwargs}, profile_name)
+        if isinstance(merged, dict) and isinstance(merged.get("container"), dict):
+            cfg_kwargs = merged["container"]
+
     cfg = ContainerConfig(**cfg_kwargs)
 
     cloner = ContainerCloner(engine=cfg.engine)
-    cloner.up(cfg, detach=getattr(args, "detach", False))
+    detach = getattr(args, "detach", False)
+    cloner.up(cfg, detach=detach, remove=not detach)
 
 
 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))
 
@@ -1004,44 +1012,36 @@ def cmd_container_ps(args):
 
 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_dashboard(args):
+    """Run the local CloneBox dashboard."""
+    try:
+        from clonebox.dashboard import run_dashboard
+    except Exception as e:
+        console.print("[red]❌ Dashboard dependencies are not installed.[/]")
+        console.print("[dim]Install with: pip install 'clonebox[dashboard]'[/]")
+        console.print(f"[dim]{e}[/]")
+        return
+
+    run_dashboard(port=getattr(args, "port", 8080))
+
+
 def cmd_diagnose(args):
     """Run detailed VM diagnostics (standalone)."""
     name = args.name
@@ -1521,7 +1521,23 @@ def cmd_test(args):
                             if '192.168' in line or '10.0' in line:
                                 console.print(f"   IP: {line.split()[-1]}")
                 else:
-                    console.print("[yellow]⚠️  No IP address detected[/]")
+                    console.print("[yellow]⚠️  No IP address detected via virsh domifaddr[/]")
+                    # Fallback: try to get IP via QEMU Guest Agent (useful for slirp/user networking)
+                    try:
+                        from .cli import _qga_ping, _qga_exec
+                    except ImportError:
+                        from clonebox.cli import _qga_ping, _qga_exec
+                    if _qga_ping(vm_name, conn_uri):
+                        try:
+                            ip_out = _qga_exec(vm_name, conn_uri, "ip -4 -o addr show scope global | awk '{print $4}'", timeout=5)
+                            if ip_out and ip_out.strip():
+                                console.print(f"[green]✅ VM has network access (IP via QGA: {ip_out.strip()})[/]")
+                            else:
+                                console.print("[yellow]⚠️  IP not available via QGA[/]")
+                        except Exception as e:
+                            console.print(f"[yellow]⚠️  Could not get IP via QGA ({e})[/]")
+                    else:
+                        console.print("[dim]IP: QEMU Guest Agent not connected[/]")
             except:
                 console.print("[yellow]⚠️  Could not check network[/]")
         else:
@@ -1582,34 +1598,13 @@ def cmd_test(args):
         if all_paths:
             for idx, (host_path, guest_path) in enumerate(all_paths.items()):
                 try:
-                    result = subprocess.run(
-                        ["virsh", "--connect", conn_uri, "qemu-agent-command", vm_name,
-                         f'{{"execute":"guest-exec","arguments":{{"path":"test","arg":["-d","{guest_path}"],"capture-output":true}}}}'],
-                        capture_output=True, text=True, timeout=10
-                    )
-                    if result.returncode == 0:
-                        try:
-                            response = json.loads(result.stdout)
-                            if "return" in response:
-                                pid = response["return"]["pid"]
-                                result2 = subprocess.run(
-                                    ["virsh", "--connect", conn_uri, "qemu-agent-command", vm_name,
-                                     f'{{"execute":"guest-exec-status","arguments":{"pid":{pid}}}}'],
-                                    capture_output=True, text=True, timeout=10
-                                )
-                                if result2.returncode == 0:
-                                    resp2 = json.loads(result2.stdout)
-                                    if "return" in resp2 and resp2["return"]["exited"]:
-                                        exit_code = resp2["return"]["exitcode"]
-                                        if exit_code == 0:
-                                            console.print(f"[green]✅ {guest_path}[/]")
-                                        else:
-                                            console.print(f"[red]❌ {guest_path} (not accessible)[/]")
-                                        continue
-                        except:
-                            pass
-                    console.print(f"[yellow]⚠️  {guest_path} (unknown)[/]")
-                except:
+                    # Use the same QGA helper as diagnose/status
+                    is_accessible = _qga_exec(vm_name, conn_uri, f"test -d {guest_path} && echo yes || echo no", timeout=5)
+                    if is_accessible == "yes":
+                        console.print(f"[green]✅ {guest_path}[/]")
+                    else:
+                        console.print(f"[red]❌ {guest_path} (not accessible)[/]")
+                except Exception:
                     console.print(f"[yellow]⚠️  {guest_path} (could not check)[/]")
         else:
             console.print("[dim]No mount points configured[/]")
@@ -1717,8 +1712,18 @@ def generate_clonebox_yaml(
     """Generate YAML config from system snapshot."""
     sys_info = detector.get_system_info()
 
-    # Collect services
-    services = [s.name for s in snapshot.running_services]
+    # Services that should NOT be cloned to VM (host-specific)
+    VM_EXCLUDED_SERVICES = {
+        "libvirtd", "virtlogd", "libvirt-guests", "qemu-guest-agent",
+        "bluetooth", "bluez", "upower", "thermald", "tlp", "power-profiles-daemon",
+        "gdm", "gdm3", "sddm", "lightdm",
+        "snap.cups.cups-browsed", "snap.cups.cupsd",
+        "ModemManager", "wpa_supplicant",
+        "accounts-daemon", "colord", "switcheroo-control",
+    }
+
+    # Collect services (excluding host-specific ones)
+    services = [s.name for s in snapshot.running_services if s.name not in VM_EXCLUDED_SERVICES]
     if deduplicate:
         services = deduplicate_list(services)
 
@@ -1782,6 +1787,21 @@ def generate_clonebox_yaml(
             guest_path = f"/home/ubuntu/{rel_path}"
             app_data_mapping[host_path] = guest_path
 
+    post_commands = []
+
+    chrome_profile = home_dir / ".config" / "google-chrome"
+    if chrome_profile.exists():
+        host_path = str(chrome_profile)
+        if host_path not in paths_mapping and host_path not in app_data_mapping:
+            app_data_mapping[host_path] = "/home/ubuntu/.config/google-chrome"
+
+        post_commands.append(
+            "command -v google-chrome >/dev/null 2>&1 || ("
+            "curl -fsSL -o /tmp/google-chrome.deb https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb && "
+            "apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y /tmp/google-chrome.deb"
+            ")"
+        )
+
     # Determine VM name
     if not vm_name:
         if target_path:
@@ -1815,6 +1835,34 @@ def generate_clonebox_yaml(
     if deduplicate:
         all_snap_packages = deduplicate_list(all_snap_packages)
 
+    if chrome_profile.exists() and "google-chrome" not in [d.get("app", "") for d in app_data_dirs]:
+        if "chromium" not in all_snap_packages:
+            all_snap_packages.append("chromium")
+
+    if "pycharm-community" in all_snap_packages:
+        remapped = {}
+        for host_path, guest_path in app_data_mapping.items():
+            if guest_path == "/home/ubuntu/.config/JetBrains":
+                remapped[host_path] = "/home/ubuntu/snap/pycharm-community/common/.config/JetBrains"
+            elif guest_path == "/home/ubuntu/.local/share/JetBrains":
+                remapped[host_path] = "/home/ubuntu/snap/pycharm-community/common/.local/share/JetBrains"
+            elif guest_path == "/home/ubuntu/.cache/JetBrains":
+                remapped[host_path] = "/home/ubuntu/snap/pycharm-community/common/.cache/JetBrains"
+            else:
+                remapped[host_path] = guest_path
+        app_data_mapping = remapped
+
+    if "firefox" in all_apt_packages:
+        remapped = {}
+        for host_path, guest_path in app_data_mapping.items():
+            if guest_path == "/home/ubuntu/.mozilla/firefox":
+                remapped[host_path] = "/home/ubuntu/snap/firefox/common/.mozilla/firefox"
+            elif guest_path == "/home/ubuntu/.cache/mozilla/firefox":
+                remapped[host_path] = "/home/ubuntu/snap/firefox/common/.cache/mozilla/firefox"
+            else:
+                remapped[host_path] = guest_path
+        app_data_mapping = remapped
+
     # Build config
     config = {
         "version": "1",
@@ -1832,7 +1880,7 @@ def generate_clonebox_yaml(
         "services": services,
         "packages": all_apt_packages,
         "snap_packages": all_snap_packages,
-        "post_commands": [],  # User can add custom commands to run after setup
+        "post_commands": post_commands,
         "paths": paths_mapping,
         "app_data_paths": app_data_mapping,  # App-specific config/data directories
         "detected": {
@@ -2057,6 +2105,32 @@ def cmd_clone(args):
         base_image=getattr(args, "base_image", None),
     )
 
+    profile_name = getattr(args, "profile", None)
+    if profile_name:
+        merged_config = merge_with_profile(yaml.safe_load(yaml_content), profile_name)
+        if isinstance(merged_config, dict):
+            vm_section = merged_config.get("vm")
+            if isinstance(vm_section, dict):
+                vm_packages = vm_section.pop("packages", None)
+                if isinstance(vm_packages, list):
+                    packages = merged_config.get("packages")
+                    if not isinstance(packages, list):
+                        packages = []
+                    for p in vm_packages:
+                        if p not in packages:
+                            packages.append(p)
+                    merged_config["packages"] = packages
+
+            if "container" in merged_config:
+                merged_config.pop("container", None)
+
+            yaml_content = yaml.dump(
+                merged_config,
+                default_flow_style=False,
+                allow_unicode=True,
+                sort_keys=False,
+            )
+
     # Dry run - show what would be created and exit
     if dry_run:
         config = yaml.safe_load(yaml_content)
@@ -2337,6 +2411,7 @@ def main():
         action="store_true",
         help="Use user session (qemu:///session) - no root required",
     )
+    list_parser.add_argument("--json", action="store_true", help="Output JSON")
     list_parser.set_defaults(func=cmd_list)
 
     # Container command
@@ -2347,13 +2422,24 @@ def main():
         default="auto",
         help="Container engine: auto (default), podman, docker",
     )
+    container_parser.set_defaults(func=lambda args, p=container_parser: p.print_help())
     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(
+        "--engine",
+        choices=["auto", "podman", "docker"],
+        default=argparse.SUPPRESS,
+        help="Container engine: auto (default), podman, docker",
+    )
     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(
+        "--profile",
+        help="Profile name (loads ~/.clonebox.d/<name>.yaml, .clonebox.d/<name>.yaml, or built-in templates)",
+    )
     container_up.add_argument(
         "--mount",
         action="append",
@@ -2380,23 +2466,52 @@ def main():
     container_up.set_defaults(func=cmd_container_up)
 
     container_ps = container_sub.add_parser("ps", aliases=["ls"], help="List containers")
+    container_ps.add_argument(
+        "--engine",
+        choices=["auto", "podman", "docker"],
+        default=argparse.SUPPRESS,
+        help="Container engine: auto (default), podman, docker",
+    )
     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(
+        "--engine",
+        choices=["auto", "podman", "docker"],
+        default=argparse.SUPPRESS,
+        help="Container engine: auto (default), podman, docker",
+    )
     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(
+        "--engine",
+        choices=["auto", "podman", "docker"],
+        default=argparse.SUPPRESS,
+        help="Container engine: auto (default), podman, docker",
+    )
     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(
+        "--engine",
+        choices=["auto", "podman", "docker"],
+        default=argparse.SUPPRESS,
+        help="Container engine: auto (default), podman, docker",
+    )
     container_down.add_argument("name", help="Container name")
     container_down.set_defaults(func=cmd_container_down)
 
+    # Dashboard command
+    dashboard_parser = subparsers.add_parser("dashboard", help="Run local dashboard")
+    dashboard_parser.add_argument("--port", type=int, default=8080, help="Port to bind (default: 8080)")
+    dashboard_parser.set_defaults(func=cmd_dashboard)
+
     # Detect command
     detect_parser = subparsers.add_parser("detect", help="Detect system state")
     detect_parser.add_argument("--json", action="store_true", help="Output as JSON")
@@ -2436,6 +2551,10 @@ def main():
         "--base-image",
         help="Path to a bootable qcow2 image to use as a base disk",
     )
+    clone_parser.add_argument(
+        "--profile",
+        help="Profile name (loads ~/.clonebox.d/<name>.yaml, .clonebox.d/<name>.yaml, or built-in templates)",
+    )
     clone_parser.add_argument(
         "--replace",
         action="store_true",
@@ -2462,6 +2581,9 @@ def main():
     status_parser.add_argument(
         "--health", "-H", action="store_true", help="Run full health check"
     )
+    status_parser.add_argument(
+        "--verbose", "-v", action="store_true", help="Show detailed diagnostics (QGA, stderr, etc.)"
+    )
     status_parser.set_defaults(func=cmd_status)
 
     # Diagnose command - detailed diagnostics from workstation

clonebox/cloner.py

@@ -663,7 +663,8 @@ fi
         # Generate mount commands and fstab entries for 9p filesystems
         mount_commands = []
         fstab_entries = []
-        for idx, (host_path, guest_path) in enumerate(config.paths.items()):
+        all_paths = dict(config.paths) if config.paths else {}
+        for idx, (host_path, guest_path) in enumerate(all_paths.items()):
             if Path(host_path).exists():
                 tag = f"mount{idx}"
                 # Use uid=1000,gid=1000 to give ubuntu user access to mounts
@@ -695,6 +696,8 @@ fi
         runcmd_lines = []
 
         runcmd_lines.append("  - systemctl enable --now qemu-guest-agent || true")
+        runcmd_lines.append("  - systemctl enable --now snapd || true")
+        runcmd_lines.append("  - timeout 300 snap wait system seed.loaded || true")
         
         # Add service enablement
         for svc in config.services:
@@ -759,7 +762,7 @@ users:
     sudo: ALL=(ALL) NOPASSWD:ALL
     shell: /bin/bash
     lock_passwd: false
-    groups: sudo,adm,dialout,cdrom,floppy,audio,dip,video,plugdev,netdev
+    groups: sudo,adm,dialout,cdrom,floppy,audio,dip,video,plugdev,netdev,docker
     plain_text_passwd: {config.password}
 
 # Allow password authentication

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)

clonebox/detector.py

@@ -64,6 +64,37 @@ class SystemSnapshot:
 class SystemDetector:
     """Detects running services, applications and important paths on the system."""
 
+    # Services that should NOT be cloned to VM (host-specific, hardware-dependent, or hypervisor services)
+    VM_EXCLUDED_SERVICES = {
+        # Hypervisor/virtualization - no nested virt needed
+        "libvirtd",
+        "virtlogd",
+        "libvirt-guests",
+        "qemu-guest-agent",  # Host-side, VM has its own
+        # Hardware-specific
+        "bluetooth",
+        "bluez",
+        "upower",
+        "thermald",
+        "tlp",
+        "power-profiles-daemon",
+        # Display manager (VM has its own)
+        "gdm",
+        "gdm3",
+        "sddm",
+        "lightdm",
+        # Snap-based duplicates (prefer APT versions)
+        "snap.cups.cups-browsed",
+        "snap.cups.cupsd",
+        # Network hardware
+        "ModemManager",
+        "wpa_supplicant",
+        # Host-specific desktop
+        "accounts-daemon",
+        "colord",
+        "switcheroo-control",
+    }
+
     # Common development/server services to look for
     INTERESTING_SERVICES = [
         "docker",
@@ -244,12 +275,24 @@ class SystemDetector:
         # Browsers - profiles, extensions, bookmarks, passwords
         "chrome": [".config/google-chrome", ".config/chromium"],
         "chromium": [".config/chromium"],
-        "firefox": [".mozilla/firefox", ".cache/mozilla/firefox"],
+        "firefox": [
+            "snap/firefox/common/.mozilla/firefox",
+            "snap/firefox/common/.cache/mozilla/firefox",
+            ".mozilla/firefox",
+            ".cache/mozilla/firefox",
+        ],
         
         # IDEs and editors - settings, extensions, projects history
         "code": [".config/Code", ".vscode", ".vscode-server"],
         "vscode": [".config/Code", ".vscode", ".vscode-server"],
-        "pycharm": [".config/JetBrains", ".local/share/JetBrains", ".cache/JetBrains"],
+        "pycharm": [
+            "snap/pycharm-community/common/.config/JetBrains",
+            "snap/pycharm-community/common/.local/share/JetBrains",
+            "snap/pycharm-community/common/.cache/JetBrains",
+            ".config/JetBrains",
+            ".local/share/JetBrains",
+            ".cache/JetBrains",
+        ],
         "idea": [".config/JetBrains", ".local/share/JetBrains"],
         "webstorm": [".config/JetBrains", ".local/share/JetBrains"],
         "goland": [".config/JetBrains", ".local/share/JetBrains"],
@@ -323,27 +366,40 @@ class SystemDetector:
         app_data_paths = []
         seen_paths = set()
         
+        matched_patterns = set()
+
         for app in applications:
             app_name = app.name.lower()
-            
-            # Check each known app pattern
-            for pattern, dirs in self.APP_DATA_DIRS.items():
+
+            for pattern in self.APP_DATA_DIRS:
                 if pattern in app_name:
-                    for dir_name in dirs:
-                        full_path = self.home / dir_name
-                        if full_path.exists() and str(full_path) not in seen_paths:
-                            seen_paths.add(str(full_path))
-                            # Calculate size
-                            try:
-                                size = self._get_dir_size(full_path, max_depth=2)
-                            except:
-                                size = 0
-                            app_data_paths.append({
-                                "path": str(full_path),
-                                "app": app.name,
-                                "type": "app_data",
-                                "size_mb": round(size / 1024 / 1024, 1)
-                            })
+                    matched_patterns.add(pattern)
+
+        for pattern in ("firefox", "chrome", "chromium", "pycharm"):
+            matched_patterns.add(pattern)
+
+        for pattern in sorted(matched_patterns):
+            dirs = self.APP_DATA_DIRS.get(pattern, [])
+            if not dirs:
+                continue
+
+            snap_dirs = [d for d in dirs if d.startswith("snap/")]
+            preferred_dirs = snap_dirs if any((self.home / d).exists() for d in snap_dirs) else dirs
+
+            for dir_name in preferred_dirs:
+                full_path = self.home / dir_name
+                if full_path.exists() and str(full_path) not in seen_paths:
+                    seen_paths.add(str(full_path))
+                    try:
+                        size = self._get_dir_size(full_path, max_depth=2)
+                    except Exception:
+                        size = 0
+                    app_data_paths.append({
+                        "path": str(full_path),
+                        "app": pattern,
+                        "type": "app_data",
+                        "size_mb": round(size / 1024 / 1024, 1),
+                    })
         
         return app_data_paths
 

clonebox/profiles.py

@@ -0,0 +1,66 @@
+import pkgutil
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import yaml
+
+
+def load_profile(profile_name: str, search_paths: list[Path]) -> Optional[Dict[str, Any]]:
+    """Load profile YAML from ~/.clonebox.d/, .clonebox.d/, templates/profiles/"""
+    search_paths = search_paths or []
+
+    profile_paths = [
+        Path.home() / ".clonebox.d" / f"{profile_name}.yaml",
+        Path.cwd() / ".clonebox.d" / f"{profile_name}.yaml",
+    ]
+
+    for base in search_paths:
+        profile_paths.insert(0, base / "templates" / "profiles" / f"{profile_name}.yaml")
+        profile_paths.insert(0, base / f"{profile_name}.yaml")
+
+    for profile_path in profile_paths:
+        if profile_path.exists():
+            return yaml.safe_load(profile_path.read_text())
+
+    data = pkgutil.get_data("clonebox", f"templates/profiles/{profile_name}.yaml")
+    if data is not None:
+        return yaml.safe_load(data.decode())
+
+    return None
+
+
+def _deep_merge(base: Dict[str, Any], override: Dict[str, Any]) -> Dict[str, Any]:
+    merged: Dict[str, Any] = dict(base)
+    for key, value in override.items():
+        if (
+            key in merged
+            and isinstance(merged[key], dict)
+            and isinstance(value, dict)
+        ):
+            merged[key] = _deep_merge(merged[key], value)
+        else:
+            merged[key] = value
+    return merged
+
+
+def merge_with_profile(
+    base_config: Dict[str, Any],
+    profile_name: Optional[str] = None,
+    *,
+    profile: Optional[Dict[str, Any]] = None,
+    search_paths: Optional[list[Path]] = None,
+) -> Dict[str, Any]:
+    """Merge profile OVER base config (profile wins)."""
+    if profile is not None:
+        if not isinstance(profile, dict):
+            return base_config
+        return _deep_merge(base_config, profile)
+
+    if not profile_name:
+        return base_config
+
+    loaded = load_profile(profile_name, search_paths or [])
+    if not loaded or not isinstance(loaded, dict):
+        return base_config
+
+    return _deep_merge(base_config, loaded)

clonebox/templates/profiles/ml-dev.yaml

@@ -0,0 +1,6 @@
+container:
+  image: python:3.11-slim
+  packages: ["pip", "jupyterlab"]
+  ports: ["8888:8888"]
+vm:
+  packages: ["python3-pip", "jupyterlab"]

clonebox/validator.py

@@ -24,6 +24,7 @@ class VMValidator:
             "packages": {"passed": 0, "failed": 0, "total": 0, "details": []},
             "snap_packages": {"passed": 0, "failed": 0, "total": 0, "details": []},
             "services": {"passed": 0, "failed": 0, "total": 0, "details": []},
+            "apps": {"passed": 0, "failed": 0, "total": 0, "details": []},
             "overall": "unknown"
         }
     
@@ -236,6 +237,16 @@ class VMValidator:
         
         return self.results["snap_packages"]
     
+    # Services that should NOT be validated in VM (host-specific)
+    VM_EXCLUDED_SERVICES = {
+        "libvirtd", "virtlogd", "libvirt-guests", "qemu-guest-agent",
+        "bluetooth", "bluez", "upower", "thermald", "tlp", "power-profiles-daemon",
+        "gdm", "gdm3", "sddm", "lightdm",
+        "snap.cups.cups-browsed", "snap.cups.cupsd",
+        "ModemManager", "wpa_supplicant",
+        "accounts-daemon", "colord", "switcheroo-control",
+    }
+
     def validate_services(self) -> Dict:
         """Validate services are enabled and running."""
         self.console.print("\n[bold]⚙️  Validating Services...[/]")
@@ -244,45 +255,155 @@ class VMValidator:
         if not services:
             self.console.print("[dim]No services configured[/]")
             return self.results["services"]
-        
+
+        if "skipped" not in self.results["services"]:
+            self.results["services"]["skipped"] = 0
+
         svc_table = Table(title="Service Validation", border_style="cyan")
         svc_table.add_column("Service", style="bold")
         svc_table.add_column("Enabled", justify="center")
         svc_table.add_column("Running", justify="center")
-        
+        svc_table.add_column("Note", style="dim")
+
         for service in services:
+            if service in self.VM_EXCLUDED_SERVICES:
+                svc_table.add_row(service, "[dim]—[/]", "[dim]—[/]", "host-only")
+                self.results["services"]["skipped"] += 1
+                self.results["services"]["details"].append(
+                    {
+                        "service": service,
+                        "enabled": None,
+                        "running": None,
+                        "skipped": True,
+                        "reason": "host-specific service",
+                    }
+                )
+                continue
+
             self.results["services"]["total"] += 1
-            
-            # Check if enabled
+
             enabled_cmd = f"systemctl is-enabled {service} 2>/dev/null"
             enabled_status = self._exec_in_vm(enabled_cmd)
             is_enabled = enabled_status == "enabled"
-            
-            # Check if running
+
             running_cmd = f"systemctl is-active {service} 2>/dev/null"
             running_status = self._exec_in_vm(running_cmd)
             is_running = running_status == "active"
-            
+
             enabled_icon = "[green]✅[/]" if is_enabled else "[yellow]⚠️[/]"
             running_icon = "[green]✅[/]" if is_running else "[red]❌[/]"
-            
-            svc_table.add_row(service, enabled_icon, running_icon)
-            
+
+            svc_table.add_row(service, enabled_icon, running_icon, "")
+
             if is_enabled and is_running:
                 self.results["services"]["passed"] += 1
             else:
                 self.results["services"]["failed"] += 1
-            
-            self.results["services"]["details"].append({
-                "service": service,
-                "enabled": is_enabled,
-                "running": is_running
-            })
-        
+
+            self.results["services"]["details"].append(
+                {
+                    "service": service,
+                    "enabled": is_enabled,
+                    "running": is_running,
+                    "skipped": False,
+                }
+            )
+
         self.console.print(svc_table)
-        self.console.print(f"[dim]{self.results['services']['passed']}/{self.results['services']['total']} services active[/]")
-        
+        skipped = self.results["services"].get("skipped", 0)
+        msg = f"{self.results['services']['passed']}/{self.results['services']['total']} services active"
+        if skipped > 0:
+            msg += f" ({skipped} host-only skipped)"
+        self.console.print(f"[dim]{msg}[/]")
+
         return self.results["services"]
+
+    def validate_apps(self) -> Dict:
+        packages = self.config.get("packages", [])
+        snap_packages = self.config.get("snap_packages", [])
+        app_data_paths = self.config.get("app_data_paths", {})
+
+        expected = []
+
+        if "firefox" in packages:
+            expected.append("firefox")
+        if "pycharm-community" in snap_packages:
+            expected.append("pycharm-community")
+
+        for _, guest_path in app_data_paths.items():
+            if guest_path == "/home/ubuntu/.config/google-chrome":
+                expected.append("google-chrome")
+                break
+
+        expected = sorted(set(expected))
+        if not expected:
+            return self.results["apps"]
+
+        self.console.print("\n[bold]🧩 Validating Apps...[/]")
+        table = Table(title="App Validation", border_style="cyan")
+        table.add_column("App", style="bold")
+        table.add_column("Installed", justify="center")
+        table.add_column("Profile", justify="center")
+
+        def _check_dir_nonempty(path: str) -> bool:
+            out = self._exec_in_vm(
+                f"test -d {path} && [ $(ls -A {path} 2>/dev/null | wc -l) -gt 0 ] && echo yes || echo no",
+                timeout=10,
+            )
+            return out == "yes"
+
+        for app in expected:
+            self.results["apps"]["total"] += 1
+            installed = False
+            profile_ok = False
+
+            if app == "firefox":
+                installed = (
+                    self._exec_in_vm("command -v firefox >/dev/null 2>&1 && echo yes || echo no")
+                    == "yes"
+                )
+                if _check_dir_nonempty("/home/ubuntu/snap/firefox/common/.mozilla/firefox"):
+                    profile_ok = True
+                elif _check_dir_nonempty("/home/ubuntu/.mozilla/firefox"):
+                    profile_ok = True
+
+            elif app == "pycharm-community":
+                installed = (
+                    self._exec_in_vm(
+                        "snap list pycharm-community >/dev/null 2>&1 && echo yes || echo no"
+                    )
+                    == "yes"
+                )
+                profile_ok = _check_dir_nonempty(
+                    "/home/ubuntu/snap/pycharm-community/common/.config/JetBrains"
+                )
+
+            elif app == "google-chrome":
+                installed = (
+                    self._exec_in_vm(
+                        "(command -v google-chrome >/dev/null 2>&1 || command -v google-chrome-stable >/dev/null 2>&1) && echo yes || echo no"
+                    )
+                    == "yes"
+                )
+                profile_ok = _check_dir_nonempty("/home/ubuntu/.config/google-chrome")
+
+            table.add_row(
+                app,
+                "[green]✅[/]" if installed else "[red]❌[/]",
+                "[green]✅[/]" if profile_ok else "[red]❌[/]",
+            )
+
+            if installed and profile_ok:
+                self.results["apps"]["passed"] += 1
+            else:
+                self.results["apps"]["failed"] += 1
+
+            self.results["apps"]["details"].append(
+                {"app": app, "installed": installed, "profile": profile_ok}
+            )
+
+        self.console.print(table)
+        return self.results["apps"]
     
     def validate_all(self) -> Dict:
         """Run all validations and return comprehensive results."""
@@ -311,51 +432,65 @@ class VMValidator:
         self.validate_packages()
         self.validate_snap_packages()
         self.validate_services()
+        self.validate_apps()
         
         # Calculate overall status
         total_checks = (
             self.results["mounts"]["total"] +
             self.results["packages"]["total"] +
             self.results["snap_packages"]["total"] +
-            self.results["services"]["total"]
+            self.results["services"]["total"] +
+            self.results["apps"]["total"]
         )
         
         total_passed = (
             self.results["mounts"]["passed"] +
             self.results["packages"]["passed"] +
             self.results["snap_packages"]["passed"] +
-            self.results["services"]["passed"]
+            self.results["services"]["passed"] +
+            self.results["apps"]["passed"]
         )
         
         total_failed = (
             self.results["mounts"]["failed"] +
             self.results["packages"]["failed"] +
             self.results["snap_packages"]["failed"] +
-            self.results["services"]["failed"]
+            self.results["services"]["failed"] +
+            self.results["apps"]["failed"]
         )
         
+        # Get skipped services count
+        skipped_services = self.results["services"].get("skipped", 0)
+        
         # Print summary
         self.console.print("\n[bold]📊 Validation Summary[/]")
         summary_table = Table(border_style="cyan")
         summary_table.add_column("Category", style="bold")
         summary_table.add_column("Passed", justify="right", style="green")
         summary_table.add_column("Failed", justify="right", style="red")
+        summary_table.add_column("Skipped", justify="right", style="dim")
         summary_table.add_column("Total", justify="right")
         
         summary_table.add_row("Mounts", str(self.results["mounts"]["passed"]), 
-                             str(self.results["mounts"]["failed"]), 
+                             str(self.results["mounts"]["failed"]), "—",
                              str(self.results["mounts"]["total"]))
         summary_table.add_row("APT Packages", str(self.results["packages"]["passed"]), 
-                             str(self.results["packages"]["failed"]), 
+                             str(self.results["packages"]["failed"]), "—",
                              str(self.results["packages"]["total"]))
         summary_table.add_row("Snap Packages", str(self.results["snap_packages"]["passed"]), 
-                             str(self.results["snap_packages"]["failed"]), 
+                             str(self.results["snap_packages"]["failed"]), "—",
                              str(self.results["snap_packages"]["total"]))
         summary_table.add_row("Services", str(self.results["services"]["passed"]), 
                              str(self.results["services"]["failed"]), 
+                             str(skipped_services),
                              str(self.results["services"]["total"]))
+        summary_table.add_row("Apps", str(self.results["apps"]["passed"]), 
+                             str(self.results["apps"]["failed"]), "—",
+                             str(self.results["apps"]["total"]))
         summary_table.add_row("[bold]TOTAL", f"[bold green]{total_passed}", 
-                             f"[bold red]{total_failed}", f"[bold]{total_checks}")
+                             f"[bold red]{total_failed}", 
+                             f"[dim]{skipped_services}[/]",
+                             f"[bold]{total_checks}")
         
         self.console.print(summary_table)
         

{clonebox-0.1.18.dist-info → clonebox-0.1.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clonebox
-Version: 0.1.18
+Version: 0.1.20
 Summary: Clone your workstation environment to an isolated VM with selective apps, paths and services
 Author: CloneBox Team
 License: Apache-2.0
@@ -41,6 +41,9 @@ Provides-Extra: test
 Requires-Dist: pytest>=7.0.0; extra == "test"
 Requires-Dist: pytest-cov>=4.0.0; extra == "test"
 Requires-Dist: pytest-timeout>=2.0.0; extra == "test"
+Provides-Extra: dashboard
+Requires-Dist: fastapi>=0.100.0; extra == "dashboard"
+Requires-Dist: uvicorn>=0.22.0; extra == "dashboard"
 Dynamic: license-file
 
 # CloneBox 📦

clonebox-0.1.20.dist-info/RECORD

@@ -0,0 +1,17 @@
+clonebox/__init__.py,sha256=CyfHVVq6KqBr4CNERBpXk_O6Q5B35q03YpdQbokVvvI,408
+clonebox/__main__.py,sha256=Fcoyzwwyz5-eC_sBlQk5a5RbKx8uodQz5sKJ190U0NU,135
+clonebox/cli.py,sha256=08k0XvVdcExl6M64jqt7I_E04QVES3opXPexX9bYJec,103621
+clonebox/cloner.py,sha256=_dJrcg4FoPzAU49J-duJdp37GF-5hE3R_ipbwaw-kaQ,32679
+clonebox/container.py,sha256=tiYK1ZB-DhdD6A2FuMA0h_sRNkUI7KfYcJ0tFOcdyeM,6105
+clonebox/dashboard.py,sha256=RhSPvR6kWglqXeLkCWesBZQid7wv2WpJa6w78mXbPjY,4268
+clonebox/detector.py,sha256=aS_QlbG93-DE3hsjRt88E7O-PGC2TUBgUbP9wqT9g60,23221
+clonebox/models.py,sha256=Uxz9eHov2epJpNYbl0ejaOX91iMSjqdHskGdC8-smVk,7789
+clonebox/profiles.py,sha256=VaKVuxCrgyMxx-8_WOTcw7E8irwGxUPhZHVY6RxYYiE,2034
+clonebox/validator.py,sha256=LnQSZEdJXFGcJrTPxzS2cQUmAXucGeHDKwxrX632h_s,21188
+clonebox/templates/profiles/ml-dev.yaml,sha256=MT7Wu3xGBnYIsO5mzZ2GDI4AAEFGOroIx0eU3XjNARg,140
+clonebox-0.1.20.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+clonebox-0.1.20.dist-info/METADATA,sha256=qOJSrz8MfPrZe3zO0Q16AfcdD_ybXx-YuVAs0_sij2g,35353
+clonebox-0.1.20.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+clonebox-0.1.20.dist-info/entry_points.txt,sha256=FES95Vi3btfViLEEoHdb8nikNxTqzaooi9ehZw9ZfWI,47
+clonebox-0.1.20.dist-info/top_level.txt,sha256=LdMo2cvCrEcRGH2M8JgQNVsCoszLV0xug6kx1JnaRjo,9
+clonebox-0.1.20.dist-info/RECORD,,

clonebox-0.1.18.dist-info/RECORD

@@ -1,14 +0,0 @@
-clonebox/__init__.py,sha256=C1J7Uwrp8H9Zopo5JgrQYzXg-PWls1JdqmE_0Qp1Tro,408
-clonebox/__main__.py,sha256=Fcoyzwwyz5-eC_sBlQk5a5RbKx8uodQz5sKJ190U0NU,135
-clonebox/cli.py,sha256=0Yjkq8EC5v8e402ouvPt3F3-8QSdKuMYZmOrIa8YARc,98076
-clonebox/cloner.py,sha256=tgN51yeNGesolO1wfuVh-CAGkAZew7oMoCYYz_bXgBk,32456
-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.18.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-clonebox-0.1.18.dist-info/METADATA,sha256=zdZz4r2QGeCLnFq757o0dR8T9OiLqYneys1r4LFcq58,35220
-clonebox-0.1.18.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-clonebox-0.1.18.dist-info/entry_points.txt,sha256=FES95Vi3btfViLEEoHdb8nikNxTqzaooi9ehZw9ZfWI,47
-clonebox-0.1.18.dist-info/top_level.txt,sha256=LdMo2cvCrEcRGH2M8JgQNVsCoszLV0xug6kx1JnaRjo,9
-clonebox-0.1.18.dist-info/RECORD,,