clonebox 0.1.12__py3-none-any.whl → 0.1.14__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.12"
+__version__ = "0.1.13"
 __author__ = "CloneBox Team"
 
 from clonebox.cloner import SelectiveVMCloner

clonebox/cli.py

@@ -515,21 +515,47 @@ def cmd_open(args):
 
 def cmd_stop(args):
     """Stop a VM."""
+    name = args.name
+    
+    # If name is a path, load config
+    if name and (name.startswith(".") or name.startswith("/") or name.startswith("~")):
+        target_path = Path(name).expanduser().resolve()
+        config_file = target_path / ".clonebox.yaml" if target_path.is_dir() else target_path
+        if config_file.exists():
+            config = load_clonebox_config(config_file)
+            name = config["vm"]["name"]
+        else:
+            console.print(f"[red]❌ Config not found: {config_file}[/]")
+            return
+    
     cloner = SelectiveVMCloner(user_session=getattr(args, "user", False))
-    cloner.stop_vm(args.name, force=args.force, console=console)
+    cloner.stop_vm(name, force=args.force, console=console)
 
 
 def cmd_delete(args):
     """Delete a VM."""
+    name = args.name
+    
+    # If name is a path, load config
+    if name and (name.startswith(".") or name.startswith("/") or name.startswith("~")):
+        target_path = Path(name).expanduser().resolve()
+        config_file = target_path / ".clonebox.yaml" if target_path.is_dir() else target_path
+        if config_file.exists():
+            config = load_clonebox_config(config_file)
+            name = config["vm"]["name"]
+        else:
+            console.print(f"[red]❌ Config not found: {config_file}[/]")
+            return
+    
     if not args.yes:
         if not questionary.confirm(
-            f"Delete VM '{args.name}' and its storage?", default=False, style=custom_style
+            f"Delete VM '{name}' and its storage?", default=False, style=custom_style
         ).ask():
             console.print("[yellow]Cancelled.[/]")
             return
 
     cloner = SelectiveVMCloner(user_session=getattr(args, "user", False))
-    cloner.delete_vm(args.name, delete_storage=not args.keep_storage, console=console)
+    cloner.delete_vm(name, delete_storage=not args.keep_storage, console=console)
 
 
 def cmd_list(args):
@@ -646,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:
@@ -710,28 +839,49 @@ def cmd_export(args):
         else:
             console.print(f"[red]❌ Config not found: {config_file}[/]")
             return
-    
-    if not name:
+    elif not name or name == ".":
         config_file = Path.cwd() / ".clonebox.yaml"
         if config_file.exists():
             config = load_clonebox_config(config_file)
             name = config["vm"]["name"]
         else:
-            console.print("[red]❌ No VM name specified[/]")
+            console.print("[red]❌ No .clonebox.yaml found in current directory[/]")
+            console.print("[dim]Usage: clonebox export . or clonebox export <vm-name>[/]")
             return
     
     console.print(f"[bold cyan]📦 Exporting VM: {name}[/]\n")
     
-    # Determine storage path
-    if user_session:
-        storage_base = Path.home() / ".local/share/libvirt/images"
-    else:
-        storage_base = Path("/var/lib/libvirt/images")
-    
-    vm_dir = storage_base / name
-    
-    if not vm_dir.exists():
-        console.print(f"[red]❌ VM storage not found: {vm_dir}[/]")
+    # Get actual disk location from virsh
+    try:
+        result = subprocess.run(
+            ["virsh", "--connect", conn_uri, "domblklist", name, "--details"],
+            capture_output=True, text=True, timeout=10
+        )
+        if result.returncode != 0:
+            console.print(f"[red]❌ VM '{name}' not found[/]")
+            return
+        
+        # Parse disk paths from output
+        disk_path = None
+        cloudinit_path = None
+        for line in result.stdout.split('\n'):
+            if 'disk' in line and '.qcow2' in line:
+                parts = line.split()
+                if len(parts) >= 4:
+                    disk_path = Path(parts[3])
+            elif 'cdrom' in line or '.iso' in line:
+                parts = line.split()
+                if len(parts) >= 4:
+                    cloudinit_path = Path(parts[3])
+        
+        if not disk_path or not disk_path.exists():
+            console.print(f"[red]❌ VM disk not found[/]")
+            return
+            
+        console.print(f"[dim]Disk location: {disk_path}[/]")
+        
+    except Exception as e:
+        console.print(f"[red]❌ Error getting VM disk: {e}[/]")
         return
     
     # Create export directory
@@ -771,14 +921,16 @@ def cmd_export(args):
         
         # Copy disk image
         console.print("[cyan]Copying disk image (this may take a while)...[/]")
-        disk_image = vm_dir / f"{name}.qcow2"
-        if disk_image.exists():
-            shutil.copy2(disk_image, temp_dir / "disk.qcow2")
+        if disk_path and disk_path.exists():
+            shutil.copy2(disk_path, temp_dir / "disk.qcow2")
+            console.print(f"[green]✅ Disk copied: {disk_path.stat().st_size / (1024**3):.2f} GB[/]")
+        else:
+            console.print("[yellow]⚠️  Disk image not found[/]")
         
         # Copy cloud-init ISO
-        cloudinit_iso = vm_dir / "cloud-init.iso"
-        if cloudinit_iso.exists():
-            shutil.copy2(cloudinit_iso, temp_dir / "cloud-init.iso")
+        if cloudinit_path and cloudinit_path.exists():
+            shutil.copy2(cloudinit_path, temp_dir / "cloud-init.iso")
+            console.print("[green]✅ Cloud-init ISO copied[/]")
         
         # Copy config file
         config_file = Path.cwd() / ".clonebox.yaml"
@@ -993,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
@@ -1827,7 +1981,7 @@ def main():
 
     # Stop command
     stop_parser = subparsers.add_parser("stop", help="Stop a VM")
-    stop_parser.add_argument("name", help="VM name")
+    stop_parser.add_argument("name", nargs="?", default=None, help="VM name or '.' to use .clonebox.yaml")
     stop_parser.add_argument("--force", "-f", action="store_true", help="Force stop")
     stop_parser.add_argument(
         "-u",
@@ -1839,7 +1993,7 @@ def main():
 
     # Delete command
     delete_parser = subparsers.add_parser("delete", help="Delete a VM")
-    delete_parser.add_argument("name", help="VM name")
+    delete_parser.add_argument("name", nargs="?", default=None, help="VM name or '.' to use .clonebox.yaml")
     delete_parser.add_argument("--yes", "-y", action="store_true", help="Skip confirmation")
     delete_parser.add_argument("--keep-storage", action="store_true", help="Keep disk images")
     delete_parser.add_argument(

clonebox/cloner.py

@@ -666,12 +666,16 @@ fi
         for idx, (host_path, guest_path) in enumerate(config.paths.items()):
             if Path(host_path).exists():
                 tag = f"mount{idx}"
+                # Use uid=1000,gid=1000 to give ubuntu user access to mounts
+                # mmap allows proper file mapping
+                mount_opts = "trans=virtio,version=9p2000.L,mmap,uid=1000,gid=1000"
                 mount_commands.append(f"  - mkdir -p {guest_path}")
+                mount_commands.append(f"  - chown 1000:1000 {guest_path}")
                 mount_commands.append(
-                    f"  - mount -t 9p -o trans=virtio,version=9p2000.L {tag} {guest_path} || true"
+                    f"  - mount -t 9p -o {mount_opts} {tag} {guest_path} || true"
                 )
                 # Add fstab entry for persistence after reboot
-                fstab_entries.append(f"{tag} {guest_path} 9p trans=virtio,version=9p2000.L,nofail 0 0")
+                fstab_entries.append(f"{tag} {guest_path} 9p {mount_opts},nofail 0 0")
 
         # User-data
         # Add desktop environment if GUI is enabled

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.12.dist-info → clonebox-0.1.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clonebox
-Version: 0.1.12
+Version: 0.1.14
 Summary: Clone your workstation environment to an isolated VM with selective apps, paths and services
 Author: CloneBox Team
 License: Apache-2.0
@@ -235,6 +235,9 @@ clonebox open . --user
 
 # 6. Stop VM when done
 clonebox stop . --user
+
+# 7. Delete VM if needed
+clonebox delete . --user --yes
 ```
 
 ### Development Environment with Browser Profiles
@@ -273,24 +276,33 @@ clonebox test . --user --verbose
 # ✅ Health check triggered
 ```
 
-### 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
@@ -578,15 +590,17 @@ clonebox clone . --network auto
 | `clonebox start .` | Start VM from `.clonebox.yaml` in current dir |
 | `clonebox start . --viewer` | Start VM and open GUI window |
 | `clonebox start <name>` | Start existing VM by name |
-| `clonebox stop <name>` | Stop a VM (graceful shutdown) |
-| `clonebox stop -f <name>` | Force stop a VM |
-| `clonebox delete <name>` | Delete VM and storage |
+| `clonebox stop .` | Stop VM from `.clonebox.yaml` in current dir |
+| `clonebox stop . -f` | Force stop VM |
+| `clonebox delete .` | Delete VM from `.clonebox.yaml` in current dir |
+| `clonebox delete . --yes` | Delete VM without confirmation |
 | `clonebox list` | List all VMs |
 | `clonebox detect` | Show detected services/apps/paths |
 | `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 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 and validate all settings |
 | `clonebox export . --user` | Export VM for migration to another workstation |
 | `clonebox export . --user --include-data` | Export VM with browser profiles and configs |
@@ -665,22 +679,57 @@ sudo apt install virt-viewer
 virt-viewer --connect qemu:///session <vm-name>
 ```
 
-### Browser Profiles Not Syncing
+### Browser Profiles and PyCharm Not Working
 
-If browser profiles or app data aren't available:
+If browser profiles or PyCharm configs aren't available, or you get permission errors:
 
-1. **Regenerate config with app data:**
-   ```bash
-   rm .clonebox.yaml
-   clonebox clone . --user --run --replace
-   ```
+**Root cause:** VM was created with old version without proper mount permissions.
 
-2. **Check mount permissions in VM:**
-   ```bash
-   # Verify mounts are accessible
-   ls -la ~/.config/google-chrome
-   ls -la ~/.mozilla/firefox
-   ```
+**Solution - Rebuild VM with latest fixes:**
+
+```bash
+# Stop and delete old VM
+clonebox stop . --user
+clonebox delete . --user --yes
+
+# Recreate VM with fixed permissions and app data mounts
+clonebox clone . --user --run --replace
+```
+
+**After rebuild, verify mounts in VM:**
+```bash
+# Check all mounts are accessible
+ls ~/.config/google-chrome      # Chrome profile
+ls ~/.mozilla/firefox           # Firefox profile  
+ls ~/.config/JetBrains         # PyCharm settings
+ls ~/Downloads                 # Downloads folder
+ls ~/Documents                 # Documents folder
+```
+
+**What changed in v0.1.12:**
+- All mounts use `uid=1000,gid=1000` for ubuntu user access
+- Both `paths` and `app_data_paths` are properly mounted
+- No sudo needed to access any shared directories
+
+### Mount Points Empty or Permission Denied
+
+If you get "must be superuser to use mount" error when accessing Downloads/Documents:
+
+**Solution:** VM was created with old mount configuration. Recreate VM:
+
+```bash
+# Stop and delete old VM
+clonebox stop . --user
+clonebox delete . --user --yes
+
+# Recreate with fixed permissions
+clonebox clone . --user --run --replace
+```
+
+**What was fixed:**
+- Mounts now use `uid=1000,gid=1000` so ubuntu user has access
+- No need for sudo to access shared directories
+- Applies to new VMs created after v0.1.12
 
 ### Mount Points Empty After Reboot
 
@@ -698,7 +747,7 @@ If shared directories appear empty after VM restart:
 
 3. **Verify access mode:**
    - VMs created with `accessmode="mapped"` allow any user to access mounts
-   - Older VMs used `accessmode="passthrough"` which preserves host UIDs
+   - Mount options include `uid=1000,gid=1000` for user access
 
 ## Advanced Usage
 
@@ -761,6 +810,160 @@ virsh --connect qemu:///session console clone-clonebox
 # Press Ctrl + ] to exit console
 ```
 
+## Exporting to Proxmox
+
+To use CloneBox VMs in Proxmox, you need to convert the qcow2 disk image to Proxmox format.
+
+### Step 1: Locate VM Disk Image
+
+```bash
+# Find VM disk location
+clonebox list
+
+# Check VM details for disk path
+virsh --connect qemu:///session dominfo clone-clonebox
+
+# Typical locations:
+# User session: ~/.local/share/libvirt/images/<vm-name>/<vm-name>.qcow2
+# System session: /var/lib/libvirt/images/<vm-name>/<vm-name>.qcow2
+```
+
+### Step 2: Export VM with CloneBox
+
+```bash
+# Export VM with all data (from current directory with .clonebox.yaml)
+clonebox export . --user --include-data -o clonebox-vm.tar.gz
+
+# Or export specific VM by name
+clonebox export safetytwin-vm --include-data -o safetytwin.tar.gz
+
+# Extract to get the disk image
+tar -xzf clonebox-vm.tar.gz
+cd clonebox-clonebox
+ls -la  # Should show disk.qcow2, vm.xml, etc.
+```
+
+### Step 3: Convert to Proxmox Format
+
+```bash
+# Install qemu-utils if not installed
+sudo apt install qemu-utils
+
+# Convert qcow2 to raw format (Proxmox preferred)
+qemu-img convert -f qcow2 -O raw disk.qcow2 vm-disk.raw
+
+# Or convert to qcow2 with compression for smaller size
+qemu-img convert -f qcow2 -O qcow2 -c disk.qcow2 vm-disk-compressed.qcow2
+```
+
+### Step 4: Transfer to Proxmox Host
+
+```bash
+# Using scp (replace with your Proxmox host IP)
+scp vm-disk.raw root@proxmox:/var/lib/vz/template/iso/
+
+# Or using rsync for large files
+rsync -avh --progress vm-disk.raw root@proxmox:/var/lib/vz/template/iso/
+```
+
+### Step 5: Create VM in Proxmox
+
+1. **Log into Proxmox Web UI**
+
+2. **Create new VM:**
+   - Click "Create VM"
+   - Enter VM ID and Name
+   - Set OS: "Do not use any media"
+
+3. **Configure Hardware:**
+   - **Hard Disk:** 
+     - Delete default disk
+     - Click "Add" → "Hard Disk"
+     - Select your uploaded image file
+     - Set Disk size (can be larger than image)
+     - Set Bus: "VirtIO SCSI"
+     - Set Cache: "Write back" for better performance
+
+4. **CPU & Memory:**
+   - Set CPU cores (match original VM config)
+   - Set Memory (match original VM config)
+
+5. **Network:**
+   - Set Model: "VirtIO (paravirtualized)"
+
+6. **Confirm:** Click "Finish" to create VM
+
+### Step 6: Post-Import Configuration
+
+1. **Start the VM in Proxmox**
+
+2. **Update network configuration:**
+   ```bash
+   # In VM console, update network interfaces
+   sudo nano /etc/netplan/01-netcfg.yaml
+   
+   # Example for Proxmox bridge:
+   network:
+     version: 2
+     renderer: networkd
+     ethernets:
+       ens18:  # Proxmox typically uses ens18
+         dhcp4: true
+   ```
+
+3. **Apply network changes:**
+   ```bash
+   sudo netplan apply
+   ```
+
+4. **Update mount points (if needed):**
+   ```bash
+   # Mount points will fail in Proxmox, remove them
+   sudo nano /etc/fstab
+   # Comment out or remove 9p mount entries
+   
+   # Reboot to apply changes
+   sudo reboot
+   ```
+
+### Alternative: Direct Import to Proxmox Storage
+
+If you have Proxmox with shared storage:
+
+```bash
+# On Proxmox host
+# Create a temporary directory
+mkdir /tmp/import
+
+# Copy disk directly to Proxmox storage (example for local-lvm)
+scp vm-disk.raw root@proxmox:/tmp/import/
+
+# On Proxmox host, create VM using CLI
+qm create 9000 --name clonebox-vm --memory 4096 --cores 4 --net0 virtio,bridge=vmbr0
+
+# Import disk to VM
+qm importdisk 9000 /tmp/import/vm-disk.raw local-lvm
+
+# Attach disk to VM
+qm set 9000 --scsihw virtio-scsi-pci --scsi0 local-lvm:vm-9000-disk-0
+
+# Set boot disk
+qm set 9000 --boot c --bootdisk scsi0
+```
+
+### Troubleshooting
+
+- **VM won't boot:** Check if disk format is compatible (raw is safest)
+- **Network not working:** Update network configuration for Proxmox's NIC naming
+- **Performance issues:** Use VirtIO drivers and set cache to "Write back"
+- **Mount errors:** Remove 9p mount entries from /etc/fstab as they won't work in Proxmox
+
+### Notes
+
+- CloneBox's bind mounts (9p filesystem) are specific to libvirt/QEMU and won't work in Proxmox
+- Browser profiles and app data exported with `--include-data` will be available in the VM disk
+- For shared folders in Proxmox, use Proxmox's shared folders or network shares instead
+
 ## License
 
 MIT License - see [LICENSE](LICENSE) file.

clonebox-0.1.14.dist-info/RECORD

@@ -0,0 +1,12 @@
+clonebox/__init__.py,sha256=C1J7Uwrp8H9Zopo5JgrQYzXg-PWls1JdqmE_0Qp1Tro,408
+clonebox/__main__.py,sha256=Fcoyzwwyz5-eC_sBlQk5a5RbKx8uodQz5sKJ190U0NU,135
+clonebox/cli.py,sha256=IWTJjC5o3GPDZqQVnWNa8SHq1zKaK-fLGRASTehGe3Y,84733
+clonebox/cloner.py,sha256=fVfphsPbsqW4ASnv4bkrDIL8Ks9aPUvxx-IOO_d2FTw,32102
+clonebox/detector.py,sha256=4fu04Ty6KC82WkcJZ5UL5TqXpWYE7Kb7R0uJ-9dtbCk,21635
+clonebox/validator.py,sha256=8HV3ahfiLkFDOH4UOmZr7-fGfhKep1Jlw1joJeWSaQE,15858
+clonebox-0.1.14.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+clonebox-0.1.14.dist-info/METADATA,sha256=RGcUEs9xELSw6zii3s6qGqoYsiaOQNVo-CB5xK9N7Vw,30824
+clonebox-0.1.14.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+clonebox-0.1.14.dist-info/entry_points.txt,sha256=FES95Vi3btfViLEEoHdb8nikNxTqzaooi9ehZw9ZfWI,47
+clonebox-0.1.14.dist-info/top_level.txt,sha256=LdMo2cvCrEcRGH2M8JgQNVsCoszLV0xug6kx1JnaRjo,9
+clonebox-0.1.14.dist-info/RECORD,,

clonebox-0.1.12.dist-info/RECORD

@@ -1,11 +0,0 @@
-clonebox/__init__.py,sha256=J9nobWleYOk3tqbPsL6g-f_F7B3LwJTjFtnQ6qwmi8Y,408
-clonebox/__main__.py,sha256=Fcoyzwwyz5-eC_sBlQk5a5RbKx8uodQz5sKJ190U0NU,135
-clonebox/cli.py,sha256=NFScoojeI1XJ982SuNt01iW52hHIYSttGy2UzZuJCCQ,76413
-clonebox/cloner.py,sha256=0puM04SzifccPfIVqc2CXFFcdNLWKpbiXXbBplrm9s8,31850
-clonebox/detector.py,sha256=4fu04Ty6KC82WkcJZ5UL5TqXpWYE7Kb7R0uJ-9dtbCk,21635
-clonebox-0.1.12.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-clonebox-0.1.12.dist-info/METADATA,sha256=SJiYq8FYnqDhVcwZ00GeOTGNeAMjoqw-_e5e9XgMePo,24526
-clonebox-0.1.12.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-clonebox-0.1.12.dist-info/entry_points.txt,sha256=FES95Vi3btfViLEEoHdb8nikNxTqzaooi9ehZw9ZfWI,47
-clonebox-0.1.12.dist-info/top_level.txt,sha256=LdMo2cvCrEcRGH2M8JgQNVsCoszLV0xug6kx1JnaRjo,9
-clonebox-0.1.12.dist-info/RECORD,,