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

clonebox/cli.py

@@ -919,6 +919,8 @@ def cmd_delete(args):
         ).ask():
             console.print("[yellow]Cancelled.[/]")
             return
+
+
 def cmd_list(args):
     """List all VMs."""
     cloner = SelectiveVMCloner(user_session=getattr(args, "user", False))
@@ -1027,6 +1029,19 @@ def cmd_container_down(args):
     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
@@ -1772,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:
@@ -1805,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",
@@ -1822,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": {
@@ -2368,6 +2426,12 @@ def main():
     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")
@@ -2402,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")

clonebox/cloner.py

@@ -696,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:
@@ -760,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

@@ -275,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"],
@@ -354,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

@@ -7,11 +7,17 @@ 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())
@@ -37,13 +43,24 @@ def _deep_merge(base: Dict[str, Any], override: Dict[str, Any]) -> Dict[str, Any
     return merged
 
 
-def merge_with_profile(base_config: Dict[str, Any], profile_name: Optional[str] = None) -> Dict[str, Any]:
+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
 
-    profile = load_profile(profile_name, [])
-    if not profile or not isinstance(profile, dict):
+    loaded = load_profile(profile_name, search_paths or [])
+    if not loaded or not isinstance(loaded, dict):
         return base_config
 
-    return _deep_merge(base_config, profile)
+    return _deep_merge(base_config, loaded)

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"
         }
     
@@ -254,68 +255,155 @@ class VMValidator:
         if not services:
             self.console.print("[dim]No services configured[/]")
             return self.results["services"]
-        
-        # Initialize skipped counter
+
         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:
-            # Check if service should be skipped (host-specific)
             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"
-                })
+                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, "")
-            
+
             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,
-                "skipped": False
-            })
-        
+
+            self.results["services"]["details"].append(
+                {
+                    "service": service,
+                    "enabled": is_enabled,
+                    "running": is_running,
+                    "skipped": False,
+                }
+            )
+
         self.console.print(svc_table)
         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."""
@@ -344,27 +432,31 @@ 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
@@ -392,6 +484,9 @@ class VMValidator:
                              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"[dim]{skipped_services}[/]",

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clonebox
-Version: 0.1.19
+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

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.19.dist-info/RECORD

@@ -1,16 +0,0 @@
-clonebox/__init__.py,sha256=CyfHVVq6KqBr4CNERBpXk_O6Q5B35q03YpdQbokVvvI,408
-clonebox/__main__.py,sha256=Fcoyzwwyz5-eC_sBlQk5a5RbKx8uodQz5sKJ190U0NU,135
-clonebox/cli.py,sha256=WnAlgR3h0gIMwkc0uHAr44E4eS25GTBsNbKbuumrUug,99790
-clonebox/cloner.py,sha256=OXytYy4K4sr-ytP55HZK9frt1vU5Kf5EOCIKYhpdJtQ,32516
-clonebox/container.py,sha256=tiYK1ZB-DhdD6A2FuMA0h_sRNkUI7KfYcJ0tFOcdyeM,6105
-clonebox/detector.py,sha256=FM8QJ6RTO0jXyUJIcAJivLwUh82xm287ayFD_VIuvgs,22521
-clonebox/models.py,sha256=Uxz9eHov2epJpNYbl0ejaOX91iMSjqdHskGdC8-smVk,7789
-clonebox/profiles.py,sha256=ZyuPct9Jg5m2ImnSEbHvBMp3x7Ufj2420D84rXt2T1Y,1537
-clonebox/validator.py,sha256=qIkFMkWmpx4k2-vPkLigZ6pK5wtl748CmpuNLB6yOIM,17645
-clonebox/templates/profiles/ml-dev.yaml,sha256=MT7Wu3xGBnYIsO5mzZ2GDI4AAEFGOroIx0eU3XjNARg,140
-clonebox-0.1.19.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-clonebox-0.1.19.dist-info/METADATA,sha256=HXLOv0aaY7OlXGJKtk8LSzlbqeQwgHp9Bax29KzQLV4,35353
-clonebox-0.1.19.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-clonebox-0.1.19.dist-info/entry_points.txt,sha256=FES95Vi3btfViLEEoHdb8nikNxTqzaooi9ehZw9ZfWI,47
-clonebox-0.1.19.dist-info/top_level.txt,sha256=LdMo2cvCrEcRGH2M8JgQNVsCoszLV0xug6kx1JnaRjo,9
-clonebox-0.1.19.dist-info/RECORD,,