clonebox 0.1.7__tar.gz → 0.1.9__tar.gz

{clonebox-0.1.7 → clonebox-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clonebox
-Version: 0.1.7
+Version: 0.1.9
 Summary: Clone your workstation environment to an isolated VM with selective apps, paths and services
 Author: CloneBox Team
 License: Apache-2.0

{clonebox-0.1.7 → clonebox-0.1.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "clonebox"
-version = "0.1.7"
+version = "0.1.9"
 description = "Clone your workstation environment to an isolated VM with selective apps, paths and services"
 readme = "README.md"
 license = {text = "Apache-2.0"}

{clonebox-0.1.7 → clonebox-0.1.9}/src/clonebox/cli.py

@@ -488,6 +488,442 @@ def cmd_list(args):
     console.print(table)
 
 
+def cmd_status(args):
+    """Check VM installation status and health from workstation."""
+    import subprocess
+    
+    name = args.name
+    user_session = getattr(args, "user", False)
+    conn_uri = "qemu:///session" if user_session else "qemu:///system"
+    
+    # If name is a path, load config to get VM name
+    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 name:
+        # Try current directory
+        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 and no .clonebox.yaml found[/]")
+            return
+    
+    console.print(f"[bold cyan]📊 Checking VM status: {name}[/]\n")
+    
+    # Check VM state
+    try:
+        result = subprocess.run(
+            ["virsh", "--connect", conn_uri, "domstate", name],
+            capture_output=True, text=True, timeout=5
+        )
+        vm_state = result.stdout.strip()
+        
+        if "running" in vm_state.lower():
+            console.print(f"[green]✅ VM State: {vm_state}[/]")
+        elif "shut off" in vm_state.lower():
+            console.print(f"[yellow]⏸️  VM State: {vm_state}[/]")
+            console.print("[dim]Start with: clonebox start .[/]")
+            return
+        else:
+            console.print(f"[dim]VM State: {vm_state}[/]")
+    except subprocess.TimeoutExpired:
+        console.print("[red]❌ Timeout checking VM state[/]")
+        return
+    except Exception as e:
+        console.print(f"[red]❌ Error: {e}[/]")
+        return
+    
+    # Get VM IP address
+    console.print("\n[bold]🔍 Checking VM network...[/]")
+    try:
+        result = subprocess.run(
+            ["virsh", "--connect", conn_uri, "domifaddr", name],
+            capture_output=True, text=True, timeout=10
+        )
+        if result.stdout.strip():
+            console.print(f"[dim]{result.stdout.strip()}[/]")
+            # Extract IP
+            for line in result.stdout.split('\n'):
+                if 'ipv4' in line.lower():
+                    parts = line.split()
+                    for p in parts:
+                        if '/' in p and '.' in p:
+                            ip = p.split('/')[0]
+                            console.print(f"[green]IP Address: {ip}[/]")
+                            break
+        else:
+            console.print("[yellow]⚠️  No IP address yet (VM may still be booting)[/]")
+    except Exception as e:
+        console.print(f"[yellow]⚠️  Cannot get IP: {e}[/]")
+    
+    # Check cloud-init status via console
+    console.print("\n[bold]☁️  Checking cloud-init status...[/]")
+    try:
+        # Use virsh console to check - this is tricky, so we check for the ready file
+        result = subprocess.run(
+            ["virsh", "--connect", conn_uri, "qemu-agent-command", name, 
+             '{"execute":"guest-exec","arguments":{"path":"/bin/cat","arg":["/var/log/clonebox-ready"],"capture-output":true}}'],
+            capture_output=True, text=True, timeout=10
+        )
+        if "CloneBox VM ready" in result.stdout or result.returncode == 0:
+            console.print("[green]✅ Cloud-init: Complete[/]")
+        else:
+            console.print("[yellow]⏳ Cloud-init: Still running (packages installing)[/]")
+    except Exception:
+        console.print("[yellow]⏳ Cloud-init status: Unknown (QEMU agent may not be ready)[/]")
+    
+    # Check health status if available
+    console.print("\n[bold]🏥 Health Check Status...[/]")
+    try:
+        result = subprocess.run(
+            ["virsh", "--connect", conn_uri, "qemu-agent-command", name,
+             '{"execute":"guest-exec","arguments":{"path":"/bin/cat","arg":["/var/log/clonebox-health-status"],"capture-output":true}}'],
+            capture_output=True, text=True, timeout=10
+        )
+        if "HEALTH_STATUS=OK" in result.stdout:
+            console.print("[green]✅ Health: All checks passed[/]")
+        elif "HEALTH_STATUS=FAILED" in result.stdout:
+            console.print("[red]❌ Health: Some checks failed[/]")
+        else:
+            console.print("[yellow]⏳ Health check not yet run[/]")
+    except Exception:
+        console.print("[dim]Health status: Not available yet[/]")
+    
+    # Show useful commands
+    console.print("\n[bold]📋 Useful commands:[/]")
+    console.print(f"  [cyan]virt-viewer --connect {conn_uri} {name}[/]  # Open GUI")
+    console.print(f"  [cyan]virsh --connect {conn_uri} console {name}[/]  # Console access")
+    console.print("  [dim]Inside VM:[/]")
+    console.print("    [cyan]cat /var/log/clonebox-health.log[/]  # Full health report")
+    console.print("    [cyan]sudo cloud-init status[/]  # Cloud-init status")
+    console.print("    [cyan]clonebox-health[/]  # Re-run health check")
+    
+    # Run full health check if requested
+    if getattr(args, "health", False):
+        console.print("\n[bold]🔄 Running full health check...[/]")
+        try:
+            result = subprocess.run(
+                ["virsh", "--connect", conn_uri, "qemu-agent-command", name,
+                 '{"execute":"guest-exec","arguments":{"path":"/usr/local/bin/clonebox-health","capture-output":true}}'],
+                capture_output=True, text=True, timeout=60
+            )
+            console.print("[green]Health check triggered. View results with:[/]")
+            console.print(f"  [cyan]virsh --connect {conn_uri} console {name}[/]")
+            console.print("  Then run: [cyan]cat /var/log/clonebox-health.log[/]")
+        except Exception as e:
+            console.print(f"[yellow]⚠️  Could not trigger health check: {e}[/]")
+
+
+def cmd_export(args):
+    """Export VM and data for migration to another workstation."""
+    import subprocess
+    import tarfile
+    import shutil
+    
+    name = args.name
+    user_session = getattr(args, "user", False)
+    conn_uri = "qemu:///session" if user_session else "qemu:///system"
+    include_data = getattr(args, "include_data", False)
+    output = getattr(args, "output", None)
+    
+    # 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 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[/]")
+            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}[/]")
+        return
+    
+    # Create export directory
+    export_name = output or f"{name}-export.tar.gz"
+    if not export_name.endswith(".tar.gz"):
+        export_name += ".tar.gz"
+    
+    export_path = Path(export_name).resolve()
+    temp_dir = Path(f"/tmp/clonebox-export-{name}")
+    
+    try:
+        # Clean up temp dir if exists
+        if temp_dir.exists():
+            shutil.rmtree(temp_dir)
+        temp_dir.mkdir(parents=True)
+        
+        # Stop VM if running
+        console.print("[cyan]Stopping VM for export...[/]")
+        subprocess.run(
+            ["virsh", "--connect", conn_uri, "shutdown", name],
+            capture_output=True, timeout=30
+        )
+        import time
+        time.sleep(5)
+        subprocess.run(
+            ["virsh", "--connect", conn_uri, "destroy", name],
+            capture_output=True, timeout=10
+        )
+        
+        # Export VM XML
+        console.print("[cyan]Exporting VM definition...[/]")
+        result = subprocess.run(
+            ["virsh", "--connect", conn_uri, "dumpxml", name],
+            capture_output=True, text=True, timeout=30
+        )
+        (temp_dir / "vm.xml").write_text(result.stdout)
+        
+        # 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")
+        
+        # Copy cloud-init ISO
+        cloudinit_iso = vm_dir / "cloud-init.iso"
+        if cloudinit_iso.exists():
+            shutil.copy2(cloudinit_iso, temp_dir / "cloud-init.iso")
+        
+        # Copy config file
+        config_file = Path.cwd() / ".clonebox.yaml"
+        if config_file.exists():
+            shutil.copy2(config_file, temp_dir / ".clonebox.yaml")
+        
+        # Copy .env file (without sensitive data warning)
+        env_file = Path.cwd() / ".env"
+        if env_file.exists():
+            shutil.copy2(env_file, temp_dir / ".env")
+        
+        # Include shared data if requested
+        if include_data:
+            console.print("[cyan]Bundling shared data (browser profiles, configs)...[/]")
+            data_dir = temp_dir / "data"
+            data_dir.mkdir()
+            
+            # Load config to get paths
+            if config_file.exists():
+                config = load_clonebox_config(config_file)
+                all_paths = config.get("paths", {}).copy()
+                all_paths.update(config.get("app_data_paths", {}))
+                
+                for idx, (host_path, guest_path) in enumerate(all_paths.items()):
+                    host_p = Path(host_path)
+                    if host_p.exists():
+                        dest = data_dir / f"mount{idx}"
+                        console.print(f"  [dim]Copying {host_path}...[/]")
+                        try:
+                            if host_p.is_dir():
+                                shutil.copytree(host_p, dest, symlinks=True, 
+                                              ignore=shutil.ignore_patterns('*.pyc', '__pycache__', '.git'))
+                            else:
+                                shutil.copy2(host_p, dest)
+                        except Exception as e:
+                            console.print(f"  [yellow]⚠️  Skipped {host_path}: {e}[/]")
+                
+                # Save path mapping
+                import json
+                (data_dir / "paths.json").write_text(json.dumps(all_paths, indent=2))
+        
+        # Create tarball
+        console.print(f"[cyan]Creating archive: {export_path}[/]")
+        with tarfile.open(export_path, "w:gz") as tar:
+            tar.add(temp_dir, arcname=name)
+        
+        # Get size
+        size_mb = export_path.stat().st_size / 1024 / 1024
+        
+        console.print(f"\n[bold green]✅ Export complete![/]")
+        console.print(f"   File: [cyan]{export_path}[/]")
+        console.print(f"   Size: [cyan]{size_mb:.1f} MB[/]")
+        console.print(f"\n[bold]To import on another workstation:[/]")
+        console.print(f"   [cyan]clonebox import {export_path.name}[/]")
+        
+    finally:
+        # Cleanup
+        if temp_dir.exists():
+            shutil.rmtree(temp_dir)
+        
+        # Restart VM
+        console.print("\n[cyan]Restarting VM...[/]")
+        subprocess.run(
+            ["virsh", "--connect", conn_uri, "start", name],
+            capture_output=True, timeout=30
+        )
+
+
+def cmd_import(args):
+    """Import VM from export archive."""
+    import subprocess
+    import tarfile
+    import shutil
+    
+    archive_path = Path(args.archive).resolve()
+    user_session = getattr(args, "user", False)
+    conn_uri = "qemu:///session" if user_session else "qemu:///system"
+    
+    if not archive_path.exists():
+        console.print(f"[red]❌ Archive not found: {archive_path}[/]")
+        return
+    
+    console.print(f"[bold cyan]📥 Importing VM from: {archive_path}[/]\n")
+    
+    # Determine storage path
+    if user_session:
+        storage_base = Path.home() / ".local/share/libvirt/images"
+    else:
+        storage_base = Path("/var/lib/libvirt/images")
+    
+    storage_base.mkdir(parents=True, exist_ok=True)
+    
+    temp_dir = Path(f"/tmp/clonebox-import-{archive_path.stem}")
+    
+    try:
+        # Extract archive
+        console.print("[cyan]Extracting archive...[/]")
+        if temp_dir.exists():
+            shutil.rmtree(temp_dir)
+        temp_dir.mkdir(parents=True)
+        
+        with tarfile.open(archive_path, "r:gz") as tar:
+            tar.extractall(temp_dir)
+        
+        # Find extracted VM directory
+        vm_dirs = list(temp_dir.iterdir())
+        if not vm_dirs:
+            console.print("[red]❌ Empty archive[/]")
+            return
+        
+        extracted_dir = vm_dirs[0]
+        vm_name = extracted_dir.name
+        
+        console.print(f"[cyan]VM Name: {vm_name}[/]")
+        
+        # Create VM storage directory
+        vm_storage = storage_base / vm_name
+        if vm_storage.exists():
+            if not getattr(args, "replace", False):
+                console.print(f"[red]❌ VM '{vm_name}' already exists. Use --replace to overwrite.[/]")
+                return
+            shutil.rmtree(vm_storage)
+        
+        vm_storage.mkdir(parents=True)
+        
+        # Copy disk image
+        console.print("[cyan]Copying disk image...[/]")
+        disk_src = extracted_dir / "disk.qcow2"
+        if disk_src.exists():
+            shutil.copy2(disk_src, vm_storage / f"{vm_name}.qcow2")
+        
+        # Copy cloud-init ISO
+        cloudinit_src = extracted_dir / "cloud-init.iso"
+        if cloudinit_src.exists():
+            shutil.copy2(cloudinit_src, vm_storage / "cloud-init.iso")
+        
+        # Copy config files to current directory
+        config_src = extracted_dir / ".clonebox.yaml"
+        if config_src.exists():
+            shutil.copy2(config_src, Path.cwd() / ".clonebox.yaml")
+            console.print("[green]✅ Copied .clonebox.yaml[/]")
+        
+        env_src = extracted_dir / ".env"
+        if env_src.exists():
+            shutil.copy2(env_src, Path.cwd() / ".env")
+            console.print("[green]✅ Copied .env[/]")
+        
+        # Restore data if included
+        data_dir = extracted_dir / "data"
+        if data_dir.exists():
+            import json
+            paths_file = data_dir / "paths.json"
+            if paths_file.exists():
+                paths_mapping = json.loads(paths_file.read_text())
+                console.print("\n[cyan]Restoring shared data...[/]")
+                
+                for idx, (host_path, guest_path) in enumerate(paths_mapping.items()):
+                    src = data_dir / f"mount{idx}"
+                    if src.exists():
+                        dest = Path(host_path)
+                        console.print(f"  [dim]Restoring to {host_path}...[/]")
+                        try:
+                            if dest.exists():
+                                console.print(f"    [yellow]⚠️  Skipped (already exists)[/]")
+                            else:
+                                dest.parent.mkdir(parents=True, exist_ok=True)
+                                if src.is_dir():
+                                    shutil.copytree(src, dest)
+                                else:
+                                    shutil.copy2(src, dest)
+                        except Exception as e:
+                            console.print(f"    [yellow]⚠️  Error: {e}[/]")
+        
+        # Modify and define VM XML
+        console.print("\n[cyan]Defining VM...[/]")
+        xml_src = extracted_dir / "vm.xml"
+        if xml_src.exists():
+            xml_content = xml_src.read_text()
+            
+            # Update paths in XML to new storage location
+            # This is a simple replacement - may need more sophisticated handling
+            xml_content = xml_content.replace(
+                f"/home/", f"{Path.home()}/"
+            )
+            
+            # Write modified XML
+            modified_xml = temp_dir / "vm-modified.xml"
+            modified_xml.write_text(xml_content)
+            
+            # Define VM
+            result = subprocess.run(
+                ["virsh", "--connect", conn_uri, "define", str(modified_xml)],
+                capture_output=True, text=True, timeout=30
+            )
+            
+            if result.returncode == 0:
+                console.print(f"[green]✅ VM '{vm_name}' defined successfully![/]")
+            else:
+                console.print(f"[yellow]⚠️  VM definition warning: {result.stderr}[/]")
+        
+        console.print(f"\n[bold green]✅ Import complete![/]")
+        console.print(f"\n[bold]To start the VM:[/]")
+        console.print(f"   [cyan]clonebox start . {'--user' if user_session else ''}[/]")
+        
+    finally:
+        # Cleanup
+        if temp_dir.exists():
+            shutil.rmtree(temp_dir)
+
+
 CLONEBOX_CONFIG_FILE = ".clonebox.yaml"
 CLONEBOX_ENV_FILE = ".env"
 
@@ -602,6 +1038,18 @@ def generate_clonebox_yaml(
         if host_folder.exists() and str(host_folder) not in paths_mapping:
             paths_mapping[str(host_folder)] = guest_folder
 
+    # Detect and add app-specific data directories for running applications
+    # This includes browser profiles, IDE settings, credentials, extensions, etc.
+    app_data_dirs = detector.detect_app_data_dirs(snapshot.applications)
+    app_data_mapping = {}
+    for app_data in app_data_dirs:
+        host_path = app_data["path"]
+        if host_path not in paths_mapping:
+            # Map to same relative path in VM user home
+            rel_path = host_path.replace(str(home_dir), "").lstrip("/")
+            guest_path = f"/home/ubuntu/{rel_path}"
+            app_data_mapping[host_path] = guest_path
+
     # Determine VM name
     if not vm_name:
         if target_path:
@@ -654,15 +1102,20 @@ def generate_clonebox_yaml(
         "snap_packages": all_snap_packages,
         "post_commands": [],  # User can add custom commands to run after setup
         "paths": paths_mapping,
+        "app_data_paths": app_data_mapping,  # App-specific config/data directories
         "detected": {
             "running_apps": [
-                {"name": a.name, "cwd": a.working_dir, "memory_mb": round(a.memory_mb)}
+                {"name": a.name, "cwd": a.working_dir or "", "memory_mb": round(a.memory_mb)}
                 for a in snapshot.applications[:10]
             ],
+            "app_data_dirs": [
+                {"path": d["path"], "app": d["app"], "size_mb": d["size_mb"]}
+                for d in app_data_dirs[:15]
+            ],
             "all_paths": {
-                "projects": paths_by_type["project"],
-                "configs": paths_by_type["config"][:5],
-                "data": paths_by_type["data"][:5],
+                "projects": list(paths_by_type["project"]),
+                "configs": list(paths_by_type["config"][:5]),
+                "data": list(paths_by_type["data"][:5]),
             },
         },
     }
@@ -692,7 +1145,7 @@ def load_clonebox_config(path: Path) -> dict:
     return config
 
 
-def monitor_cloud_init_status(vm_name: str, user_session: bool = False, timeout: int = 600):
+def monitor_cloud_init_status(vm_name: str, user_session: bool = False, timeout: int = 900):
     """Monitor cloud-init status in VM and show progress."""
     import subprocess
     import time
@@ -746,15 +1199,17 @@ def monitor_cloud_init_status(vm_name: str, user_session: bool = False, timeout:
                     time.sleep(2)
                     break
                 
-                # Estimate remaining time
+                # Estimate remaining time (total ~12-15 minutes for full desktop install)
                 if elapsed < 60:
-                    remaining = "~9-10 minutes"
-                elif elapsed < 180:
-                    remaining = f"~{8 - minutes} minutes"
+                    remaining = "~12-15 minutes"
                 elif elapsed < 300:
-                    remaining = f"~{6 - minutes} minutes"
+                    remaining = f"~{12 - minutes} minutes"
+                elif elapsed < 600:
+                    remaining = f"~{10 - minutes} minutes"
+                elif elapsed < 800:
+                    remaining = "finishing soon..."
                 else:
-                    remaining = "finishing soon"
+                    remaining = "almost done"
                 
                 if restart_detected:
                     progress.update(task, description=f"[cyan]Starting GUI... ({minutes}m {seconds}s, {remaining})")
@@ -781,13 +1236,17 @@ def create_vm_from_config(
     replace: bool = False,
 ) -> str:
     """Create VM from YAML config dict."""
+    # Merge paths and app_data_paths
+    all_paths = config.get("paths", {}).copy()
+    all_paths.update(config.get("app_data_paths", {}))
+    
     vm_config = VMConfig(
         name=config["vm"]["name"],
         ram_mb=config["vm"].get("ram_mb", 4096),
         vcpus=config["vm"].get("vcpus", 4),
         gui=config["vm"].get("gui", True),
         base_image=config["vm"].get("base_image"),
-        paths=config.get("paths", {}),
+        paths=all_paths,
         packages=config.get("packages", []),
         snap_packages=config.get("snap_packages", []),
         services=config.get("services", []),
@@ -915,16 +1374,27 @@ def cmd_clone(args):
                 password = config['vm'].get('password', 'ubuntu')
                 console.print("\n[bold yellow]⏰ GUI Setup Process:[/]")
                 console.print("  [yellow]•[/] Installing desktop environment (~5-10 minutes)")
+                console.print("  [yellow]•[/] Running health checks on all components")
                 console.print("  [yellow]•[/] Automatic restart after installation")
                 console.print("  [yellow]•[/] GUI login screen will appear")
                 console.print(f"  [yellow]•[/] Login: [cyan]{username}[/] / [cyan]{'*' * len(password)}[/] (from .env)")
                 console.print("\n[dim]💡 Progress will be monitored automatically below[/]")
 
+            # Show health check info
+            console.print("\n[bold]📊 Health Check (inside VM):[/]")
+            console.print("  [cyan]cat /var/log/clonebox-health.log[/]  # View full report")
+            console.print("  [cyan]cat /var/log/clonebox-health-status[/]  # Quick status")
+            console.print("  [cyan]clonebox-health[/]  # Re-run health check")
+
             # Show mount instructions
-            if config.get("paths"):
-                console.print("\n[bold]Inside VM, mount paths with:[/]")
-                for idx, (host, guest) in enumerate(config["paths"].items()):
-                    console.print(f"  [cyan]sudo mount -t 9p -o trans=virtio mount{idx} {guest}[/]")
+            all_paths = config.get("paths", {}).copy()
+            all_paths.update(config.get("app_data_paths", {}))
+            if all_paths:
+                console.print("\n[bold]📁 Mounted paths (automatic):[/]")
+                for idx, (host, guest) in enumerate(list(all_paths.items())[:5]):
+                    console.print(f"  [dim]{host}[/] → [cyan]{guest}[/]")
+                if len(all_paths) > 5:
+                    console.print(f"  [dim]... and {len(all_paths) - 5} more paths[/]")
         except PermissionError as e:
             console.print(f"[red]❌ Permission Error:[/]\n{e}")
             console.print("\n[yellow]💡 Try running with --user flag:[/]")
@@ -1146,6 +1616,50 @@ def main():
     )
     clone_parser.set_defaults(func=cmd_clone)
 
+    # Status command - check VM health from workstation
+    status_parser = subparsers.add_parser("status", help="Check VM installation status and health")
+    status_parser.add_argument(
+        "name", nargs="?", default=None, help="VM name or '.' to use .clonebox.yaml"
+    )
+    status_parser.add_argument(
+        "-u",
+        "--user",
+        action="store_true",
+        help="Use user session (qemu:///session)",
+    )
+    status_parser.add_argument(
+        "--health", "-H", action="store_true", help="Run full health check"
+    )
+    status_parser.set_defaults(func=cmd_status)
+
+    # Export command - package VM for migration
+    export_parser = subparsers.add_parser("export", help="Export VM and data for migration")
+    export_parser.add_argument(
+        "name", nargs="?", default=None, help="VM name or '.' to use .clonebox.yaml"
+    )
+    export_parser.add_argument(
+        "-u", "--user", action="store_true", help="Use user session (qemu:///session)"
+    )
+    export_parser.add_argument(
+        "-o", "--output", help="Output archive filename (default: <vmname>-export.tar.gz)"
+    )
+    export_parser.add_argument(
+        "--include-data", "-d", action="store_true",
+        help="Include shared data (browser profiles, configs) in export"
+    )
+    export_parser.set_defaults(func=cmd_export)
+
+    # Import command - restore VM from export
+    import_parser = subparsers.add_parser("import", help="Import VM from export archive")
+    import_parser.add_argument("archive", help="Path to export archive (.tar.gz)")
+    import_parser.add_argument(
+        "-u", "--user", action="store_true", help="Use user session (qemu:///session)"
+    )
+    import_parser.add_argument(
+        "--replace", action="store_true", help="Replace existing VM if exists"
+    )
+    import_parser.set_defaults(func=cmd_import)
+
     args = parser.parse_args()
 
     if hasattr(args, "func"):

{clonebox-0.1.7 → clonebox-0.1.9}/src/clonebox/cloner.py

@@ -476,6 +476,179 @@ class SelectiveVMCloner:
 
         return ET.tostring(root, encoding="unicode")
 
+    def _generate_health_check_script(self, config: VMConfig) -> str:
+        """Generate a health check script that validates all installed components."""
+        import base64
+        
+        # Build package check commands
+        apt_checks = []
+        for pkg in config.packages:
+            apt_checks.append(f'check_apt_package "{pkg}"')
+        
+        snap_checks = []
+        for pkg in config.snap_packages:
+            snap_checks.append(f'check_snap_package "{pkg}"')
+        
+        service_checks = []
+        for svc in config.services:
+            service_checks.append(f'check_service "{svc}"')
+        
+        mount_checks = []
+        for idx, (host_path, guest_path) in enumerate(config.paths.items()):
+            mount_checks.append(f'check_mount "{guest_path}" "mount{idx}"')
+        
+        apt_checks_str = "\n".join(apt_checks) if apt_checks else "echo 'No apt packages to check'"
+        snap_checks_str = "\n".join(snap_checks) if snap_checks else "echo 'No snap packages to check'"
+        service_checks_str = "\n".join(service_checks) if service_checks else "echo 'No services to check'"
+        mount_checks_str = "\n".join(mount_checks) if mount_checks else "echo 'No mounts to check'"
+        
+        script = f'''#!/bin/bash
+# CloneBox Health Check Script
+# Generated automatically - validates all installed components
+
+REPORT_FILE="/var/log/clonebox-health.log"
+PASSED=0
+FAILED=0
+WARNINGS=0
+
+# Colors for output
+RED='\\033[0;31m'
+GREEN='\\033[0;32m'
+YELLOW='\\033[1;33m'
+NC='\\033[0m'
+
+log() {{
+    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$REPORT_FILE"
+}}
+
+check_apt_package() {{
+    local pkg="$1"
+    if dpkg -l "$pkg" 2>/dev/null | grep -q "^ii"; then
+        log "[PASS] APT package '$pkg' is installed"
+        ((PASSED++))
+        return 0
+    else
+        log "[FAIL] APT package '$pkg' is NOT installed"
+        ((FAILED++))
+        return 1
+    fi
+}}
+
+check_snap_package() {{
+    local pkg="$1"
+    if snap list "$pkg" &>/dev/null; then
+        log "[PASS] Snap package '$pkg' is installed"
+        ((PASSED++))
+        return 0
+    else
+        log "[FAIL] Snap package '$pkg' is NOT installed"
+        ((FAILED++))
+        return 1
+    fi
+}}
+
+check_service() {{
+    local svc="$1"
+    if systemctl is-enabled "$svc" &>/dev/null; then
+        if systemctl is-active "$svc" &>/dev/null; then
+            log "[PASS] Service '$svc' is enabled and running"
+            ((PASSED++))
+            return 0
+        else
+            log "[WARN] Service '$svc' is enabled but not running"
+            ((WARNINGS++))
+            return 1
+        fi
+    else
+        log "[INFO] Service '$svc' is not enabled (may be optional)"
+        return 0
+    fi
+}}
+
+check_mount() {{
+    local path="$1"
+    local tag="$2"
+    if mountpoint -q "$path" 2>/dev/null; then
+        log "[PASS] Mount '$path' ($tag) is active"
+        ((PASSED++))
+        return 0
+    elif [ -d "$path" ]; then
+        log "[WARN] Directory '$path' exists but not mounted"
+        ((WARNINGS++))
+        return 1
+    else
+        log "[INFO] Mount point '$path' does not exist yet"
+        return 0
+    fi
+}}
+
+check_gui() {{
+    if systemctl get-default | grep -q graphical; then
+        log "[PASS] System configured for graphical target"
+        ((PASSED++))
+        if systemctl is-active gdm3 &>/dev/null || systemctl is-active gdm &>/dev/null; then
+            log "[PASS] Display manager (GDM) is running"
+            ((PASSED++))
+        else
+            log "[WARN] Display manager not yet running (may start after reboot)"
+            ((WARNINGS++))
+        fi
+    else
+        log "[INFO] System not configured for GUI"
+    fi
+}}
+
+# Start health check
+log "=========================================="
+log "CloneBox Health Check Report"
+log "VM Name: {config.name}"
+log "Date: $(date)"
+log "=========================================="
+
+log ""
+log "--- APT Packages ---"
+{apt_checks_str}
+
+log ""
+log "--- Snap Packages ---"
+{snap_checks_str}
+
+log ""
+log "--- Services ---"
+{service_checks_str}
+
+log ""
+log "--- Mounts ---"
+{mount_checks_str}
+
+log ""
+log "--- GUI Status ---"
+check_gui
+
+log ""
+log "=========================================="
+log "Health Check Summary"
+log "=========================================="
+log "Passed:   $PASSED"
+log "Failed:   $FAILED"
+log "Warnings: $WARNINGS"
+
+if [ $FAILED -eq 0 ]; then
+    log ""
+    log "[SUCCESS] All critical checks passed!"
+    echo "HEALTH_STATUS=OK" > /var/log/clonebox-health-status
+    exit 0
+else
+    log ""
+    log "[ERROR] Some checks failed. Review log for details."
+    echo "HEALTH_STATUS=FAILED" > /var/log/clonebox-health-status
+    exit 1
+fi
+'''
+        # Encode script to base64 for safe embedding in cloud-init
+        encoded = base64.b64encode(script.encode()).decode()
+        return encoded
+
     def _create_cloudinit_iso(self, vm_dir: Path, config: VMConfig) -> Path:
         """Create cloud-init ISO with user-data and meta-data."""
 
@@ -486,15 +659,18 @@ class SelectiveVMCloner:
         meta_data = f"instance-id: {config.name}\nlocal-hostname: {config.name}\n"
         (cloudinit_dir / "meta-data").write_text(meta_data)
 
-        # Generate mount commands for 9p filesystems
+        # Generate mount commands and fstab entries for 9p filesystems
         mount_commands = []
+        fstab_entries = []
         for idx, (host_path, guest_path) in enumerate(config.paths.items()):
             if Path(host_path).exists():
                 tag = f"mount{idx}"
                 mount_commands.append(f"  - mkdir -p {guest_path}")
                 mount_commands.append(
-                    f"  - mount -t 9p -o trans=virtio,version=9p2000.L {tag} {guest_path}"
+                    f"  - mount -t 9p -o trans=virtio,version=9p2000.L {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")
 
         # User-data
         # Add desktop environment if GUI is enabled
@@ -517,7 +693,13 @@ class SelectiveVMCloner:
         for svc in config.services:
             runcmd_lines.append(f"  - systemctl enable --now {svc} || true")
         
-        # Add mounts
+        # Add fstab entries for persistent mounts after reboot
+        if fstab_entries:
+            runcmd_lines.append("  - echo '# CloneBox 9p mounts' >> /etc/fstab")
+            for entry in fstab_entries:
+                runcmd_lines.append(f"  - echo '{entry}' >> /etc/fstab")
+        
+        # Add mounts (immediate, before reboot)
         for cmd in mount_commands:
             runcmd_lines.append(cmd)
         
@@ -540,16 +722,17 @@ class SelectiveVMCloner:
             for cmd in config.post_commands:
                 runcmd_lines.append(f"  - {cmd}")
         
-        # Validation - check installed packages and log results
-        runcmd_lines.append("  - echo '=== CloneBox Setup Validation ===' >> /var/log/clonebox-setup.log")
-        runcmd_lines.append("  - dpkg -l | grep -E 'ii' | wc -l >> /var/log/clonebox-setup.log")
-        runcmd_lines.append("  - snap list >> /var/log/clonebox-setup.log 2>/dev/null || true")
+        # Generate health check script
+        health_script = self._generate_health_check_script(config)
+        runcmd_lines.append(f"  - echo '{health_script}' | base64 -d > /usr/local/bin/clonebox-health")
+        runcmd_lines.append("  - chmod +x /usr/local/bin/clonebox-health")
+        runcmd_lines.append("  - /usr/local/bin/clonebox-health >> /var/log/clonebox-health.log 2>&1")
         runcmd_lines.append("  - echo 'CloneBox VM ready!' > /var/log/clonebox-ready")
-        runcmd_lines.append("  - echo 'Setup completed at:' $(date) >> /var/log/clonebox-setup.log")
         
         # Add reboot command at the end if GUI is enabled
         if config.gui:
-            runcmd_lines.append("  - shutdown -r +1 'Rebooting to start GUI' || reboot")
+            runcmd_lines.append("  - echo 'Rebooting in 10 seconds to start GUI...'")
+            runcmd_lines.append("  - sleep 10 && reboot")
         
         runcmd_yaml = "\n".join(runcmd_lines) if runcmd_lines else ""
 

{clonebox-0.1.7 → clonebox-0.1.9}/src/clonebox.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clonebox
-Version: 0.1.7
+Version: 0.1.9
 Summary: Clone your workstation environment to an isolated VM with selective apps, paths and services
 Author: CloneBox Team
 License: Apache-2.0

{clonebox-0.1.7 → clonebox-0.1.9}/tests/test_network.py

@@ -50,10 +50,16 @@ class TestNetworkMode:
     @patch("clonebox.cloner.libvirt")
     def test_resolve_network_mode_auto_user_no_default(self, mock_libvirt):
         """Test auto mode with user session and no default network falls back to user."""
-        import libvirt as real_libvirt
+        # Handle missing libvirt module in test environment
+        try:
+            import libvirt as real_libvirt
+            libvirt_error = real_libvirt.libvirtError
+        except ImportError:
+            class libvirt_error(Exception):
+                pass
 
         mock_conn = MagicMock()
-        mock_conn.networkLookupByName.side_effect = real_libvirt.libvirtError("No network")
+        mock_conn.networkLookupByName.side_effect = libvirt_error("No network")
         mock_libvirt.open.return_value = mock_conn
 
         cloner = SelectiveVMCloner(user_session=True)
@@ -126,10 +132,16 @@ class TestNetworkMode:
     @patch("clonebox.cloner.libvirt")
     def test_default_network_active_not_found(self, mock_libvirt):
         """Test _default_network_active returns False when network not found."""
-        import libvirt as real_libvirt
+        # Handle missing libvirt module in test environment
+        try:
+            import libvirt as real_libvirt
+            libvirt_error = real_libvirt.libvirtError
+        except ImportError:
+            class libvirt_error(Exception):
+                pass
 
         mock_conn = MagicMock()
-        mock_conn.networkLookupByName.side_effect = real_libvirt.libvirtError("Not found")
+        mock_conn.networkLookupByName.side_effect = libvirt_error("Not found")
         mock_libvirt.open.return_value = mock_conn
 
         cloner = SelectiveVMCloner()