clonebox 0.1.17__py3-none-any.whl → 0.1.19__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(
@@ -80,98 +83,95 @@ def _resolve_vm_name_and_config_file(name: Optional[str]) -> tuple[str, Optional
 
 
 def _qga_ping(vm_name: str, conn_uri: str) -> bool:
-    def _qga_ping() -> bool:
-        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
+    import subprocess
 
-    return _qga_ping()
+    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]:
-    def _qga_exec() -> Optional[str]:
-        try:
-            payload = {
-                "execute": "guest-exec",
-                "arguments": {
-                    "path": "/bin/sh",
-                    "arg": ["-c", command],
-                    "capture-output": True,
-                },
-            }
-            exec_result = subprocess.run(
+    import subprocess
+    import base64
+    import time
+
+    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
+
+        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(payload),
+                    json.dumps(status_payload),
                 ],
                 capture_output=True,
                 text=True,
-                timeout=timeout,
+                timeout=5,
             )
-            if exec_result.returncode != 0:
-                return None
-
-            resp = json.loads(exec_result.stdout)
-            pid = resp.get("return", {}).get("pid")
-            if not pid:
+            if status_result.returncode != 0:
                 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 ""
+            status_resp = json.loads(status_result.stdout)
+            ret = status_resp.get("return", {})
+            if not ret.get("exited", False):
+                time.sleep(0.3)
+                continue
 
-            return None
-        except Exception:
-            return None
+            out_data = ret.get("out-data")
+            if out_data:
+                return base64.b64decode(out_data).decode().strip()
+            return ""
 
-    return _qga_exec()
+        return None
+    except Exception:
+        return None
 
 
 def run_vm_diagnostics(
@@ -237,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}[/]")
@@ -706,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
@@ -907,16 +919,15 @@ def cmd_delete(args):
         ).ask():
             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
@@ -935,14 +946,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:
@@ -962,21 +965,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))
 
@@ -1007,39 +1010,18 @@ 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)
@@ -1524,7 +1506,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:
@@ -1585,34 +1583,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[/]")
@@ -1720,8 +1697,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)
 
@@ -2060,6 +2047,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)
@@ -2340,6 +2353,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
@@ -2350,6 +2364,7 @@ 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")
@@ -2357,6 +2372,10 @@ def main():
     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",
@@ -2439,6 +2458,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",
@@ -2465,6 +2488,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

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",

clonebox/profiles.py

@@ -0,0 +1,49 @@
+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/"""
+    profile_paths = [
+        Path.home() / ".clonebox.d" / f"{profile_name}.yaml",
+        Path.cwd() / ".clonebox.d" / 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) -> Dict[str, Any]:
+    """Merge profile OVER base config (profile wins)."""
+    if not profile_name:
+        return base_config
+
+    profile = load_profile(profile_name, [])
+    if not profile or not isinstance(profile, dict):
+        return base_config
+
+    return _deep_merge(base_config, profile)

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

@@ -236,6 +236,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...[/]")
@@ -245,12 +255,30 @@ class VMValidator:
             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"
+                })
+                continue
+            
             self.results["services"]["total"] += 1
             
             # Check if enabled
@@ -266,7 +294,7 @@ class VMValidator:
             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
@@ -276,11 +304,16 @@ class VMValidator:
             self.results["services"]["details"].append({
                 "service": service,
                 "enabled": is_enabled,
-                "running": is_running
+                "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"]
     
@@ -334,28 +367,35 @@ class VMValidator:
             self.results["services"]["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("[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.17.dist-info → clonebox-0.1.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clonebox
-Version: 0.1.17
+Version: 0.1.19
 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.19.dist-info/RECORD

@@ -0,0 +1,16 @@
+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,,

clonebox-0.1.17.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=mB2Xoz9llkHW9yIR-xRuZ94F_PmV833gdiKVKKcJQrc,98462
-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.17.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-clonebox-0.1.17.dist-info/METADATA,sha256=YHJ3k1qzqhkB7hsuZVesQv5ANF6bbABLGTYSCl29p34,35220
-clonebox-0.1.17.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-clonebox-0.1.17.dist-info/entry_points.txt,sha256=FES95Vi3btfViLEEoHdb8nikNxTqzaooi9ehZw9ZfWI,47
-clonebox-0.1.17.dist-info/top_level.txt,sha256=LdMo2cvCrEcRGH2M8JgQNVsCoszLV0xug6kx1JnaRjo,9
-clonebox-0.1.17.dist-info/RECORD,,