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

clonebox/cli.py

@@ -672,6 +672,109 @@ def cmd_status(args):
     except Exception:
         console.print("[yellow]⏳ Cloud-init status: Unknown (QEMU agent may not be ready)[/]")
     
+    # Check mount status
+    console.print("\n[bold]💾 Checking mount status...[/]")
+    try:
+        # Load config to get expected mounts
+        config_file = Path.cwd() / ".clonebox.yaml"
+        if config_file.exists():
+            config = load_clonebox_config(config_file)
+            all_paths = config.get("paths", {}).copy()
+            all_paths.update(config.get("app_data_paths", {}))
+            
+            if all_paths:
+                # Check which mounts are active
+                result = subprocess.run(
+                    ["virsh", "--connect", conn_uri, "qemu-agent-command", name,
+                     '{"execute":"guest-exec","arguments":{"path":"/bin/sh","arg":["-c","mount | grep 9p"],"capture-output":true}}'],
+                    capture_output=True, text=True, timeout=10
+                )
+                
+                mount_table = Table(title="Mount Points", border_style="cyan", show_header=True)
+                mount_table.add_column("Guest Path", style="bold")
+                mount_table.add_column("Status", justify="center")
+                mount_table.add_column("Files", justify="right")
+                
+                mounted_paths = []
+                if result.returncode == 0 and "return" in result.stdout:
+                    # Parse guest-exec response for mount output
+                    import json
+                    try:
+                        resp = json.loads(result.stdout)
+                        if "return" in resp and "pid" in resp["return"]:
+                            # Get the output from guest-exec-status
+                            pid = resp["return"]["pid"]
+                            status_result = subprocess.run(
+                                ["virsh", "--connect", conn_uri, "qemu-agent-command", name,
+                                 f'{{"execute":"guest-exec-status","arguments":{{"pid":{pid}}}}}'],
+                                capture_output=True, text=True, timeout=5
+                            )
+                            if status_result.returncode == 0:
+                                status_resp = json.loads(status_result.stdout)
+                                if "return" in status_resp and "out-data" in status_resp["return"]:
+                                    import base64
+                                    mount_output = base64.b64decode(status_resp["return"]["out-data"]).decode()
+                                    mounted_paths = [line.split()[2] for line in mount_output.split('\n') if line.strip()]
+                    except:
+                        pass
+                
+                # Check each expected mount
+                working_mounts = 0
+                total_mounts = 0
+                for host_path, guest_path in all_paths.items():
+                    total_mounts += 1
+                    is_mounted = any(guest_path in mp for mp in mounted_paths)
+                    
+                    # Try to get file count
+                    file_count = "?"
+                    if is_mounted:
+                        try:
+                            count_result = subprocess.run(
+                                ["virsh", "--connect", conn_uri, "qemu-agent-command", name,
+                                 f'{{"execute":"guest-exec","arguments":{{"path":"/bin/sh","arg":["-c","ls -A {guest_path} 2>/dev/null | wc -l"],"capture-output":true}}}}'],
+                                capture_output=True, text=True, timeout=5
+                            )
+                            if count_result.returncode == 0:
+                                resp = json.loads(count_result.stdout)
+                                if "return" in resp and "pid" in resp["return"]:
+                                    pid = resp["return"]["pid"]
+                                    import time
+                                    time.sleep(0.5)
+                                    status_result = subprocess.run(
+                                        ["virsh", "--connect", conn_uri, "qemu-agent-command", name,
+                                         f'{{"execute":"guest-exec-status","arguments":{{"pid":{pid}}}}}'],
+                                        capture_output=True, text=True, timeout=5
+                                    )
+                                    if status_result.returncode == 0:
+                                        status_resp = json.loads(status_result.stdout)
+                                        if "return" in status_resp and "out-data" in status_resp["return"]:
+                                            file_count = base64.b64decode(status_resp["return"]["out-data"]).decode().strip()
+                        except:
+                            pass
+                    
+                    if is_mounted:
+                        status = "[green]✅ Mounted[/]"
+                        working_mounts += 1
+                    else:
+                        status = "[red]❌ Not mounted[/]"
+                    
+                    mount_table.add_row(guest_path, status, str(file_count))
+                
+                console.print(mount_table)
+                console.print(f"[dim]{working_mounts}/{total_mounts} mounts active[/]")
+                
+                if working_mounts < total_mounts:
+                    console.print("[yellow]⚠️  Some mounts are missing. Try remounting in VM:[/]")
+                    console.print("[dim]  sudo mount -a[/]")
+                    console.print("[dim]Or rebuild VM with: clonebox clone . --user --run --replace[/]")
+            else:
+                console.print("[dim]No mount points configured[/]")
+        else:
+            console.print("[dim]No .clonebox.yaml found - cannot check mounts[/]")
+    except Exception as e:
+        console.print(f"[yellow]⚠️  Cannot check mounts: {e}[/]")
+        console.print("[dim]QEMU guest agent may not be ready yet[/]")
+    
     # Check health status if available
     console.print("\n[bold]🏥 Health Check Status...[/]")
     try:
@@ -1042,11 +1145,13 @@ def cmd_test(args):
     """Test VM configuration and health."""
     import subprocess
     import json
+    from clonebox.validator import VMValidator
     
     name = args.name
     user_session = getattr(args, "user", False)
     quick = getattr(args, "quick", False)
     verbose = getattr(args, "verbose", False)
+    validate_all = getattr(args, "validate", False)
     conn_uri = "qemu:///session" if user_session else "qemu:///system"
     
     # If name is a path, load config
@@ -1242,11 +1347,24 @@ def cmd_test(args):
     
     console.print()
     
-    # Summary
-    console.print("[bold]Test Summary[/]")
-    console.print("VM configuration is valid and VM is accessible.")
-    console.print("\n[dim]For detailed health report, run in VM:[/]")
-    console.print("[dim]  cat /var/log/clonebox-health.log[/]")
+    # Run full validation if requested
+    if validate_all and state == "running":
+        validator = VMValidator(config, vm_name, conn_uri, console)
+        results = validator.validate_all()
+        
+        # Exit with error code if validations failed
+        if results["overall"] == "partial":
+            return 1
+    else:
+        # Summary
+        console.print("[bold]Test Summary[/]")
+        console.print("VM configuration is valid and VM is accessible.")
+        console.print("\n[dim]For full validation including packages, services, and mounts:[/]")
+        console.print("[dim]  clonebox test . --user --validate[/]")
+        console.print("\n[dim]For detailed health report, run in VM:[/]")
+        console.print("[dim]  cat /var/log/clonebox-health.log[/]")
+    
+    return 0
 
 
 CLONEBOX_CONFIG_FILE = ".clonebox.yaml"
@@ -1616,12 +1734,16 @@ def create_vm_from_config(
 def cmd_clone(args):
     """Generate clone config from path and optionally create VM."""
     target_path = Path(args.path).resolve()
+    dry_run = getattr(args, "dry_run", False)
 
     if not target_path.exists():
         console.print(f"[red]❌ Path does not exist: {target_path}[/]")
         return
 
-    console.print(f"[bold cyan]📦 Generating clone config for: {target_path}[/]\n")
+    if dry_run:
+        console.print(f"[bold cyan]🔍 DRY RUN - Analyzing: {target_path}[/]\n")
+    else:
+        console.print(f"[bold cyan]📦 Generating clone config for: {target_path}[/]\n")
 
     # Detect system state
     with Progress(
@@ -1646,6 +1768,25 @@ def cmd_clone(args):
         base_image=getattr(args, "base_image", None),
     )
 
+    # Dry run - show what would be created and exit
+    if dry_run:
+        config = yaml.safe_load(yaml_content)
+        console.print(Panel(
+            f"[bold]VM Name:[/] {config['vm']['name']}\n"
+            f"[bold]RAM:[/] {config['vm'].get('ram_mb', 4096)} MB\n"
+            f"[bold]vCPUs:[/] {config['vm'].get('vcpus', 4)}\n"
+            f"[bold]Network:[/] {config['vm'].get('network_mode', 'auto')}\n"
+            f"[bold]Paths:[/] {len(config.get('paths', {}))} mounts\n"
+            f"[bold]Packages:[/] {len(config.get('packages', []))} packages\n"
+            f"[bold]Services:[/] {len(config.get('services', []))} services",
+            title="[bold cyan]Would create VM[/]",
+            border_style="cyan",
+        ))
+        console.print("\n[dim]Config preview:[/]")
+        console.print(Panel(yaml_content, title="[bold].clonebox.yaml[/]", border_style="dim"))
+        console.print("\n[yellow]ℹ️  Dry run complete. No changes made.[/]")
+        return
+
     # Save config file
     config_file = (
         target_path / CLONEBOX_CONFIG_FILE
@@ -1953,6 +2094,11 @@ def main():
         action="store_true",
         help="If VM already exists, stop+undefine it and recreate (also deletes its storage)",
     )
+    clone_parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Show what would be created without making any changes",
+    )
     clone_parser.set_defaults(func=cmd_clone)
 
     # Status command - check VM health from workstation
@@ -2013,6 +2159,9 @@ def main():
     test_parser.add_argument(
         "--verbose", "-v", action="store_true", help="Verbose output"
     )
+    test_parser.add_argument(
+        "--validate", action="store_true", help="Run full validation (mounts, packages, services)"
+    )
     test_parser.set_defaults(func=cmd_test)
 
     args = parser.parse_args()

clonebox/models.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+"""
+Pydantic models for CloneBox configuration validation.
+"""
+
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, Field, field_validator, model_validator
+
+
+class VMSettings(BaseModel):
+    """VM-specific settings."""
+
+    name: str = Field(default="clonebox-vm", description="VM name")
+    ram_mb: int = Field(default=4096, ge=512, le=131072, description="RAM in MB")
+    vcpus: int = Field(default=4, ge=1, le=128, description="Number of vCPUs")
+    disk_size_gb: int = Field(default=10, ge=1, le=2048, description="Disk size in GB")
+    gui: bool = Field(default=True, description="Enable SPICE graphics")
+    base_image: Optional[str] = Field(default=None, description="Path to base qcow2 image")
+    network_mode: str = Field(default="auto", description="Network mode: auto|default|user")
+    username: str = Field(default="ubuntu", description="VM default username")
+    password: str = Field(default="ubuntu", description="VM default password")
+
+    @field_validator("name")
+    @classmethod
+    def name_must_be_valid(cls, v: str) -> str:
+        if not v or not v.strip():
+            raise ValueError("VM name cannot be empty")
+        if len(v) > 64:
+            raise ValueError("VM name must be <= 64 characters")
+        return v.strip()
+
+    @field_validator("network_mode")
+    @classmethod
+    def network_mode_must_be_valid(cls, v: str) -> str:
+        valid_modes = {"auto", "default", "user"}
+        if v not in valid_modes:
+            raise ValueError(f"network_mode must be one of: {valid_modes}")
+        return v
+
+
+class CloneBoxConfig(BaseModel):
+    """Complete CloneBox configuration with validation."""
+
+    version: str = Field(default="1", description="Config version")
+    generated: Optional[str] = Field(default=None, description="Generation timestamp")
+    vm: VMSettings = Field(default_factory=VMSettings, description="VM settings")
+    paths: Dict[str, str] = Field(default_factory=dict, description="Host:Guest path mappings")
+    app_data_paths: Dict[str, str] = Field(
+        default_factory=dict, description="Application data paths"
+    )
+    packages: List[str] = Field(default_factory=list, description="APT packages to install")
+    snap_packages: List[str] = Field(default_factory=list, description="Snap packages to install")
+    services: List[str] = Field(default_factory=list, description="Services to enable")
+    post_commands: List[str] = Field(default_factory=list, description="Post-setup commands")
+    detected: Optional[Dict[str, Any]] = Field(
+        default=None, description="Auto-detected system info"
+    )
+
+    @field_validator("paths", "app_data_paths")
+    @classmethod
+    def paths_must_be_absolute(cls, v: Dict[str, str]) -> Dict[str, str]:
+        for host_path, guest_path in v.items():
+            if not host_path.startswith("/"):
+                raise ValueError(f"Host path must be absolute: {host_path}")
+            if not guest_path.startswith("/"):
+                raise ValueError(f"Guest path must be absolute: {guest_path}")
+        return v
+
+    @model_validator(mode="before")
+    @classmethod
+    def handle_nested_vm(cls, data: Any) -> Any:
+        """Handle both dict and nested vm structures."""
+        if isinstance(data, dict):
+            if "vm" in data and isinstance(data["vm"], dict):
+                return data
+            vm_fields = {"name", "ram_mb", "vcpus", "disk_size_gb", "gui", "base_image", 
+                        "network_mode", "username", "password"}
+            vm_data = {k: v for k, v in data.items() if k in vm_fields}
+            if vm_data:
+                data = {k: v for k, v in data.items() if k not in vm_fields}
+                data["vm"] = vm_data
+        return data
+
+    def save(self, path: Path) -> None:
+        """Save configuration to YAML file."""
+        import yaml
+
+        config_dict = self.model_dump(exclude_none=True)
+        path.write_text(yaml.dump(config_dict, default_flow_style=False, sort_keys=False))
+
+    @classmethod
+    def load(cls, path: Path) -> "CloneBoxConfig":
+        """Load configuration from YAML file."""
+        import yaml
+
+        if path.is_dir():
+            path = path / ".clonebox.yaml"
+        if not path.exists():
+            raise FileNotFoundError(f"Config file not found: {path}")
+        data = yaml.safe_load(path.read_text())
+        return cls.model_validate(data)
+
+    def to_vm_config(self) -> "VMConfigDataclass":
+        """Convert to legacy VMConfig dataclass for compatibility."""
+        from clonebox.cloner import VMConfig as VMConfigDataclass
+
+        return VMConfigDataclass(
+            name=self.vm.name,
+            ram_mb=self.vm.ram_mb,
+            vcpus=self.vm.vcpus,
+            disk_size_gb=self.vm.disk_size_gb,
+            gui=self.vm.gui,
+            base_image=self.vm.base_image,
+            paths=self.paths,
+            packages=self.packages,
+            snap_packages=self.snap_packages,
+            services=self.services,
+            post_commands=self.post_commands,
+            network_mode=self.vm.network_mode,
+            username=self.vm.username,
+            password=self.vm.password,
+        )
+
+
+# Backwards compatibility alias
+VMConfigModel = CloneBoxConfig

clonebox/validator.py

@@ -0,0 +1,374 @@
+"""
+VM validation module - validates VM state against YAML configuration.
+"""
+import subprocess
+import json
+import base64
+import time
+from typing import Dict, List, Tuple, Optional
+from pathlib import Path
+from rich.console import Console
+from rich.table import Table
+
+
+class VMValidator:
+    """Validates VM configuration against expected state from YAML."""
+    
+    def __init__(self, config: dict, vm_name: str, conn_uri: str, console: Console = None):
+        self.config = config
+        self.vm_name = vm_name
+        self.conn_uri = conn_uri
+        self.console = console or Console()
+        self.results = {
+            "mounts": {"passed": 0, "failed": 0, "total": 0, "details": []},
+            "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": []},
+            "overall": "unknown"
+        }
+    
+    def _exec_in_vm(self, command: str, timeout: int = 10) -> Optional[str]:
+        """Execute command in VM using QEMU guest agent."""
+        try:
+            # Execute command
+            result = subprocess.run(
+                ["virsh", "--connect", self.conn_uri, "qemu-agent-command", self.vm_name,
+                 f'{{"execute":"guest-exec","arguments":{{"path":"/bin/sh","arg":["-c","{command}"],"capture-output":true}}}}'],
+                capture_output=True, text=True, timeout=timeout
+            )
+            
+            if result.returncode != 0:
+                return None
+            
+            response = json.loads(result.stdout)
+            if "return" not in response or "pid" not in response["return"]:
+                return None
+            
+            pid = response["return"]["pid"]
+            
+            # Wait a bit for command to complete
+            time.sleep(0.3)
+            
+            # Get result
+            status_result = subprocess.run(
+                ["virsh", "--connect", self.conn_uri, "qemu-agent-command", self.vm_name,
+                 f'{{"execute":"guest-exec-status","arguments":{{"pid":{pid}}}}}'],
+                capture_output=True, text=True, timeout=5
+            )
+            
+            if status_result.returncode != 0:
+                return None
+            
+            status_resp = json.loads(status_result.stdout)
+            if "return" not in status_resp:
+                return None
+            
+            ret = status_resp["return"]
+            if not ret.get("exited", False):
+                return None
+            
+            if "out-data" in ret:
+                return base64.b64decode(ret["out-data"]).decode().strip()
+            
+            return ""
+            
+        except Exception:
+            return None
+    
+    def validate_mounts(self) -> Dict:
+        """Validate all mount points are accessible and contain data."""
+        self.console.print("\n[bold]💾 Validating Mount Points...[/]")
+        
+        all_paths = self.config.get("paths", {}).copy()
+        all_paths.update(self.config.get("app_data_paths", {}))
+        
+        if not all_paths:
+            self.console.print("[dim]No mount points configured[/]")
+            return self.results["mounts"]
+        
+        # Get mounted filesystems
+        mount_output = self._exec_in_vm("mount | grep 9p")
+        mounted_paths = []
+        if mount_output:
+            mounted_paths = [line.split()[2] for line in mount_output.split('\n') if line.strip()]
+        
+        mount_table = Table(title="Mount Validation", border_style="cyan")
+        mount_table.add_column("Guest Path", style="bold")
+        mount_table.add_column("Mounted", justify="center")
+        mount_table.add_column("Accessible", justify="center")
+        mount_table.add_column("Files", justify="right")
+        
+        for host_path, guest_path in all_paths.items():
+            self.results["mounts"]["total"] += 1
+            
+            # Check if mounted
+            is_mounted = any(guest_path in mp for mp in mounted_paths)
+            
+            # Check if accessible
+            accessible = False
+            file_count = "?"
+            
+            if is_mounted:
+                test_result = self._exec_in_vm(f"test -d {guest_path} && echo 'yes' || echo 'no'")
+                accessible = test_result == "yes"
+                
+                if accessible:
+                    # Get file count
+                    count_str = self._exec_in_vm(f"ls -A {guest_path} 2>/dev/null | wc -l")
+                    if count_str and count_str.isdigit():
+                        file_count = count_str
+            
+            # Determine status
+            if is_mounted and accessible:
+                mount_status = "[green]✅[/]"
+                access_status = "[green]✅[/]"
+                self.results["mounts"]["passed"] += 1
+                status = "pass"
+            elif is_mounted:
+                mount_status = "[green]✅[/]"
+                access_status = "[red]❌[/]"
+                self.results["mounts"]["failed"] += 1
+                status = "mounted_but_inaccessible"
+            else:
+                mount_status = "[red]❌[/]"
+                access_status = "[dim]N/A[/]"
+                self.results["mounts"]["failed"] += 1
+                status = "not_mounted"
+            
+            mount_table.add_row(guest_path, mount_status, access_status, str(file_count))
+            
+            self.results["mounts"]["details"].append({
+                "path": guest_path,
+                "mounted": is_mounted,
+                "accessible": accessible,
+                "files": file_count,
+                "status": status
+            })
+        
+        self.console.print(mount_table)
+        self.console.print(f"[dim]{self.results['mounts']['passed']}/{self.results['mounts']['total']} mounts working[/]")
+        
+        return self.results["mounts"]
+    
+    def validate_packages(self) -> Dict:
+        """Validate APT packages are installed."""
+        self.console.print("\n[bold]📦 Validating APT Packages...[/]")
+        
+        packages = self.config.get("packages", [])
+        if not packages:
+            self.console.print("[dim]No APT packages configured[/]")
+            return self.results["packages"]
+        
+        pkg_table = Table(title="Package Validation", border_style="cyan")
+        pkg_table.add_column("Package", style="bold")
+        pkg_table.add_column("Status", justify="center")
+        pkg_table.add_column("Version", style="dim")
+        
+        for package in packages:
+            self.results["packages"]["total"] += 1
+            
+            # Check if installed
+            check_cmd = f"dpkg -l | grep -E '^ii  {package}' | awk '{{print $3}}'"
+            version = self._exec_in_vm(check_cmd)
+            
+            if version:
+                pkg_table.add_row(package, "[green]✅ Installed[/]", version[:40])
+                self.results["packages"]["passed"] += 1
+                self.results["packages"]["details"].append({
+                    "package": package,
+                    "installed": True,
+                    "version": version
+                })
+            else:
+                pkg_table.add_row(package, "[red]❌ Missing[/]", "")
+                self.results["packages"]["failed"] += 1
+                self.results["packages"]["details"].append({
+                    "package": package,
+                    "installed": False,
+                    "version": None
+                })
+        
+        self.console.print(pkg_table)
+        self.console.print(f"[dim]{self.results['packages']['passed']}/{self.results['packages']['total']} packages installed[/]")
+        
+        return self.results["packages"]
+    
+    def validate_snap_packages(self) -> Dict:
+        """Validate snap packages are installed."""
+        self.console.print("\n[bold]📦 Validating Snap Packages...[/]")
+        
+        snap_packages = self.config.get("snap_packages", [])
+        if not snap_packages:
+            self.console.print("[dim]No snap packages configured[/]")
+            return self.results["snap_packages"]
+        
+        snap_table = Table(title="Snap Package Validation", border_style="cyan")
+        snap_table.add_column("Package", style="bold")
+        snap_table.add_column("Status", justify="center")
+        snap_table.add_column("Version", style="dim")
+        
+        for package in snap_packages:
+            self.results["snap_packages"]["total"] += 1
+            
+            # Check if installed
+            check_cmd = f"snap list | grep '^{package}' | awk '{{print $2}}'"
+            version = self._exec_in_vm(check_cmd)
+            
+            if version:
+                snap_table.add_row(package, "[green]✅ Installed[/]", version[:40])
+                self.results["snap_packages"]["passed"] += 1
+                self.results["snap_packages"]["details"].append({
+                    "package": package,
+                    "installed": True,
+                    "version": version
+                })
+            else:
+                snap_table.add_row(package, "[red]❌ Missing[/]", "")
+                self.results["snap_packages"]["failed"] += 1
+                self.results["snap_packages"]["details"].append({
+                    "package": package,
+                    "installed": False,
+                    "version": None
+                })
+        
+        self.console.print(snap_table)
+        self.console.print(f"[dim]{self.results['snap_packages']['passed']}/{self.results['snap_packages']['total']} snap packages installed[/]")
+        
+        return self.results["snap_packages"]
+    
+    def validate_services(self) -> Dict:
+        """Validate services are enabled and running."""
+        self.console.print("\n[bold]⚙️  Validating Services...[/]")
+        
+        services = self.config.get("services", [])
+        if not services:
+            self.console.print("[dim]No services configured[/]")
+            return self.results["services"]
+        
+        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")
+        
+        for service in services:
+            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
+            })
+        
+        self.console.print(svc_table)
+        self.console.print(f"[dim]{self.results['services']['passed']}/{self.results['services']['total']} services active[/]")
+        
+        return self.results["services"]
+    
+    def validate_all(self) -> Dict:
+        """Run all validations and return comprehensive results."""
+        self.console.print("[bold cyan]🔍 Running Full Validation...[/]")
+        
+        # Check if VM is running
+        try:
+            result = subprocess.run(
+                ["virsh", "--connect", self.conn_uri, "domstate", self.vm_name],
+                capture_output=True, text=True, timeout=5
+            )
+            vm_state = result.stdout.strip()
+            
+            if "running" not in vm_state.lower():
+                self.console.print(f"[yellow]⚠️  VM is not running (state: {vm_state})[/]")
+                self.console.print("[dim]Start VM with: clonebox start .[/]")
+                self.results["overall"] = "vm_not_running"
+                return self.results
+        except Exception as e:
+            self.console.print(f"[red]❌ Cannot check VM state: {e}[/]")
+            self.results["overall"] = "error"
+            return self.results
+        
+        # Run all validations
+        self.validate_mounts()
+        self.validate_packages()
+        self.validate_snap_packages()
+        self.validate_services()
+        
+        # Calculate overall status
+        total_checks = (
+            self.results["mounts"]["total"] +
+            self.results["packages"]["total"] +
+            self.results["snap_packages"]["total"] +
+            self.results["services"]["total"]
+        )
+        
+        total_passed = (
+            self.results["mounts"]["passed"] +
+            self.results["packages"]["passed"] +
+            self.results["snap_packages"]["passed"] +
+            self.results["services"]["passed"]
+        )
+        
+        total_failed = (
+            self.results["mounts"]["failed"] +
+            self.results["packages"]["failed"] +
+            self.results["snap_packages"]["failed"] +
+            self.results["services"]["failed"]
+        )
+        
+        # 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("Total", justify="right")
+        
+        summary_table.add_row("Mounts", str(self.results["mounts"]["passed"]), 
+                             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"]["total"]))
+        summary_table.add_row("Snap Packages", str(self.results["snap_packages"]["passed"]), 
+                             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(self.results["services"]["total"]))
+        summary_table.add_row("[bold]TOTAL", f"[bold green]{total_passed}", 
+                             f"[bold red]{total_failed}", f"[bold]{total_checks}")
+        
+        self.console.print(summary_table)
+        
+        # Determine overall status
+        if total_failed == 0 and total_checks > 0:
+            self.results["overall"] = "pass"
+            self.console.print("\n[bold green]✅ All validations passed![/]")
+        elif total_failed > 0:
+            self.results["overall"] = "partial"
+            self.console.print(f"\n[bold yellow]⚠️  {total_failed}/{total_checks} checks failed[/]")
+            self.console.print("[dim]Consider rebuilding VM: clonebox clone . --user --run --replace[/]")
+        else:
+            self.results["overall"] = "no_checks"
+            self.console.print("\n[dim]No validation checks configured[/]")
+        
+        return self.results

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clonebox
-Version: 0.1.13
+Version: 0.1.15
 Summary: Clone your workstation environment to an isolated VM with selective apps, paths and services
 Author: CloneBox Team
 License: Apache-2.0
@@ -30,14 +30,26 @@ Requires-Dist: rich>=13.0.0
 Requires-Dist: questionary>=2.0.0
 Requires-Dist: psutil>=5.9.0
 Requires-Dist: pyyaml>=6.0
+Requires-Dist: pydantic>=2.0.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
 Requires-Dist: black>=23.0.0; extra == "dev"
 Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+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"
 Dynamic: license-file
 
 # CloneBox 📦
+
+[![CI](https://github.com/wronai/clonebox/workflows/CI/badge.svg)](https://github.com/wronai/clonebox/actions)
+[![PyPI version](https://badge.fury.io/py/clonebox.svg)](https://pypi.org/project/clonebox/)
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+[![License](https://img.shields.io/badge/license-Apache%202.0-green.svg)](LICENSE)
+
 ![img.png](img.png)
 
 ```commandline
@@ -51,7 +63,8 @@ Dynamic: license-file
 ║      Clone your workstation to an isolated VM         ║
 ╚═══════════════════════════════════════════════════════╝
 ```
-**Clone your workstation environment to an isolated VM with selective apps, paths and services.**
+
+> **Clone your workstation environment to an isolated VM in 60 seconds using bind mounts instead of disk cloning.**
 
 CloneBox lets you create isolated virtual machines with only the applications, directories and services you need - using bind mounts instead of full disk cloning. Perfect for development, testing, or creating reproducible environments.
 
@@ -168,6 +181,61 @@ clonebox stop <name>         # Zatrzymaj VM
 clonebox delete <name>       # Usuń VM
 ```
 
+## Development and Testing
+
+### Running Tests
+
+CloneBox has comprehensive test coverage with unit tests and end-to-end tests:
+
+```bash
+# Run unit tests only (fast, no libvirt required)
+make test
+
+# Run fast unit tests (excludes slow tests)
+make test-unit
+
+# Run end-to-end tests (requires libvirt/KVM)
+make test-e2e
+
+# Run all tests including e2e
+make test-all
+
+# Run tests with coverage
+make test-cov
+
+# Run tests with verbose output
+make test-verbose
+```
+
+### Test Categories
+
+Tests are organized with pytest markers:
+
+- **Unit tests**: Fast tests that mock libvirt/system calls (default)
+- **E2E tests**: End-to-end tests requiring actual VM creation (marked with `@pytest.mark.e2e`)
+- **Slow tests**: Tests that take longer to run (marked with `@pytest.mark.slow`)
+
+E2E tests are automatically skipped when:
+- libvirt is not installed
+- `/dev/kvm` is not available
+- Running in CI environment (`CI=true` or `GITHUB_ACTIONS=true`)
+
+### Manual Test Execution
+
+```bash
+# Run only unit tests (exclude e2e)
+pytest tests/ -m "not e2e"
+
+# Run only e2e tests
+pytest tests/e2e/ -m "e2e" -v
+
+# Run specific test file
+pytest tests/test_cloner.py -v
+
+# Run with coverage
+pytest tests/ -m "not e2e" --cov=clonebox --cov-report=html
+```
+
 ## Quick Start
 
 ### Interactive Mode (Recommended)
@@ -258,42 +326,82 @@ ls ~/.mozilla/firefox       # Firefox profile
 ls ~/.config/JetBrains      # PyCharm settings
 ```
 
-### Testing VM Configuration
+### Testing and Validating VM Configuration
 
 ```bash
 # Quick test - basic checks
 clonebox test . --user --quick
 
-# Full test with verbose output
-clonebox test . --user --verbose
-
-# Test output shows:
-# ✅ VM is defined in libvirt
-# ✅ VM is running
-# ✅ VM has network access (IP: 192.168.122.89)
-# ✅ Cloud-init completed
-# ✅ All mount points accessible
-# ✅ Health check triggered
+# Full validation - checks EVERYTHING against YAML config
+clonebox test . --user --validate
+
+# Validation checks:
+# ✅ All mount points (paths + app_data_paths) are mounted and accessible
+# ✅ All APT packages are installed
+# ✅ All snap packages are installed
+# ✅ All services are enabled and running
+# ✅ Reports file counts for each mount
+# ✅ Shows package versions
+# ✅ Comprehensive summary table
+
+# Example output:
+# 💾 Validating Mount Points...
+# ┌─────────────────────────┬─────────┬────────────┬────────┐
+# │ Guest Path              │ Mounted │ Accessible │ Files  │
+# ├─────────────────────────┼─────────┼────────────┼────────┤
+# │ /home/ubuntu/Downloads  │ ✅      │ ✅         │ 199    │
+# │ ~/.config/JetBrains     │ ✅      │ ✅         │ 45     │
+# └─────────────────────────┴─────────┴────────────┴────────┘
+# 12/14 mounts working
+#
+# 📦 Validating APT Packages...
+# ┌─────────────────┬──────────────┬────────────┐
+# │ Package         │ Status       │ Version    │
+# ├─────────────────┼──────────────┼────────────┤
+# │ firefox         │ ✅ Installed │ 122.0+b... │
+# │ docker.io       │ ✅ Installed │ 24.0.7-... │
+# └─────────────────┴──────────────┴────────────┘
+# 8/8 packages installed
+#
+# 📊 Validation Summary
+# ┌────────────────┬────────┬────────┬───────┐
+# │ Category       │ Passed │ Failed │ Total │
+# ├────────────────┼────────┼────────┼───────┤
+# │ Mounts         │ 12     │ 2      │ 14    │
+# │ APT Packages   │ 8      │ 0      │ 8     │
+# │ Snap Packages  │ 2      │ 0      │ 2     │
+# │ Services       │ 5      │ 1      │ 6     │
+# │ TOTAL          │ 27     │ 3      │ 30    │
+# └────────────────┴────────┴────────┴───────┘
 ```
 
-### VM Health Monitoring
+### VM Health Monitoring and Mount Validation
 
 ```bash
-# Check overall status
+# Check overall status including mount validation
 clonebox status . --user
 
-# Output:
-# 📊 Checking VM status: clone-clonebox
-# ✅ VM State: running
-# ✅ VM has network access
-# ☁️ Cloud-init: Still running (packages installing)
-# 🏥 Health Check Status... ⏳ Health check not yet run
-
-# Trigger health check
+# Output shows:
+# 📊 VM State: running
+# 🔍 Network and IP address
+# ☁️ Cloud-init: Complete
+# 💾 Mount Points status table:
+#    ┌─────────────────────────┬──────────────┬────────┐
+#    │ Guest Path              │ Status       │ Files  │
+#    ├─────────────────────────┼──────────────┼────────┤
+#    │ /home/ubuntu/Downloads  │ ✅ Mounted   │ 199    │
+#    │ /home/ubuntu/Documents  │ ❌ Not mounted│ ?     │
+#    │ ~/.config/JetBrains     │ ✅ Mounted   │ 45     │
+#    └─────────────────────────┴──────────────┴────────┘
+#    12/14 mounts active
+# 🏥 Health Check Status: OK
+
+# Trigger full health check
 clonebox status . --user --health
 
-# View detailed health report in VM:
-# cat /var/log/clonebox-health.log
+# If mounts are missing, remount or rebuild:
+# In VM: sudo mount -a
+# Or rebuild: clonebox clone . --user --run --replace
 ```
 
 ### Export/Import Workflow
@@ -590,8 +698,10 @@ clonebox clone . --network auto
 | `clonebox detect --yaml` | Output as YAML config |
 | `clonebox detect --yaml --dedupe` | YAML with duplicates removed |
 | `clonebox detect --json` | Output as JSON |
-| `clonebox status . --user` | Check VM health, cloud-init status, and IP address |
-| `clonebox test . --user` | Test VM configuration and validate all settings |
+| `clonebox status . --user` | Check VM health, cloud-init, IP, and mount status |
+| `clonebox status . --user --health` | Check VM status and run full health check |
+| `clonebox test . --user` | Test VM configuration (basic checks) |
+| `clonebox test . --user --validate` | Full validation: mounts, packages, services vs YAML |
 | `clonebox export . --user` | Export VM for migration to another workstation |
 | `clonebox export . --user --include-data` | Export VM with browser profiles and configs |
 | `clonebox import archive.tar.gz --user` | Import VM from export archive |

clonebox-0.1.15.dist-info/RECORD

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

clonebox-0.1.13.dist-info/RECORD

@@ -1,11 +0,0 @@
-clonebox/__init__.py,sha256=C1J7Uwrp8H9Zopo5JgrQYzXg-PWls1JdqmE_0Qp1Tro,408
-clonebox/__main__.py,sha256=Fcoyzwwyz5-eC_sBlQk5a5RbKx8uodQz5sKJ190U0NU,135
-clonebox/cli.py,sha256=GWsBWL5i3DYVkwMuLja4pfXQAp5fgytr3MM5iJgtbdQ,78741
-clonebox/cloner.py,sha256=fVfphsPbsqW4ASnv4bkrDIL8Ks9aPUvxx-IOO_d2FTw,32102
-clonebox/detector.py,sha256=4fu04Ty6KC82WkcJZ5UL5TqXpWYE7Kb7R0uJ-9dtbCk,21635
-clonebox-0.1.13.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-clonebox-0.1.13.dist-info/METADATA,sha256=IvxQ3Zd2pwvgEQ-GXI5332ogfskiGoOoEZGrA0C2rGE,29927
-clonebox-0.1.13.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-clonebox-0.1.13.dist-info/entry_points.txt,sha256=FES95Vi3btfViLEEoHdb8nikNxTqzaooi9ehZw9ZfWI,47
-clonebox-0.1.13.dist-info/top_level.txt,sha256=LdMo2cvCrEcRGH2M8JgQNVsCoszLV0xug6kx1JnaRjo,9
-clonebox-0.1.13.dist-info/RECORD,,