clonebox 0.1.8__py3-none-any.whl → 0.1.10__py3-none-any.whl

clonebox/cli.py

@@ -445,7 +445,72 @@ def cmd_start(args):
             return
 
     cloner = SelectiveVMCloner(user_session=getattr(args, "user", False))
-    cloner.start_vm(name, open_viewer=not args.no_viewer, console=console)
+    open_viewer = getattr(args, "viewer", False) or not getattr(args, "no_viewer", False)
+    cloner.start_vm(name, open_viewer=open_viewer, console=console)
+
+
+def cmd_open(args):
+    """Open VM viewer window."""
+    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
+    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
+    elif name == "." or 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 and no .clonebox.yaml in current directory[/]")
+            console.print("[dim]Usage: clonebox open <vm-name> or clonebox open .[/]")
+            return
+    
+    # Check if VM is running
+    try:
+        result = subprocess.run(
+            ["virsh", "--connect", conn_uri, "domstate", name],
+            capture_output=True, text=True, timeout=10
+        )
+        state = result.stdout.strip()
+        
+        if state != "running":
+            console.print(f"[yellow]⚠️  VM '{name}' is not running (state: {state})[/]")
+            if questionary.confirm(
+                f"Start VM '{name}' and open viewer?", default=True, style=custom_style
+            ).ask():
+                cloner = SelectiveVMCloner(user_session=user_session)
+                cloner.start_vm(name, open_viewer=True, console=console)
+            else:
+                console.print("[dim]Use 'clonebox start' to start the VM first.[/]")
+            return
+    except Exception as e:
+        console.print(f"[red]❌ Error checking VM state: {e}[/]")
+        return
+    
+    # Open virt-viewer
+    console.print(f"[cyan]Opening viewer for VM: {name}[/]")
+    try:
+        subprocess.run(
+            ["virt-viewer", "--connect", conn_uri, name],
+            check=True
+        )
+    except FileNotFoundError:
+        console.print("[red]❌ virt-viewer not found[/]")
+        console.print("Install with: sudo apt install virt-viewer")
+    except subprocess.CalledProcessError as e:
+        console.print(f"[red]❌ Failed to open viewer: {e}[/]")
 
 
 def cmd_stop(args):
@@ -488,6 +553,653 @@ 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)
+
+
+def cmd_test(args):
+    """Test VM configuration and health."""
+    import subprocess
+    import json
+    
+    name = args.name
+    user_session = getattr(args, "user", False)
+    quick = getattr(args, "quick", False)
+    verbose = getattr(args, "verbose", False)
+    conn_uri = "qemu:///session" if user_session else "qemu:///system"
+    
+    # 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 not config_file.exists():
+            console.print(f"[red]❌ Config not found: {config_file}[/]")
+            return
+    else:
+        config_file = Path.cwd() / ".clonebox.yaml"
+        if not config_file.exists():
+            console.print("[red]❌ No .clonebox.yaml found in current directory[/]")
+            return
+    
+    console.print(f"[bold cyan]🧪 Testing VM configuration: {config_file}[/]\n")
+    
+    # Load config
+    try:
+        config = load_clonebox_config(config_file)
+        vm_name = config["vm"]["name"]
+        console.print(f"[green]✅ Config loaded successfully[/]")
+        console.print(f"   VM Name: {vm_name}")
+        console.print(f"   RAM: {config['vm']['ram_mb']}MB")
+        console.print(f"   vCPUs: {config['vm']['vcpus']}")
+        console.print(f"   GUI: {'Yes' if config['vm']['gui'] else 'No'}")
+    except Exception as e:
+        console.print(f"[red]❌ Failed to load config: {e}[/]")
+        return
+    
+    console.print()
+    
+    # Test 1: Check VM exists
+    console.print("[bold]1. VM Existence Check[/]")
+    try:
+        result = subprocess.run(
+            ["virsh", "--connect", conn_uri, "dominfo", vm_name],
+            capture_output=True, text=True, timeout=10
+        )
+        if result.returncode == 0:
+            console.print("[green]✅ VM is defined in libvirt[/]")
+            if verbose:
+                for line in result.stdout.split('\n'):
+                    if ':' in line:
+                        console.print(f"   {line}")
+        else:
+            console.print("[red]❌ VM not found in libvirt[/]")
+            console.print("   Run: clonebox create .clonebox.yaml --start")
+            return
+    except Exception as e:
+        console.print(f"[red]❌ Error checking VM: {e}[/]")
+        return
+    
+    console.print()
+    
+    # Test 2: Check VM state
+    console.print("[bold]2. VM State Check[/]")
+    try:
+        result = subprocess.run(
+            ["virsh", "--connect", conn_uri, "domstate", vm_name],
+            capture_output=True, text=True, timeout=10
+        )
+        state = result.stdout.strip()
+        if state == "running":
+            console.print("[green]✅ VM is running[/]")
+            
+            # Test network if running
+            console.print("\n   Checking network...")
+            try:
+                result = subprocess.run(
+                    ["virsh", "--connect", conn_uri, "domifaddr", vm_name],
+                    capture_output=True, text=True, timeout=10
+                )
+                if "192.168" in result.stdout or "10.0" in result.stdout:
+                    console.print("[green]✅ VM has network access[/]")
+                    if verbose:
+                        for line in result.stdout.split('\n'):
+                            if '192.168' in line or '10.0' in line:
+                                console.print(f"   IP: {line.split()[-1]}")
+                else:
+                    console.print("[yellow]⚠️  No IP address detected[/]")
+            except:
+                console.print("[yellow]⚠️  Could not check network[/]")
+        else:
+            console.print(f"[yellow]⚠️  VM is not running (state: {state})[/]")
+            console.print("   Run: clonebox start .")
+    except Exception as e:
+        console.print(f"[red]❌ Error checking VM state: {e}[/]")
+    
+    console.print()
+    
+    # Test 3: Check cloud-init status (if running)
+    if not quick and state == "running":
+        console.print("[bold]3. Cloud-init Status[/]")
+        try:
+            # Try to get cloud-init status via QEMU guest agent
+            result = subprocess.run(
+                ["virsh", "--connect", conn_uri, "qemu-agent-command", vm_name,
+                 '{"execute":"guest-exec","arguments":{"path":"cloud-init","arg":["status"],"capture-output":true}}'],
+                capture_output=True, text=True, timeout=15
+            )
+            if result.returncode == 0:
+                try:
+                    response = json.loads(result.stdout)
+                    if "return" in response:
+                        pid = response["return"]["pid"]
+                        # Get output
+                        result2 = subprocess.run(
+                            ["virsh", "--connect", conn_uri, "qemu-agent-command", vm_name,
+                             f'{{"execute":"guest-exec-status","arguments":{"pid":{pid}}}}'],
+                            capture_output=True, text=True, timeout=15
+                        )
+                        if result2.returncode == 0:
+                            resp2 = json.loads(result2.stdout)
+                            if "return" in resp2 and resp2["return"]["exited"]:
+                                output = resp2["return"]["out-data"]
+                                if output:
+                                    import base64
+                                    status = base64.b64decode(output).decode()
+                                    if "done" in status.lower():
+                                        console.print("[green]✅ Cloud-init completed[/]")
+                                    elif "running" in status.lower():
+                                        console.print("[yellow]⚠️  Cloud-init still running[/]")
+                                    else:
+                                        console.print(f"[yellow]⚠️  Cloud-init status: {status.strip()}[/]")
+                except:
+                    pass
+        except:
+            console.print("[yellow]⚠️  Could not check cloud-init (QEMU agent may not be running)[/]")
+    
+    console.print()
+    
+    # Test 4: Check mounts (if running)
+    if not quick and state == "running":
+        console.print("[bold]4. Mount Points Check[/]")
+        all_paths = config.get("paths", {}).copy()
+        all_paths.update(config.get("app_data_paths", {}))
+        
+        if all_paths:
+            for idx, (host_path, guest_path) in enumerate(all_paths.items()):
+                try:
+                    result = subprocess.run(
+                        ["virsh", "--connect", conn_uri, "qemu-agent-command", vm_name,
+                         f'{{"execute":"guest-exec","arguments":{{"path":"test","arg":["-d","{guest_path}"],"capture-output":true}}}}'],
+                        capture_output=True, text=True, timeout=10
+                    )
+                    if result.returncode == 0:
+                        try:
+                            response = json.loads(result.stdout)
+                            if "return" in response:
+                                pid = response["return"]["pid"]
+                                result2 = subprocess.run(
+                                    ["virsh", "--connect", conn_uri, "qemu-agent-command", vm_name,
+                                     f'{{"execute":"guest-exec-status","arguments":{"pid":{pid}}}}'],
+                                    capture_output=True, text=True, timeout=10
+                                )
+                                if result2.returncode == 0:
+                                    resp2 = json.loads(result2.stdout)
+                                    if "return" in resp2 and resp2["return"]["exited"]:
+                                        exit_code = resp2["return"]["exitcode"]
+                                        if exit_code == 0:
+                                            console.print(f"[green]✅ {guest_path}[/]")
+                                        else:
+                                            console.print(f"[red]❌ {guest_path} (not accessible)[/]")
+                                        continue
+                        except:
+                            pass
+                    console.print(f"[yellow]⚠️  {guest_path} (unknown)[/]")
+                except:
+                    console.print(f"[yellow]⚠️  {guest_path} (could not check)[/]")
+        else:
+            console.print("[dim]No mount points configured[/]")
+    
+    console.print()
+    
+    # Test 5: Run health check (if running and not quick)
+    if not quick and state == "running":
+        console.print("[bold]5. Health Check[/]")
+        try:
+            result = subprocess.run(
+                ["virsh", "--connect", conn_uri, "qemu-agent-command", vm_name,
+                 '{"execute":"guest-exec","arguments":{"path":"/usr/local/bin/clonebox-health","capture-output":true}}'],
+                capture_output=True, text=True, timeout=60
+            )
+            if result.returncode == 0:
+                console.print("[green]✅ Health check triggered[/]")
+                console.print("   View results in VM: cat /var/log/clonebox-health.log")
+            else:
+                console.print("[yellow]⚠️  Health check script not found[/]")
+                console.print("   VM may not have been created with health checks")
+        except Exception as e:
+            console.print(f"[yellow]⚠️  Could not run health check: {e}[/]")
+    
+    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[/]")
+
+
 CLONEBOX_CONFIG_FILE = ".clonebox.yaml"
 CLONEBOX_ENV_FILE = ".env"
 
@@ -709,7 +1421,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
@@ -763,15 +1475,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})")
@@ -1089,6 +1803,7 @@ def main():
         "name", nargs="?", default=None, help="VM name or '.' to use .clonebox.yaml"
     )
     start_parser.add_argument("--no-viewer", action="store_true", help="Don't open virt-viewer")
+    start_parser.add_argument("--viewer", action="store_true", help="Open virt-viewer GUI")
     start_parser.add_argument(
         "-u",
         "--user",
@@ -1097,6 +1812,19 @@ def main():
     )
     start_parser.set_defaults(func=cmd_start)
 
+    # Open command - open VM viewer
+    open_parser = subparsers.add_parser("open", help="Open VM viewer window")
+    open_parser.add_argument(
+        "name", nargs="?", default=None, help="VM name or '.' to use .clonebox.yaml"
+    )
+    open_parser.add_argument(
+        "-u",
+        "--user",
+        action="store_true",
+        help="Use user session (qemu:///session) - no root required",
+    )
+    open_parser.set_defaults(func=cmd_open)
+
     # Stop command
     stop_parser = subparsers.add_parser("stop", help="Stop a VM")
     stop_parser.add_argument("name", help="VM name")
@@ -1178,6 +1906,66 @@ 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)
+
+    # Test command - validate VM configuration
+    test_parser = subparsers.add_parser("test", help="Test VM configuration and health")
+    test_parser.add_argument(
+        "name", nargs="?", default=None, help="VM name or '.' to use .clonebox.yaml"
+    )
+    test_parser.add_argument(
+        "-u", "--user", action="store_true", help="Use user session (qemu:///session)"
+    )
+    test_parser.add_argument(
+        "--quick", action="store_true", help="Quick test (no deep health checks)"
+    )
+    test_parser.add_argument(
+        "--verbose", "-v", action="store_true", help="Verbose output"
+    )
+    test_parser.set_defaults(func=cmd_test)
+
     args = parser.parse_args()
 
     if hasattr(args, "func"):

clonebox/cloner.py

@@ -417,9 +417,10 @@ class SelectiveVMCloner:
             ET.SubElement(cdrom, "readonly")
 
         # 9p filesystem mounts (bind mounts from host)
+        # Use accessmode="mapped" to allow VM user to access host files regardless of UID
         for idx, (host_path, guest_tag) in enumerate(config.paths.items()):
             if Path(host_path).exists():
-                fs = ET.SubElement(devices, "filesystem", type="mount", accessmode="passthrough")
+                fs = ET.SubElement(devices, "filesystem", type="mount", accessmode="mapped")
                 ET.SubElement(fs, "driver", type="path", wrpolicy="immediate")
                 ET.SubElement(fs, "source", dir=host_path)
                 # Use simple tag names for 9p mounts
@@ -659,15 +660,18 @@ fi
         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
@@ -690,7 +694,13 @@ fi
         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)
         
@@ -722,7 +732,8 @@ fi
         
         # 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.8.dist-info → clonebox-0.1.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clonebox
-Version: 0.1.8
+Version: 0.1.10
 Summary: Clone your workstation environment to an isolated VM with selective apps, paths and services
 Author: CloneBox Team
 License: Apache-2.0
@@ -64,6 +64,41 @@ CloneBox lets you create isolated virtual machines with only the applications, d
 - 🖥️ **GUI support** - SPICE graphics with virt-viewer integration
 - ⚡ **Fast creation** - No full disk cloning, VMs are ready in seconds
 - 📥 **Auto-download** - Automatically downloads and caches Ubuntu cloud images (stored in ~/Downloads)
+- 📊 **Health monitoring** - Built-in health checks for packages, services, and mounts
+- 🔄 **VM migration** - Export/import VMs with data between workstations
+- 🧪 **Configuration testing** - Validate VM settings and functionality
+- 📁 **App data sync** - Include browser profiles, IDE settings, and app configs
+
+
+
+
+CloneBox to narzędzie CLI do **szybkiego klonowania aktualnego środowiska workstation do izolowanej maszyny wirtualnej (VM)**. 
+Zamiast pełnego kopiowania dysku, używa **bind mounts** (udostępnianie katalogów na żywo) i **cloud-init** do selektywnego przeniesienia tylko potrzebnych elementów: uruchomionych usług (Docker, PostgreSQL, nginx), aplikacji, ścieżek projektów i konfiguracji. Automatycznie pobiera obrazy Ubuntu, instaluje pakiety i uruchamia VM z SPICE GUI. Idealne dla deweloperów na Linuxie – VM powstaje w minuty, bez duplikowania danych.
+
+Kluczowe komendy:
+- `clonebox` – interaktywny wizard (detect + create + start)
+- `clonebox detect` – skanuje usługi/apps/ścieżki
+- `clonebox clone . --user --run` – szybki klon bieżącego katalogu z użytkownikiem i autostartem
+
+### Dlaczego wirtualne klony workstation mają sens?
+
+**Problem**: Developerzy/Vibecoderzy nie izolują środowisk dev/test (np. dla AI agentów), bo ręczne odtwarzanie setupu to ból – godziny na instalację apps, usług, configów, dotfiles. Przechodzenie z fizycznego PC na VM wymagałoby pełnego rebuilda, co blokuje workflow.
+
+**Rozwiązanie CloneBox**: Automatycznie **skanuje i klonuje stan "tu i teraz"** (usługi z `ps`, dockery z `docker ps`, projekty z git/.env). VM dziedziczy środowisko bez kopiowania całego śmietnika – tylko wybrane bind mounty. 
+
+**Korzyści w twoim kontekście (embedded/distributed systems, AI automation)**:
+- **Sandbox dla eksperymentów**: Testuj AI agenty, edge computing (RPi/ESP32 symulacje) czy Camel/ERP integracje w izolacji, bez psucia hosta.
+- **Reprodukcja workstation**: Na firmowym PC masz setup z domu (Python/Rust/Go envs, Docker compose, Postgres dev DB) – klonujesz i pracujesz identycznie.
+- **Szybkość > dotfiles**: Dotfiles odtwarzają configi, ale nie łapią runtime stanu (uruchomione serwery, otwarte projekty). CloneBox to "snapshot na sterydach".
+- **Bezpieczeństwo/cost-optymalizacja**: Izolacja od plików hosta (tylko mounts), zero downtime, tanie w zasobach (libvirt/QEMU). Dla SME: szybki onboarding dev env bez migracji fizycznej.
+- **AI-friendly**: Agenci LLMs (jak te z twoich hobby) mogą działać w VM z pełnym kontekstem, bez ryzyka "zasmiecania" main PC.
+
+Przykład: Masz uruchomiony Kubernetes Podman z twoim home labem + projekt automotive leasing. `clonebox clone ~/projects --run` → VM gotowa w 30s, z tymi samymi serwisami, ale izolowana. Lepsze niż Docker (brak GUI/full OS) czy pełna migracja.
+
+**Dlaczego ludzie tego nie robią?** Brak automatyzacji – nikt nie chce ręcznie rebuildować. 
+- CloneBox rozwiązuje to jednym poleceniem. Super match dla twoich interesów (distributed infra, AI tools, business automation).
+
+
 
 ## Installation
 
@@ -142,7 +177,6 @@ Simply run `clonebox` to start the interactive wizard:
 ```bash
 clonebox
 clonebox clone . --user --run --replace --base-image ~/ubuntu-22.04-cloud.qcow2
-
 ```
 
 The wizard will:
@@ -181,6 +215,130 @@ clonebox detect --json
 
 ## Usage Examples
 
+### Basic Workflow
+
+```bash
+# 1. Clone current directory with auto-detection
+clonebox clone . --user
+
+# 2. Review generated config
+cat .clonebox.yaml
+
+# 3. Create and start VM
+clonebox start . --user --viewer
+
+# 4. Check VM status
+clonebox status . --user
+
+# 5. Open VM window later
+clonebox open . --user
+
+# 6. Stop VM when done
+clonebox stop . --user
+```
+
+### Development Environment with Browser Profiles
+
+```bash
+# Clone with app data (browser profiles, IDE settings)
+clonebox clone . --user --run
+
+# VM will have:
+# - All your project directories
+# - Browser profiles (Chrome, Firefox) with bookmarks and passwords
+# - IDE settings (PyCharm, VSCode)
+# - Docker containers and services
+
+# Access in VM:
+ls ~/.config/google-chrome  # Chrome profile
+ls ~/.mozilla/firefox       # Firefox profile
+ls ~/.config/JetBrains      # PyCharm settings
+```
+
+### Testing 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
+```
+
+### VM Health Monitoring
+
+```bash
+# Check overall status
+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
+clonebox status . --user --health
+
+# View detailed health report in VM:
+# cat /var/log/clonebox-health.log
+```
+
+### Export/Import Workflow
+
+```bash
+# On workstation A - Export VM with all data
+clonebox export . --user --include-data -o my-dev-env.tar.gz
+
+# Transfer file to workstation B, then import
+clonebox import my-dev-env.tar.gz --user
+
+# Start VM on new workstation
+clonebox start . --user
+clonebox open . --user
+
+# VM includes:
+# - Complete disk image
+# - All browser profiles and settings
+# - Project files
+# - Docker images and containers
+```
+
+### Troubleshooting Common Issues
+
+```bash
+# If mounts are empty after reboot:
+clonebox status . --user  # Check VM status
+# Then in VM:
+sudo mount -a              # Remount all fstab entries
+
+# If browser profiles don't sync:
+rm .clonebox.yaml
+clonebox clone . --user --run --replace
+
+# If GUI doesn't open:
+clonebox open . --user     # Easiest way
+# or:
+virt-viewer --connect qemu:///session clone-clonebox
+
+# Check VM details:
+clonebox list              # List all VMs
+virsh --connect qemu:///session dominfo clone-clonebox
+```
+
+## Legacy Examples (Manual Config)
+
+These examples use the older `create` command with manual JSON config. For most users, the `clone` command with auto-detection is easier.
+
 ### Python Development Environment
 
 ```bash
@@ -222,17 +380,36 @@ clonebox create --name fullstack --config '{
 
 ## Inside the VM
 
-After the VM boots, mount shared directories:
+After the VM boots, shared directories are automatically mounted via fstab entries. You can check their status:
 
 ```bash
-# Mount shared paths (9p filesystem)
-sudo mkdir -p /mnt/projects
-sudo mount -t 9p -o trans=virtio,version=9p2000.L mount0 /mnt/projects
+# Check mount status
+mount | grep 9p
 
-# Or add to /etc/fstab for permanent mount
-echo "mount0 /mnt/projects 9p trans=virtio,version=9p2000.L 0 0" | sudo tee -a /etc/fstab
+# View health check report
+cat /var/log/clonebox-health.log
+
+# Re-run health check manually
+clonebox-health
+
+# Check cloud-init status
+sudo cloud-init status
+
+# Manual mount (if needed)
+sudo mkdir -p /mnt/projects
+sudo mount -t 9p -o trans=virtio,version=9p2000.L,nofail mount0 /mnt/projects
 ```
 
+### Health Check System
+
+CloneBox includes automated health checks that verify:
+- Package installation (apt/snap)
+- Service status
+- Mount points accessibility
+- GUI readiness
+
+Health check logs are saved to `/var/log/clonebox-health.log` with a summary in `/var/log/clonebox-health-status`.
+
 ## Architecture
 
 ```
@@ -399,6 +576,7 @@ clonebox clone . --network auto
 | `clonebox clone . --network user` | Use user-mode networking (slirp) |
 | `clonebox clone . --network auto` | Auto-detect network mode (default) |
 | `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 |
@@ -408,6 +586,14 @@ 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 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 open . --user` | Open GUI viewer for VM (same as virt-viewer) |
+| `virt-viewer --connect qemu:///session <vm>` | Open GUI for running VM |
+| `virsh --connect qemu:///session console <vm>` | Open text console (Ctrl+] to exit) |
 
 ## Requirements
 
@@ -479,6 +665,102 @@ sudo apt install virt-viewer
 virt-viewer --connect qemu:///session <vm-name>
 ```
 
+### Browser Profiles Not Syncing
+
+If browser profiles or app data aren't available:
+
+1. **Regenerate config with app data:**
+   ```bash
+   rm .clonebox.yaml
+   clonebox clone . --user --run --replace
+   ```
+
+2. **Check mount permissions in VM:**
+   ```bash
+   # Verify mounts are accessible
+   ls -la ~/.config/google-chrome
+   ls -la ~/.mozilla/firefox
+   ```
+
+### Mount Points Empty After Reboot
+
+If shared directories appear empty after VM restart:
+
+1. **Check fstab entries:**
+   ```bash
+   cat /etc/fstab | grep 9p
+   ```
+
+2. **Mount manually:**
+   ```bash
+   sudo mount -a
+   ```
+
+3. **Verify access mode:**
+   - VMs created with `accessmode="mapped"` allow any user to access mounts
+   - Older VMs used `accessmode="passthrough"` which preserves host UIDs
+
+## Advanced Usage
+
+### VM Migration Between Workstations
+
+Export your complete VM environment:
+
+```bash
+# Export VM with all data
+clonebox export . --user --include-data -o my-dev-env.tar.gz
+
+# Transfer to new workstation, then import
+clonebox import my-dev-env.tar.gz --user
+clonebox start . --user
+```
+
+### Testing VM Configuration
+
+Validate your VM setup:
+
+```bash
+# Quick test (basic checks)
+clonebox test . --user --quick
+
+# Full test (includes health checks)
+clonebox test . --user --verbose
+```
+
+### Monitoring VM Health
+
+Check VM status from workstation:
+
+```bash
+# Check VM state, IP, cloud-init, and health
+clonebox status . --user
+
+# Trigger health check in VM
+clonebox status . --user --health
+```
+
+### Reopening VM Window
+
+If you close the VM window, you can reopen it:
+
+```bash
+# Open GUI viewer (easiest)
+clonebox open . --user
+
+# Start VM and open GUI (if VM is stopped)
+clonebox start . --user --viewer
+
+# Open GUI for running VM
+virt-viewer --connect qemu:///session clone-clonebox
+
+# List VMs to get the correct name
+clonebox list
+
+# Text console (no GUI)
+virsh --connect qemu:///session console clone-clonebox
+# Press Ctrl + ] to exit console
+```
+
 ## License
 
 MIT License - see [LICENSE](LICENSE) file.

clonebox-0.1.10.dist-info/RECORD

@@ -0,0 +1,11 @@
+clonebox/__init__.py,sha256=IOk7G0DiSQ33EGbFC0xbnnFB9aou_6yuyFxvycQEvA0,407
+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.10.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+clonebox-0.1.10.dist-info/METADATA,sha256=hzdP5bntKA1s_RyRLx0hgbBzGrlt3NBGvDKu5YZfabE,24526
+clonebox-0.1.10.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+clonebox-0.1.10.dist-info/entry_points.txt,sha256=FES95Vi3btfViLEEoHdb8nikNxTqzaooi9ehZw9ZfWI,47
+clonebox-0.1.10.dist-info/top_level.txt,sha256=LdMo2cvCrEcRGH2M8JgQNVsCoszLV0xug6kx1JnaRjo,9
+clonebox-0.1.10.dist-info/RECORD,,

clonebox-0.1.8.dist-info/RECORD

@@ -1,11 +0,0 @@
-clonebox/__init__.py,sha256=IOk7G0DiSQ33EGbFC0xbnnFB9aou_6yuyFxvycQEvA0,407
-clonebox/__main__.py,sha256=Fcoyzwwyz5-eC_sBlQk5a5RbKx8uodQz5sKJ190U0NU,135
-clonebox/cli.py,sha256=Kp-1C9Be39ZK9fVe-4bQLyb25W2otXk8597MvOOee7M,43133
-clonebox/cloner.py,sha256=CMy0NWxOiUMULaQuDHY0_LDUaELW0_h4ewj_dZ_5WHw,31171
-clonebox/detector.py,sha256=4fu04Ty6KC82WkcJZ5UL5TqXpWYE7Kb7R0uJ-9dtbCk,21635
-clonebox-0.1.8.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-clonebox-0.1.8.dist-info/METADATA,sha256=6a8ry0WjVyY21D3r1teMvSEL7zwVaoweH9GRtFxnZJY,15582
-clonebox-0.1.8.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-clonebox-0.1.8.dist-info/entry_points.txt,sha256=FES95Vi3btfViLEEoHdb8nikNxTqzaooi9ehZw9ZfWI,47
-clonebox-0.1.8.dist-info/top_level.txt,sha256=LdMo2cvCrEcRGH2M8JgQNVsCoszLV0xug6kx1JnaRjo,9
-clonebox-0.1.8.dist-info/RECORD,,