clonebox 1.1.20__py3-none-any.whl → 1.1.23__py3-none-any.whl

clonebox/cli.py

@@ -945,10 +945,28 @@ def interactive_mode():
         cloner = SelectiveVMCloner(user_session=getattr(args, "user", False))
 
         # Check prerequisites
-        checks = cloner.check_prerequisites()
-        if not all(checks.values()):
+        checks = cloner.check_prerequisites(config)
+        required_keys = [
+            "libvirt_connected",
+            "kvm_available",
+            "images_dir_writable",
+            "genisoimage_installed",
+            "qemu_img_installed",
+        ]
+        if checks.get("default_network_required", True):
+            required_keys.append("default_network")
+        if getattr(config, "gui", False):
+            required_keys.append("virt_viewer_installed")
+
+        required_checks = {
+            k: checks.get(k)
+            for k in required_keys
+            if isinstance(checks.get(k), bool)
+        }
+
+        if required_checks and not all(required_checks.values()):
             console.print("[yellow]⚠️  Prerequisites check:[/]")
-            for check, passed in checks.items():
+            for check, passed in required_checks.items():
                 icon = "✅" if passed else "❌"
                 console.print(f"   {icon} {check}")
 
@@ -1898,7 +1916,10 @@ def cmd_test(args):
 
                 if not qga_ready:
                     console.print("[yellow]⚠️  QEMU Guest Agent still not connected[/]")
-            
+                    console.print(
+                        f"[dim]Tip: you can watch live cloud-init output via serial console: virsh --connect {conn_uri} console {vm_name}[/]"
+                    )
+
             # Check cloud-init status immediately if QGA is ready
             if qga_ready:
                 console.print("[dim]   Checking cloud-init status via QGA...[/]")
@@ -2624,10 +2645,24 @@ def create_vm_from_config(config, start=False, user_session=False, replace=False
     cloner = SelectiveVMCloner(user_session=user_session)
     
     # Check prerequisites
-    checks = cloner.check_prerequisites()
-    if not all(checks.values()):
+    checks = cloner.check_prerequisites(vm_config)
+    required_keys = [
+        "libvirt_connected",
+        "kvm_available",
+        "images_dir_writable",
+        "genisoimage_installed",
+        "qemu_img_installed",
+    ]
+    if checks.get("default_network_required", True):
+        required_keys.append("default_network")
+    if getattr(vm_config, "gui", False):
+        required_keys.append("virt_viewer_installed")
+
+    required_checks = {k: checks.get(k) for k in required_keys if isinstance(checks.get(k), bool)}
+
+    if required_checks and not all(required_checks.values()):
         console.print("[yellow]⚠️  Prerequisites check:[/]")
-        for check, passed in checks.items():
+        for check, passed in required_checks.items():
             icon = "✅" if passed else "❌"
             console.print(f"   {icon} {check}")
     

clonebox/cloner.py

@@ -15,6 +15,7 @@ import tempfile
 import time
 import urllib.request
 import uuid
+import zlib
 import xml.etree.ElementTree as ET
 from dataclasses import dataclass, field
 from datetime import datetime
@@ -288,6 +289,17 @@ class SelectiveVMCloner:
         """Check if libvirt default network is active."""
         return self._default_network_state() == "active"
 
+    def _passt_supported(self) -> bool:
+        try:
+            if self.conn is None:
+                return False
+            if not hasattr(self.conn, "getLibVersion"):
+                return False
+            # libvirt 9.0.0 introduced the passt backend and <portForward> support
+            return int(self.conn.getLibVersion()) >= 9_000_000
+        except Exception:
+            return False
+
     def resolve_network_mode(self, config: VMConfig) -> str:
         """Resolve network mode based on config and session type."""
         mode = (config.network_mode or "auto").lower()
@@ -299,22 +311,34 @@ class SelectiveVMCloner:
             return mode
         return "default"
 
-    def check_prerequisites(self) -> dict:
+    def check_prerequisites(self, config: Optional[VMConfig] = None) -> dict:
         """Check system prerequisites for VM creation."""
         images_dir = self.get_images_dir()
 
+        resolved_network_mode: Optional[str] = None
+        if config is not None:
+            try:
+                resolved_network_mode = self.resolve_network_mode(config)
+            except Exception:
+                resolved_network_mode = None
+
         checks = {
             "libvirt_connected": False,
             "kvm_available": False,
             "default_network": False,
+            "default_network_required": True,
             "images_dir_writable": False,
             "images_dir": str(images_dir),
             "session_type": "user" if self.user_session else "system",
             "genisoimage_installed": False,
             "virt_viewer_installed": False,
             "qemu_img_installed": False,
+            "passt_installed": shutil.which("passt") is not None,
+            "passt_available": False,
         }
 
+        checks["passt_available"] = checks["passt_installed"] and self._passt_supported()
+
         # Check for genisoimage
         checks["genisoimage_installed"] = shutil.which("genisoimage") is not None
         
@@ -340,8 +364,14 @@ class SelectiveVMCloner:
 
         # Check default network
         default_net_state = self._default_network_state()
-        checks["default_network"] = default_net_state == "active"
-        if default_net_state in {"inactive", "missing", "unknown"}:
+        checks["default_network_required"] = (resolved_network_mode or "default") != "user"
+        if checks["default_network_required"]:
+            checks["default_network"] = default_net_state == "active"
+        else:
+            # For user-mode networking (slirp/passt), libvirt's default network is not required.
+            checks["default_network"] = True
+
+        if checks["default_network_required"] and default_net_state in {"inactive", "missing", "unknown"}:
             checks["network_error"] = (
                 "Default network not found or inactive.\n"
                 "  For user session, CloneBox can use user-mode networking (slirp) automatically.\n"
@@ -351,6 +381,9 @@ class SelectiveVMCloner:
                 "  Or use system session: clonebox clone . (without --user)\n"
             )
 
+        if resolved_network_mode is not None:
+            checks["network_mode"] = resolved_network_mode
+
         # Check images directory
         if images_dir.exists():
             checks["images_dir_writable"] = os.access(images_dir, os.W_OK)
@@ -524,6 +557,36 @@ class SelectiveVMCloner:
                             f"If the VM already exists, try: clonebox clone . --name {config.name} --replace\n"
                         ) from e
 
+                    try:
+                        if console and self.resolve_network_mode(config) == "user":
+                            if shutil.which("passt") and self._passt_supported():
+                                ssh_key_path = vm_dir / "ssh_key"
+                                if ssh_key_path.exists():
+                                    ssh_port = 22000 + (zlib.crc32(config.name.encode("utf-8")) % 1000)
+                                    console.print(
+                                        f"[dim]SSH access (passthrough): ssh -i {ssh_key_path} -p {ssh_port} {config.username}@127.0.0.1[/]"
+                                    )
+                            else:
+                                console.print(
+                                    "[yellow]⚠️  passt not available - SSH port-forward will NOT be configured in --user mode[/]"
+                                )
+                                console.print(
+                                    "[dim]Install passt (and recreate VM) to enable SSH fallback, or use virsh console for live logs.[/]"
+                                )
+
+                                if self.user_session:
+                                    console.print(
+                                        f"[dim]Host serial log (when enabled): {vm_dir / 'serial.log'}[/]"
+                                    )
+
+                        if console:
+                            conn_uri = "qemu:///session" if self.user_session else "qemu:///system"
+                            console.print(
+                                f"[dim]Live install logs: virsh --connect {conn_uri} console {config.name}[/]"
+                            )
+                    except Exception:
+                        pass
+
                     # Start if autostart requested
                     if getattr(config, "autostart", False):
                         self.start_vm(config.name, open_viewer=True)
@@ -1358,6 +1421,13 @@ fi
         if network_mode == "user":
             iface = ET.SubElement(devices, "interface", type="user")
             ET.SubElement(iface, "model", type="virtio")
+
+            if shutil.which("passt") and self._passt_supported():
+                ET.SubElement(iface, "backend", type="passt")
+
+                ssh_port = 22000 + (zlib.crc32(config.name.encode("utf-8")) % 1000)
+                pf = ET.SubElement(iface, "portForward", proto="tcp", address="127.0.0.1")
+                ET.SubElement(pf, "range", start=str(ssh_port), to="22")
         else:
             iface = ET.SubElement(devices, "interface", type="network")
             ET.SubElement(iface, "source", network="default")
@@ -1376,6 +1446,13 @@ fi
         serial = ET.SubElement(devices, "serial", type="pty")
         ET.SubElement(serial, "target", port="0")
 
+        if self.user_session:
+            vm_dir = Path(str(root_disk)).parent
+            serial_log_path = str(vm_dir / "serial.log")
+            serial_file = ET.SubElement(devices, "serial", type="file")
+            ET.SubElement(serial_file, "source", path=serial_log_path)
+            ET.SubElement(serial_file, "target", port="1")
+
         console_elem = ET.SubElement(devices, "console", type="pty")
         ET.SubElement(console_elem, "target", type="serial", port="0")
 
@@ -1398,6 +1475,7 @@ fi
 
         # Channel for guest agent
         channel = ET.SubElement(devices, "channel", type="unix")
+        # For both user and system sessions, let libvirt handle the path
         ET.SubElement(channel, "source", mode="bind")
         ET.SubElement(channel, "target", type="virtio", name="org.qemu.guest_agent.0")
 
@@ -1563,7 +1641,7 @@ fi
 
         # User-data
         # Add desktop environment if GUI is enabled
-        base_packages = ["qemu-guest-agent", "cloud-guest-utils"]
+        base_packages = ["qemu-guest-agent", "cloud-guest-utils", "openssh-server"]
         if config.gui:
             base_packages.extend(
                 [
@@ -1619,10 +1697,13 @@ fi
 
         # Phase 3: Core services
         runcmd_lines.append("  - echo '[3/10] 🔧 Enabling core services...'")
-        runcmd_lines.append("  - echo '  → [1/2] Enabling qemu-guest-agent'")
+        runcmd_lines.append("  - echo '  → [1/3] Enabling qemu-guest-agent'")
         runcmd_lines.append("  - systemctl enable --now qemu-guest-agent || echo '  → ❌ Failed to enable qemu-guest-agent'")
-        runcmd_lines.append("  - echo '  → [2/2] Enabling snapd'")
+        runcmd_lines.append("  - echo '  → [2/3] Enabling SSH server'")
+        runcmd_lines.append("  - systemctl enable --now ssh || systemctl enable --now sshd || echo '  → ❌ Failed to enable ssh'")
+        runcmd_lines.append("  - echo '  → [3/3] Enabling snapd'")
         runcmd_lines.append("  - systemctl enable --now snapd || echo '  → ❌ Failed to enable snapd'")
+        runcmd_lines.append("  - systemctl enable --now serial-getty@ttyS0.service >/dev/null 2>&1 || true")
         runcmd_lines.append("  - echo '  → Waiting for snap system seed...'")
         runcmd_lines.append("  - timeout 300 snap wait system seed.loaded || true")
         runcmd_lines.append("  - echo '  → ✓ [3/10] Core services enabled'")
@@ -2544,7 +2625,12 @@ if __name__ == "__main__":
         runcmd_yaml = "\n".join(runcmd_lines) if runcmd_lines else ""
         
         # Build bootcmd combining mount commands and extra security bootcmds
-        bootcmd_lines = list(bootcmd_extra) if bootcmd_extra else []
+        bootcmd_lines = [
+            '  - sh -c "echo \"[clonebox] bootcmd: enabling serial console (ttyS0)\" > /dev/ttyS0 || true"',
+            '  - systemctl enable --now serial-getty@ttyS0.service >/dev/null 2>&1 || true',
+        ]
+        if bootcmd_extra:
+            bootcmd_lines.extend(list(bootcmd_extra))
             
         bootcmd_block = ""
         if bootcmd_lines:
@@ -2572,6 +2658,10 @@ users:
             
         user_data_header += f"ssh_pwauth: {ssh_pwauth}\n"
 
+        output_targets = "/dev/ttyS0"
+        if user_session:
+            output_targets += " /dev/ttyS1"
+
         # Assemble final user-data
         user_data = f"""{user_data_header}
 # Make sure root partition + filesystem grows to fill the qcow2 disk size
@@ -2584,6 +2674,9 @@ resize_rootfs: true
 # Update package cache and upgrade
 package_update: true
 package_upgrade: false
+
+output:
+  all: "| tee -a /var/log/cloud-init-output.log {output_targets}"
 {bootcmd_block}
 
 # Install packages moved to runcmd for better logging

clonebox/validation/__init__.py

@@ -0,0 +1 @@
+from .validator import VMValidator

clonebox/validation/apps.py

@@ -0,0 +1,303 @@
+from typing import Dict, List, Optional
+
+from rich.panel import Panel
+from rich.table import Table
+
+
+class AppValidationMixin:
+    def validate_apps(self) -> Dict:
+        setup_in_progress = self._setup_in_progress() is True
+        packages = self.config.get("packages", [])
+        snap_packages = self.config.get("snap_packages", [])
+        copy_paths = self.config.get("copy_paths", None)
+        if not isinstance(copy_paths, dict) or not copy_paths:
+            copy_paths = self.config.get("app_data_paths", {})
+        vm_user = self.config.get("vm", {}).get("username", "ubuntu")
+
+        snap_app_specs = {
+            "pycharm-community": {
+                "process_patterns": ["pycharm-community", "pycharm", "jetbrains"],
+                "required_interfaces": [
+                    "desktop",
+                    "desktop-legacy",
+                    "x11",
+                    "wayland",
+                    "home",
+                    "network",
+                ],
+            },
+            "chromium": {
+                "process_patterns": ["chromium", "chromium-browser"],
+                "required_interfaces": [
+                    "desktop",
+                    "desktop-legacy",
+                    "x11",
+                    "wayland",
+                    "home",
+                    "network",
+                ],
+            },
+            "firefox": {
+                "process_patterns": ["firefox"],
+                "required_interfaces": [
+                    "desktop",
+                    "desktop-legacy",
+                    "x11",
+                    "wayland",
+                    "home",
+                    "network",
+                ],
+            },
+            "code": {
+                "process_patterns": ["code"],
+                "required_interfaces": [
+                    "desktop",
+                    "desktop-legacy",
+                    "x11",
+                    "wayland",
+                    "home",
+                    "network",
+                ],
+            },
+        }
+
+        expected = []
+
+        if "firefox" in packages:
+            expected.append("firefox")
+
+        for snap_pkg in snap_packages:
+            if snap_pkg in snap_app_specs:
+                expected.append(snap_pkg)
+
+        for _, guest_path in copy_paths.items():
+            if guest_path == "/home/ubuntu/.config/google-chrome":
+                expected.append("google-chrome")
+                break
+
+        expected = sorted(set(expected))
+        if not expected:
+            return self.results["apps"]
+
+        self.console.print("\n[bold]🧩 Validating Apps...[/]")
+        table = Table(title="App Validation", border_style="cyan")
+        table.add_column("App", style="bold")
+        table.add_column("Installed", justify="center")
+        table.add_column("Profile", justify="center")
+        table.add_column("Running", justify="center")
+        table.add_column("PID", justify="right", style="dim")
+        table.add_column("Note", style="dim")
+
+        def _pgrep_pattern(pattern: str) -> str:
+            if not pattern:
+                return pattern
+            return f"[{pattern[0]}]{pattern[1:]}"
+
+        def _check_any_process_running(patterns: List[str]) -> Optional[bool]:
+            for pattern in patterns:
+                p = _pgrep_pattern(pattern)
+                out = self._exec_in_vm(
+                    f"pgrep -u {vm_user} -f '{p}' >/dev/null 2>&1 && echo yes || echo no",
+                    timeout=10,
+                )
+                if out is None:
+                    return None
+                if out == "yes":
+                    return True
+            return False
+
+        def _find_first_pid(patterns: List[str]) -> Optional[str]:
+            for pattern in patterns:
+                p = _pgrep_pattern(pattern)
+                out = self._exec_in_vm(
+                    f"pgrep -u {vm_user} -f '{p}' 2>/dev/null | head -n 1 || true",
+                    timeout=10,
+                )
+                if out is None:
+                    return None
+                pid = out.strip()
+                if pid:
+                    return pid
+            return ""
+
+        def _collect_app_logs(app_name: str) -> str:
+            chunks: List[str] = []
+
+            def add(cmd: str, title: str, timeout: int = 20):
+                out = self._exec_in_vm(cmd, timeout=timeout)
+                if out is None:
+                    return
+                out = out.strip()
+                if not out:
+                    return
+                chunks.append(f"{title}\n$ {cmd}\n{out}")
+
+            if app_name in snap_app_specs:
+                add(f"snap connections {app_name} 2>/dev/null | head -n 40", "Snap connections")
+                add(f"snap logs {app_name} -n 80 2>/dev/null | tail -n 60", "Snap logs")
+
+                if app_name == "pycharm-community":
+                    add(
+                        "tail -n 80 /home/ubuntu/snap/pycharm-community/common/.config/JetBrains/*/log/idea.log 2>/dev/null || true",
+                        "idea.log",
+                    )
+
+            if app_name == "google-chrome":
+                add(
+                    "journalctl -n 200 --no-pager 2>/dev/null | grep -i chrome | tail -n 60 || true",
+                    "Journal (chrome)",
+                )
+            if app_name == "firefox":
+                add(
+                    "journalctl -n 200 --no-pager 2>/dev/null | grep -i firefox | tail -n 60 || true",
+                    "Journal (firefox)",
+                )
+
+            return "\n\n".join(chunks)
+
+        def _snap_missing_interfaces(snap_name: str, required: List[str]) -> Optional[List[str]]:
+            out = self._exec_in_vm(
+                f"snap connections {snap_name} 2>/dev/null | awk 'NR>1{{print $1, $3}}'",
+                timeout=15,
+            )
+            if out is None:
+                return None
+
+            connected = set()
+            for line in out.splitlines():
+                parts = line.split()
+                if len(parts) < 2:
+                    continue
+                iface, slot = parts[0], parts[1]
+                if slot != "-":
+                    connected.add(iface)
+
+            missing = [i for i in required if i not in connected]
+            return missing
+
+        def _check_dir_nonempty(path: str) -> bool:
+            out = self._exec_in_vm(
+                f"test -d {path} && [ $(ls -A {path} 2>/dev/null | wc -l) -gt 0 ] && echo yes || echo no",
+                timeout=10,
+            )
+            return out == "yes"
+
+        for app in expected:
+            self.results["apps"]["total"] += 1
+            installed = False
+            profile_ok = False
+            running: Optional[bool] = None
+            pid: Optional[str] = None
+            note = ""
+            pending = False
+
+            if app == "firefox":
+                installed = (
+                    self._exec_in_vm("command -v firefox >/dev/null 2>&1 && echo yes || echo no") == "yes"
+                )
+                if _check_dir_nonempty("/home/ubuntu/snap/firefox/common/.mozilla/firefox"):
+                    profile_ok = True
+                elif _check_dir_nonempty("/home/ubuntu/.mozilla/firefox"):
+                    profile_ok = True
+
+                if installed:
+                    running = _check_any_process_running(["firefox"])
+                    pid = _find_first_pid(["firefox"]) if running else ""
+
+            elif app in snap_app_specs:
+                installed = (
+                    self._exec_in_vm(f"snap list {app} >/dev/null 2>&1 && echo yes || echo no") == "yes"
+                )
+                if app == "pycharm-community":
+                    profile_ok = _check_dir_nonempty(
+                        "/home/ubuntu/snap/pycharm-community/common/.config/JetBrains"
+                    )
+                else:
+                    profile_ok = True
+
+                if installed:
+                    patterns = snap_app_specs[app]["process_patterns"]
+                    running = _check_any_process_running(patterns)
+                    pid = _find_first_pid(patterns) if running else ""
+                    if running is False:
+                        missing_ifaces = _snap_missing_interfaces(
+                            app,
+                            snap_app_specs[app]["required_interfaces"],
+                        )
+                        if missing_ifaces:
+                            note = f"missing interfaces: {', '.join(missing_ifaces)}"
+                        elif missing_ifaces == []:
+                            note = "not running"
+                        else:
+                            note = "interfaces unknown"
+
+            elif app == "google-chrome":
+                installed = (
+                    self._exec_in_vm(
+                        "(command -v google-chrome >/dev/null 2>&1 || command -v google-chrome-stable >/dev/null 2>&1) && echo yes || echo no"
+                    )
+                    == "yes"
+                )
+                profile_ok = _check_dir_nonempty("/home/ubuntu/.config/google-chrome")
+
+                if installed:
+                    running = _check_any_process_running(["google-chrome", "google-chrome-stable"])
+                    pid = (
+                        _find_first_pid(["google-chrome", "google-chrome-stable"]) if running else ""
+                    )
+
+            if self.require_running_apps and installed and profile_ok and running is None:
+                note = note or "running unknown"
+
+            if setup_in_progress and not installed:
+                pending = True
+                note = note or "setup in progress"
+            elif setup_in_progress and not profile_ok:
+                pending = True
+                note = note or "profile import in progress"
+
+            running_icon = (
+                "[dim]—[/]"
+                if not installed
+                else (
+                    "[green]✅[/]" if running is True else "[yellow]⚠️[/]" if running is False else "[dim]?[/]"
+                )
+            )
+
+            pid_value = "—" if not installed else ("?" if pid is None else (pid or "—"))
+
+            installed_icon = "[green]✅[/]" if installed else ("[yellow]⏳[/]" if pending else "[red]❌[/]")
+            profile_icon = "[green]✅[/]" if profile_ok else ("[yellow]⏳[/]" if pending else "[red]❌[/]")
+
+            table.add_row(app, installed_icon, profile_icon, running_icon, pid_value, note)
+
+            should_pass = installed and profile_ok
+            if self.require_running_apps and installed and profile_ok:
+                should_pass = running is True
+
+            if pending:
+                self.results["apps"]["skipped"] += 1
+            elif should_pass:
+                self.results["apps"]["passed"] += 1
+            else:
+                self.results["apps"]["failed"] += 1
+
+            self.results["apps"]["details"].append(
+                {
+                    "app": app,
+                    "installed": installed,
+                    "profile": profile_ok,
+                    "running": running,
+                    "pid": pid,
+                    "note": note,
+                    "pending": pending,
+                }
+            )
+
+            if installed and profile_ok and running in (False, None):
+                logs = _collect_app_logs(app)
+                if logs:
+                    self.console.print(Panel(logs, title=f"Logs: {app}", border_style="yellow"))
+
+        self.console.print(table)
+        return self.results["apps"]