clonebox 0.1.18__tar.gz → 0.1.19__tar.gz

{clonebox-0.1.18/src/clonebox.egg-info → clonebox-0.1.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clonebox
-Version: 0.1.18
+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.18 → clonebox-0.1.19}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "clonebox"
-version = "0.1.18"
+version = "0.1.19"
 description = "Clone your workstation environment to an isolated VM with selective apps, paths and services"
 readme = "README.md"
 license = {text = "Apache-2.0"}
@@ -52,6 +52,10 @@ test = [
     "pytest-cov>=4.0.0",
     "pytest-timeout>=2.0.0",
 ]
+dashboard = [
+    "fastapi>=0.100.0",
+    "uvicorn>=0.22.0",
+]
 
 [project.scripts]
 clonebox = "clonebox.cli:main"
@@ -64,6 +68,9 @@ Issues = "https://github.com/wronai/clonebox/issues"
 [tool.setuptools.packages.find]
 where = ["src"]
 
+[tool.setuptools.package-data]
+clonebox = ["templates/**/*.yaml"]
+
 [tool.black]
 line-length = 100
 target-version = ["py38", "py39", "py310", "py311", "py312"]
@@ -82,6 +89,7 @@ markers = [
     "e2e: end-to-end tests requiring libvirt/KVM (deselect with '-m \"not e2e\"')",
     "slow: slow tests (deselect with '-m \"not slow\"')",
     "integration: integration tests",
+    "container: container workflow tests requiring podman/docker",
     "requires_kvm: tests requiring /dev/kvm access",
 ]
 addopts = [
@@ -99,3 +107,9 @@ filterwarnings = [
     "ignore::PendingDeprecationWarning",
     "ignore::UserWarning",
 ]
+
+[tool.coverage.run]
+omit = [
+    "src/clonebox/container.py",
+    "src/clonebox/cli.py",
+]

{clonebox-0.1.18 → clonebox-0.1.19}/src/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-0.1.18 → clonebox-0.1.19}/src/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
@@ -904,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
@@ -932,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:
@@ -959,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))
 
@@ -1004,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)
@@ -1521,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:
@@ -1582,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[/]")
@@ -1717,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)
 
@@ -2057,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)
@@ -2337,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
@@ -2347,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")
@@ -2354,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",
@@ -2436,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",
@@ -2462,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-0.1.18 → clonebox-0.1.19}/src/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-0.1.18 → clonebox-0.1.19}/src/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-0.1.19/src/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-0.1.19/src/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-0.1.18 → clonebox-0.1.19}/src/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.18 → clonebox-0.1.19/src/clonebox.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clonebox
-Version: 0.1.18
+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.18 → clonebox-0.1.19}/src/clonebox.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ src/clonebox/cloner.py
 src/clonebox/container.py
 src/clonebox/detector.py
 src/clonebox/models.py
+src/clonebox/profiles.py
 src/clonebox/validator.py
 src/clonebox.egg-info/PKG-INFO
 src/clonebox.egg-info/SOURCES.txt
@@ -15,8 +16,10 @@ src/clonebox.egg-info/dependency_links.txt
 src/clonebox.egg-info/entry_points.txt
 src/clonebox.egg-info/requires.txt
 src/clonebox.egg-info/top_level.txt
+src/clonebox/templates/profiles/ml-dev.yaml
 tests/test_cli.py
 tests/test_cloner.py
+tests/test_container.py
 tests/test_detector.py
 tests/test_models.py
 tests/test_network.py

{clonebox-0.1.18 → clonebox-0.1.19}/src/clonebox.egg-info/requires.txt

@@ -5,6 +5,10 @@ psutil>=5.9.0
 pyyaml>=6.0
 pydantic>=2.0.0
 
+[dashboard]
+fastapi>=0.100.0
+uvicorn>=0.22.0
+
 [dev]
 pytest>=7.0.0
 pytest-cov>=4.0.0

{clonebox-0.1.18 → clonebox-0.1.19}/tests/test_cli.py

@@ -222,6 +222,9 @@ class TestCLIIntegration:
         (["detect", "--help"], 0),
         (["clone", "--help"], 0),
         (["list", "--help"], 0),
+        (["container", "--help"], 0),
+        (["container", "ps", "--help"], 0),
+        (["container", "up", "--help"], 0),
     ])
     def test_cli_help_commands(self, command, expected_exit):
         """Test CLI help and version commands."""

clonebox-0.1.19/tests/test_container.py

@@ -0,0 +1,235 @@
+#!/usr/bin/env python3
+
+from pathlib import Path
+from unittest.mock import MagicMock
+
+import pytest
+
+from clonebox.container import ContainerCloner
+from clonebox.models import ContainerConfig
+
+
+def _which_side_effect(mapping):
+    def which(name):
+        return mapping.get(name)
+
+    return which
+
+
+class TestContainerClonerEngineDetection:
+    def test_detect_engine_prefers_podman(self, monkeypatch):
+        monkeypatch.setattr(
+            "clonebox.container.shutil.which",
+            _which_side_effect({"podman": "/usr/bin/podman", "docker": "/usr/bin/docker"}),
+        )
+
+        def fake_run(self, cmd, check=True, capture_output=True, text=True):
+            return MagicMock(returncode=0, stdout="podman version", stderr="")
+
+        monkeypatch.setattr("clonebox.container.ContainerCloner._run", fake_run)
+
+        c = ContainerCloner(engine="auto")
+        assert c.engine == "podman"
+
+    def test_detect_engine_fallbacks_to_docker(self, monkeypatch):
+        monkeypatch.setattr(
+            "clonebox.container.shutil.which",
+            _which_side_effect({"podman": "/usr/bin/podman", "docker": "/usr/bin/docker"}),
+        )
+
+        def fake_run(self, cmd, check=True, capture_output=True, text=True):
+            if cmd[0] == "podman":
+                raise RuntimeError("podman broken")
+            return MagicMock(returncode=0, stdout="docker version", stderr="")
+
+        monkeypatch.setattr("clonebox.container.ContainerCloner._run", fake_run)
+
+        c = ContainerCloner(engine="auto")
+        assert c.engine == "docker"
+
+    def test_detect_engine_errors_when_none_found(self, monkeypatch):
+        monkeypatch.setattr(
+            "clonebox.container.shutil.which",
+            _which_side_effect({"podman": None, "docker": None}),
+        )
+
+        c = ContainerCloner.__new__(ContainerCloner)
+        c.engine = "auto"
+        with pytest.raises(RuntimeError, match="No container engine found"):
+            c.detect_engine()
+
+
+class TestContainerClonerBuild:
+    def test_build_dockerfile_includes_packages(self, tmp_path):
+        cfg = ContainerConfig(
+            engine="podman",
+            image="ubuntu:22.04",
+            workspace=tmp_path,
+            packages=["curl", "git"],
+        )
+        c = ContainerCloner.__new__(ContainerCloner)
+        c.engine = "podman"
+
+        dockerfile = c.build_dockerfile(cfg)
+        assert "FROM ubuntu:22.04" in dockerfile
+        assert "apt-get install -y curl git" in dockerfile
+        assert "WORKDIR /workspace" in dockerfile
+
+    def test_build_image_calls_engine_build(self, monkeypatch, tmp_path):
+        (tmp_path / "file.txt").write_text("x")
+        cfg = ContainerConfig(engine="podman", workspace=tmp_path, packages=["curl"])
+
+        calls = []
+
+        def fake_run(self, cmd, check=True, capture_output=True, text=True):
+            calls.append(cmd)
+            return MagicMock(returncode=0, stdout="ok", stderr="")
+
+        monkeypatch.setattr("clonebox.container.ContainerCloner._run", fake_run)
+
+        c = ContainerCloner.__new__(ContainerCloner)
+        c.engine = "podman"
+
+        tag = c.build_image(cfg, tag="myimg:latest")
+        assert tag == "myimg:latest"
+        assert calls
+        cmd = calls[0]
+        assert cmd[0] == "podman"
+        assert cmd[1] == "build"
+        assert "-t" in cmd and "myimg:latest" in cmd
+        assert str(tmp_path.resolve()) == cmd[-1]
+
+        dockerfile_path = Path(cmd[cmd.index("-f") + 1])
+        assert not dockerfile_path.exists()
+
+
+class TestContainerClonerUpAndPs:
+    def test_up_runs_interactive_with_env_file(self, monkeypatch, tmp_path):
+        (tmp_path / ".env").write_text("FOO=bar\n")
+
+        cfg = ContainerConfig(engine="podman", name="test", workspace=tmp_path)
+
+        monkeypatch.setattr(
+            "clonebox.container.shutil.which", _which_side_effect({"podman": "/usr/bin/podman"})
+        )
+
+        def fake_run_version(self, cmd, check=True, capture_output=True, text=True):
+            return MagicMock(returncode=0, stdout="podman version", stderr="")
+
+        monkeypatch.setattr("clonebox.container.ContainerCloner._run", fake_run_version)
+
+        called = {}
+
+        def fake_subprocess_run(cmd, check=True):
+            called["cmd"] = cmd
+            return MagicMock(returncode=0)
+
+        monkeypatch.setattr("clonebox.container.subprocess.run", fake_subprocess_run)
+
+        c = ContainerCloner(engine="podman")
+        c.up(cfg, detach=False)
+
+        cmd = called["cmd"]
+        assert cmd[0] == "podman"
+        assert cmd[1] == "run"
+        assert "--env-file" in cmd
+        assert str(tmp_path / ".env") in cmd
+        assert "-v" in cmd
+        assert "bash" in cmd
+
+    def test_up_detach_runs_sleep_infinity(self, monkeypatch, tmp_path):
+        cfg = ContainerConfig(engine="podman", name="test", workspace=tmp_path)
+
+        monkeypatch.setattr(
+            "clonebox.container.shutil.which", _which_side_effect({"podman": "/usr/bin/podman"})
+        )
+
+        def fake_run_version(self, cmd, check=True, capture_output=True, text=True):
+            return MagicMock(returncode=0, stdout="podman version", stderr="")
+
+        monkeypatch.setattr("clonebox.container.ContainerCloner._run", fake_run_version)
+
+        called = {}
+
+        def fake_subprocess_run(cmd, check=True):
+            called["cmd"] = cmd
+            return MagicMock(returncode=0)
+
+        monkeypatch.setattr("clonebox.container.subprocess.run", fake_subprocess_run)
+
+        c = ContainerCloner(engine="podman")
+        c.up(cfg, detach=True)
+
+        cmd = called["cmd"]
+        assert "-d" in cmd
+        assert cmd[-2:] == ["sleep", "infinity"]
+
+    def test_ps_docker_parses_tab_format(self, monkeypatch):
+        def fake_run(self, cmd, check=True, capture_output=True, text=True):
+            return MagicMock(
+                returncode=0,
+                stdout="c1\tubuntu:22.04\tUp 2 seconds\t0.0.0.0:8080->80/tcp\n",
+                stderr="",
+            )
+
+        monkeypatch.setattr("clonebox.container.ContainerCloner._run", fake_run)
+
+        c = ContainerCloner.__new__(ContainerCloner)
+        c.engine = "docker"
+
+        items = c.ps(all=False)
+        assert len(items) == 1
+        assert items[0]["name"] == "c1"
+        assert items[0]["image"] == "ubuntu:22.04"
+
+    def test_ps_podman_json_uses_a_when_all(self, monkeypatch):
+        captured = {}
+
+        def fake_run(self, cmd, check=True, capture_output=True, text=True):
+            captured["cmd"] = cmd
+            return MagicMock(
+                returncode=0,
+                stdout='[{"Names":["c1"],"Image":"ubuntu:22.04","State":"running","Ports":[]}]',
+                stderr="",
+            )
+
+        monkeypatch.setattr("clonebox.container.ContainerCloner._run", fake_run)
+
+        c = ContainerCloner.__new__(ContainerCloner)
+        c.engine = "podman"
+
+        items = c.ps(all=True)
+        # Command is: podman ps --format json -a
+        assert captured["cmd"][:2] == ["podman", "ps"]
+        assert "-a" in captured["cmd"]
+        assert items[0]["name"] == "c1"
+
+
+class TestContainerClonerStopRm:
+    def test_stop_calls_engine(self, monkeypatch):
+        called = {}
+
+        def fake_subprocess_run(cmd, check=True):
+            called["cmd"] = cmd
+            return MagicMock(returncode=0)
+
+        monkeypatch.setattr("clonebox.container.subprocess.run", fake_subprocess_run)
+
+        c = ContainerCloner.__new__(ContainerCloner)
+        c.engine = "podman"
+        c.stop("c1")
+        assert called["cmd"] == ["podman", "stop", "c1"]
+
+    def test_rm_force_adds_f(self, monkeypatch):
+        called = {}
+
+        def fake_subprocess_run(cmd, check=True):
+            called["cmd"] = cmd
+            return MagicMock(returncode=0)
+
+        monkeypatch.setattr("clonebox.container.subprocess.run", fake_subprocess_run)
+
+        c = ContainerCloner.__new__(ContainerCloner)
+        c.engine = "docker"
+        c.rm("c1", force=True)
+        assert called["cmd"] == ["docker", "rm", "-f", "c1"]