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

clonebox/cli.py

@@ -949,11 +949,12 @@ def interactive_mode():
         required_keys = [
             "libvirt_connected",
             "kvm_available",
-            "default_network",
             "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")
 
@@ -1915,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...[/]")
@@ -2645,11 +2649,12 @@ def create_vm_from_config(config, start=False, user_session=False, replace=False
     required_keys = [
         "libvirt_connected",
         "kvm_available",
-        "default_network",
         "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")
 

clonebox/cloner.py

@@ -289,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()
@@ -323,8 +334,11 @@ class SelectiveVMCloner:
             "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
         
@@ -543,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)
@@ -1378,7 +1422,7 @@ fi
             iface = ET.SubElement(devices, "interface", type="user")
             ET.SubElement(iface, "model", type="virtio")
 
-            if shutil.which("passt"):
+            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)
@@ -1402,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")
 
@@ -1652,6 +1703,7 @@ fi
         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'")
@@ -2573,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:
@@ -2601,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
@@ -2613,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"]

clonebox/validation/core.py

@@ -0,0 +1,202 @@
+import base64
+import json
+import shutil
+import subprocess
+import time
+import zlib
+from pathlib import Path
+from typing import Dict, Optional
+
+from rich.console import Console
+
+
+class VMValidatorCore:
+    def __init__(
+        self,
+        config: dict,
+        vm_name: str,
+        conn_uri: str,
+        console: Console = None,
+        require_running_apps: bool = False,
+        smoke_test: bool = False,
+    ):
+        self.config = config
+        self.vm_name = vm_name
+        self.conn_uri = conn_uri
+        self.console = console or Console()
+        self.require_running_apps = require_running_apps
+        self.smoke_test = smoke_test
+        self.results = {
+            "mounts": {"passed": 0, "failed": 0, "skipped": 0, "total": 0, "details": []},
+            "packages": {"passed": 0, "failed": 0, "skipped": 0, "total": 0, "details": []},
+            "snap_packages": {
+                "passed": 0,
+                "failed": 0,
+                "skipped": 0,
+                "total": 0,
+                "details": [],
+            },
+            "services": {"passed": 0, "failed": 0, "skipped": 0, "total": 0, "details": []},
+            "disk": {"usage_pct": 0, "avail": "0", "total": "0"},
+            "apps": {"passed": 0, "failed": 0, "skipped": 0, "total": 0, "details": []},
+            "smoke": {"passed": 0, "failed": 0, "skipped": 0, "total": 0, "details": []},
+            "overall": "unknown",
+        }
+
+        self._setup_in_progress_cache: Optional[bool] = None
+        self._exec_transport: str = "qga"  # qga|ssh
+
+    def _get_ssh_key_path(self) -> Optional[Path]:
+        """Return path to the SSH key generated for this VM (if present)."""
+        try:
+            if self.conn_uri.endswith("/session"):
+                images_dir = Path.home() / ".local/share/libvirt/images"
+            else:
+                images_dir = Path("/var/lib/libvirt/images")
+            key_path = images_dir / self.vm_name / "ssh_key"
+            return key_path if key_path.exists() else None
+        except Exception:
+            return None
+
+    def _get_ssh_port(self) -> int:
+        """Deterministic host-side SSH port for passt port forwarding."""
+        return 22000 + (zlib.crc32(self.vm_name.encode("utf-8")) % 1000)
+
+    def _ssh_exec(self, command: str, timeout: int = 10) -> Optional[str]:
+        if shutil.which("ssh") is None:
+            return None
+        key_path = self._get_ssh_key_path()
+        if key_path is None:
+            return None
+
+        ssh_port = self._get_ssh_port()
+        user = (self.config.get("vm") or {}).get("username") or "ubuntu"
+
+        try:
+            result = subprocess.run(
+                [
+                    "ssh",
+                    "-i",
+                    str(key_path),
+                    "-p",
+                    str(ssh_port),
+                    "-o",
+                    "StrictHostKeyChecking=no",
+                    "-o",
+                    "UserKnownHostsFile=/dev/null",
+                    "-o",
+                    "ConnectTimeout=5",
+                    "-o",
+                    "BatchMode=yes",
+                    f"{user}@127.0.0.1",
+                    command,
+                ],
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+            )
+            if result.returncode != 0:
+                return None
+            return (result.stdout or "").strip()
+        except Exception:
+            return None
+
+    def _exec_in_vm(self, command: str, timeout: int = 10) -> Optional[str]:
+        """Execute command in VM using QEMU guest agent, with SSH fallback."""
+        if self._exec_transport == "ssh":
+            return self._ssh_exec(command, timeout=timeout)
+
+        try:
+            result = subprocess.run(
+                [
+                    "virsh",
+                    "--connect",
+                    self.conn_uri,
+                    "qemu-agent-command",
+                    self.vm_name,
+                    f'{{"execute":"guest-exec","arguments":{{"path":"/bin/sh","arg":["-c","{command}"],"capture-output":true}}}}',
+                ],
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+            )
+
+            if result.returncode != 0:
+                return None
+
+            response = json.loads(result.stdout)
+            if "return" not in response or "pid" not in response["return"]:
+                return None
+
+            pid = response["return"]["pid"]
+
+            deadline = time.time() + timeout
+            while time.time() < deadline:
+                status_result = subprocess.run(
+                    [
+                        "virsh",
+                        "--connect",
+                        self.conn_uri,
+                        "qemu-agent-command",
+                        self.vm_name,
+                        f'{{"execute":"guest-exec-status","arguments":{{"pid":{pid}}}}}',
+                    ],
+                    capture_output=True,
+                    text=True,
+                    timeout=5,
+                )
+
+                if status_result.returncode != 0:
+                    return None
+
+                status_resp = json.loads(status_result.stdout)
+                if "return" not in status_resp:
+                    return None
+
+                ret = status_resp["return"]
+                if ret.get("exited", False):
+                    if "out-data" in ret:
+                        return base64.b64decode(ret["out-data"]).decode().strip()
+                    return ""
+
+                time.sleep(0.2)
+
+            return None
+
+        except Exception:
+            return None
+
+    def _setup_in_progress(self) -> Optional[bool]:
+        if self._setup_in_progress_cache is not None:
+            return self._setup_in_progress_cache
+
+        out = self._exec_in_vm(
+            "test -f /var/lib/cloud/instance/boot-finished && echo no || echo yes",
+            timeout=10,
+        )
+        if out is None:
+            self._setup_in_progress_cache = None
+            return None
+
+        self._setup_in_progress_cache = out.strip() == "yes"
+        return self._setup_in_progress_cache
+
+    def _check_qga_ready(self) -> bool:
+        """Check if QEMU guest agent is responding."""
+        try:
+            result = subprocess.run(
+                [
+                    "virsh",
+                    "--connect",
+                    self.conn_uri,
+                    "qemu-agent-command",
+                    self.vm_name,
+                    '{"execute":"guest-ping"}',
+                ],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            return result.returncode == 0
+        except Exception:
+            return False