clonebox 0.1.21__py3-none-any.whl → 0.1.22__py3-none-any.whl

clonebox/cli.py

@@ -8,7 +8,8 @@ import json
 import os
 import re
 import sys
-from typing import Optional
+import time
+from typing import Any, Dict, Optional, Tuple
 from datetime import datetime
 from pathlib import Path
 
@@ -16,6 +17,7 @@ import questionary
 import yaml
 from questionary import Style
 from rich.console import Console
+from rich.live import Live
 from rich.panel import Panel
 from rich.progress import Progress, SpinnerColumn, TextColumn
 from rich.table import Table
@@ -61,7 +63,7 @@ def print_banner():
     console.print(f"  Version {__version__}\n", style="dim")
 
 
-def _resolve_vm_name_and_config_file(name: Optional[str]) -> tuple[str, Optional[Path]]:
+def _resolve_vm_name_and_config_file(name: Optional[str]) -> Tuple[str, Optional[Path]]:
     config_file: Optional[Path] = None
 
     if name and (name.startswith(".") or name.startswith("/") or name.startswith("~")):
@@ -196,6 +198,9 @@ def run_vm_diagnostics(
 
     console.print(f"[bold cyan]🧪 Diagnostics: {vm_name}[/]\n")
 
+    guest_agent_ready = _qga_ping(vm_name, conn_uri)
+    result["qga"]["ready"] = guest_agent_ready
+
     try:
         domstate = subprocess.run(
             ["virsh", "--connect", conn_uri, "domstate", vm_name],
@@ -257,8 +262,6 @@ def run_vm_diagnostics(
         result["network"] = {"error": str(e)}
         console.print(f"[yellow]⚠️  Cannot get IP: {e}[/]")
 
-    guest_agent_ready = _qga_ping(vm_name, conn_uri)
-    result["qga"]["ready"] = guest_agent_ready
     if verbose:
         console.print("\n[bold]🤖 QEMU Guest Agent...[/]")
         console.print(f"{'[green]✅' if guest_agent_ready else '[red]❌'} QGA connected")
@@ -334,7 +337,7 @@ def run_vm_diagnostics(
     if not cloud_init_complete:
         console.print("[dim]Mounts may not be ready until cloud-init completes.[/]")
 
-    mounts_detail: list[dict] = []
+    mounts_detail: list = []
     result["mounts"]["details"] = mounts_detail
     if not guest_agent_ready:
         console.print("[yellow]⏳ QEMU guest agent not connected yet - cannot verify mounts.[/]")
@@ -426,6 +429,109 @@ def run_vm_diagnostics(
     return result
 
 
+def cmd_watch(args):
+    name = args.name
+    user_session = getattr(args, "user", False)
+    conn_uri = "qemu:///session" if user_session else "qemu:///system"
+    refresh = getattr(args, "refresh", 1.0)
+    max_wait = getattr(args, "timeout", 600)
+
+    try:
+        vm_name, _ = _resolve_vm_name_and_config_file(name)
+    except FileNotFoundError as e:
+        console.print(f"[red]❌ {e}[/]")
+        return
+
+    console.print(f"[bold cyan]👀 Watching boot diagnostics: {vm_name}[/]")
+    console.print("[dim]Waiting for QEMU Guest Agent...[/]")
+
+    start = time.time()
+    while time.time() - start < max_wait:
+        if _qga_ping(vm_name, conn_uri):
+            break
+        time.sleep(min(refresh, 2.0))
+
+    if not _qga_ping(vm_name, conn_uri):
+        console.print("[yellow]⚠️  QEMU Guest Agent not connected - cannot watch diagnostic status yet[/]")
+        console.print(f"[dim]Try: clonebox status {name or vm_name} {'--user' if user_session else ''} --verbose[/]")
+        return
+
+    def _read_status() -> Tuple[Optional[Dict[str, Any]], str]:
+        status_raw = _qga_exec(vm_name, conn_uri, "cat /var/run/clonebox-status.json 2>/dev/null || true", timeout=10)
+        log_tail = _qga_exec(vm_name, conn_uri, "tail -n 40 /var/log/clonebox-boot.log 2>/dev/null || true", timeout=10) or ""
+
+        status_obj: Optional[Dict[str, Any]] = None
+        if status_raw:
+            try:
+                status_obj = json.loads(status_raw)
+            except Exception:
+                status_obj = None
+        return status_obj, log_tail
+
+    with Live(refresh_per_second=max(1, int(1 / max(refresh, 0.2))), console=console) as live:
+        while True:
+            status_obj, log_tail = _read_status()
+            phase = (status_obj or {}).get("phase") if status_obj else None
+            current_task = (status_obj or {}).get("current_task") if status_obj else None
+
+            header = f"phase={phase or 'unknown'}"
+            if current_task:
+                header += f" | {current_task}"
+
+            stats = ""
+            if status_obj:
+                stats = (
+                    f"passed={status_obj.get('passed', 0)} failed={status_obj.get('failed', 0)} repaired={status_obj.get('repaired', 0)} total={status_obj.get('total', 0)}"
+                )
+
+            body = "\n".join([s for s in [header, stats, "", log_tail.strip()] if s])
+            live.update(Panel(body or "(no output yet)", title="CloneBox boot diagnostic", border_style="cyan"))
+
+            if phase == "complete":
+                break
+
+            if time.time() - start >= max_wait:
+                break
+
+            time.sleep(refresh)
+
+
+def cmd_repair(args):
+    name = args.name
+    user_session = getattr(args, "user", False)
+    conn_uri = "qemu:///session" if user_session else "qemu:///system"
+    timeout = getattr(args, "timeout", 600)
+    follow = getattr(args, "watch", False)
+
+    try:
+        vm_name, _ = _resolve_vm_name_and_config_file(name)
+    except FileNotFoundError as e:
+        console.print(f"[red]❌ {e}[/]")
+        return
+
+    if not _qga_ping(vm_name, conn_uri):
+        console.print("[yellow]⚠️  QEMU Guest Agent not connected - cannot trigger repair[/]")
+        console.print("[dim]Inside VM you can run: sudo /usr/local/bin/clonebox-boot-diagnostic[/]")
+        return
+
+    console.print(f"[cyan]🔧 Running boot diagnostic/repair in VM: {vm_name}[/]")
+    out = _qga_exec(vm_name, conn_uri, "/usr/local/bin/clonebox-boot-diagnostic || true", timeout=timeout)
+    if out is None:
+        console.print("[yellow]⚠️  Repair triggered but output not available via QGA (check VM console/log)[/]")
+    elif out.strip():
+        console.print(Panel(out.strip()[-3000:], title="Command output", border_style="cyan"))
+
+    if follow:
+        cmd_watch(
+            argparse.Namespace(
+                name=name,
+                user=user_session,
+                refresh=getattr(args, "refresh", 1.0),
+                timeout=timeout,
+            )
+        )
+
+
 def interactive_mode():
     """Run the interactive VM creation wizard."""
     print_banner()
@@ -1444,6 +1550,8 @@ def cmd_test(args):
     quick = getattr(args, "quick", False)
     verbose = getattr(args, "verbose", False)
     validate_all = getattr(args, "validate", False)
+    require_running_apps = getattr(args, "require_running_apps", False)
+    smoke_test = getattr(args, "smoke_test", False)
     conn_uri = "qemu:///session" if user_session else "qemu:///system"
     
     # If name is a path, load config
@@ -1636,7 +1744,14 @@ def cmd_test(args):
     
     # Run full validation if requested
     if validate_all and state == "running":
-        validator = VMValidator(config, vm_name, conn_uri, console)
+        validator = VMValidator(
+            config,
+            vm_name,
+            conn_uri,
+            console,
+            require_running_apps=require_running_apps,
+            smoke_test=smoke_test,
+        )
         results = validator.validate_all()
         
         # Exit with error code if validations failed
@@ -2629,6 +2744,63 @@ def main():
     )
     diagnose_parser.set_defaults(func=cmd_diagnose)
 
+    watch_parser = subparsers.add_parser(
+        "watch", help="Watch boot diagnostic output from VM (via QEMU Guest Agent)"
+    )
+    watch_parser.add_argument(
+        "name", nargs="?", default=None, help="VM name or '.' to use .clonebox.yaml"
+    )
+    watch_parser.add_argument(
+        "-u",
+        "--user",
+        action="store_true",
+        help="Use user session (qemu:///session)",
+    )
+    watch_parser.add_argument(
+        "--refresh",
+        type=float,
+        default=1.0,
+        help="Refresh interval in seconds (default: 1.0)",
+    )
+    watch_parser.add_argument(
+        "--timeout",
+        type=int,
+        default=600,
+        help="Max seconds to wait (default: 600)",
+    )
+    watch_parser.set_defaults(func=cmd_watch)
+
+    repair_parser = subparsers.add_parser(
+        "repair", help="Trigger boot diagnostic/repair inside VM (via QEMU Guest Agent)"
+    )
+    repair_parser.add_argument(
+        "name", nargs="?", default=None, help="VM name or '.' to use .clonebox.yaml"
+    )
+    repair_parser.add_argument(
+        "-u",
+        "--user",
+        action="store_true",
+        help="Use user session (qemu:///session)",
+    )
+    repair_parser.add_argument(
+        "--timeout",
+        type=int,
+        default=600,
+        help="Max seconds to wait for repair (default: 600)",
+    )
+    repair_parser.add_argument(
+        "--watch",
+        action="store_true",
+        help="After triggering repair, watch status/log output",
+    )
+    repair_parser.add_argument(
+        "--refresh",
+        type=float,
+        default=1.0,
+        help="Refresh interval for --watch (default: 1.0)",
+    )
+    repair_parser.set_defaults(func=cmd_repair)
+
     # Export command - package VM for migration
     export_parser = subparsers.add_parser("export", help="Export VM and data for migration")
     export_parser.add_argument(
@@ -2674,6 +2846,16 @@ def main():
     test_parser.add_argument(
         "--validate", action="store_true", help="Run full validation (mounts, packages, services)"
     )
+    test_parser.add_argument(
+        "--require-running-apps",
+        action="store_true",
+        help="Fail validation if expected apps are installed but not currently running",
+    )
+    test_parser.add_argument(
+        "--smoke-test",
+        action="store_true",
+        help="Run smoke tests (installed ≠ works): headless launch checks for key apps",
+    )
     test_parser.set_defaults(func=cmd_test)
 
     args = parser.parse_args()

clonebox/cloner.py

@@ -487,6 +487,268 @@ class SelectiveVMCloner:
 
         return ET.tostring(root, encoding="unicode")
 
+    def _generate_boot_diagnostic_script(self, config: VMConfig) -> str:
+        """Generate boot diagnostic script with self-healing capabilities."""
+        import base64
+
+        wants_google_chrome = any(
+            p == "/home/ubuntu/.config/google-chrome" for p in (config.paths or {}).values()
+        )
+
+        apt_pkg_list = list(config.packages or [])
+        for base_pkg in ["qemu-guest-agent", "cloud-guest-utils"]:
+            if base_pkg not in apt_pkg_list:
+                apt_pkg_list.insert(0, base_pkg)
+        if config.gui:
+            for gui_pkg in ["ubuntu-desktop-minimal", "firefox"]:
+                if gui_pkg not in apt_pkg_list:
+                    apt_pkg_list.append(gui_pkg)
+
+        apt_packages = " ".join(f'"{p}"' for p in apt_pkg_list) if apt_pkg_list else ""
+        snap_packages = " ".join(f'"{p}"' for p in config.snap_packages) if config.snap_packages else ""
+        services = " ".join(f'"{s}"' for s in config.services) if config.services else ""
+        
+        snap_ifaces_bash = "\n".join(
+            f'SNAP_INTERFACES["{snap}"]="{" ".join(ifaces)}"'
+            for snap, ifaces in SNAP_INTERFACES.items()
+        )
+        
+        script = f'''#!/bin/bash
+set -uo pipefail
+LOG="/var/log/clonebox-boot.log"
+STATUS_KV="/var/run/clonebox-status"
+STATUS_JSON="/var/run/clonebox-status.json"
+MAX_RETRIES=3
+PASSED=0 FAILED=0 REPAIRED=0 TOTAL=0
+
+RED='\\033[0;31m' GREEN='\\033[0;32m' YELLOW='\\033[1;33m' CYAN='\\033[0;36m' NC='\\033[0m' BOLD='\\033[1m'
+
+log() {{ echo -e "[$(date +%H:%M:%S)] $1" | tee -a "$LOG"; }}
+ok() {{ log "${{GREEN}}✅ $1${{NC}}"; ((PASSED++)); ((TOTAL++)); }}
+fail() {{ log "${{RED}}❌ $1${{NC}}"; ((FAILED++)); ((TOTAL++)); }}
+repair() {{ log "${{YELLOW}}🔧 $1${{NC}}"; }}
+section() {{ log ""; log "${{BOLD}}[$1] $2${{NC}}"; }}
+
+write_status() {{
+    local phase="$1"
+    local current_task="${{2:-}}"
+    printf 'passed=%s failed=%s repaired=%s\n' "$PASSED" "$FAILED" "$REPAIRED" > "$STATUS_KV" 2>/dev/null || true
+    cat > "$STATUS_JSON" <<EOF
+{{"phase":"$phase","current_task":"$current_task","total":$TOTAL,"passed":$PASSED,"failed":$FAILED,"repaired":$REPAIRED,"timestamp":"$(date -Iseconds)"}}
+EOF
+}}
+
+header() {{
+    log ""
+    log "${{BOLD}}${{CYAN}}═══════════════════════════════════════════════════════════${{NC}}"
+    log "${{BOLD}}${{CYAN}}  $1${{NC}}"
+    log "${{BOLD}}${{CYAN}}═══════════════════════════════════════════════════════════${{NC}}"
+}}
+
+declare -A SNAP_INTERFACES
+{snap_ifaces_bash}
+DEFAULT_IFACES="desktop desktop-legacy x11 home network"
+
+check_apt() {{
+    dpkg -l "$1" 2>/dev/null | grep -q "^ii"
+}}
+
+install_apt() {{
+    for i in $(seq 1 $MAX_RETRIES); do
+        DEBIAN_FRONTEND=noninteractive apt-get install -y "$1" &>>"$LOG" && return 0
+        sleep 3
+    done
+    return 1
+}}
+
+check_snap() {{
+    snap list "$1" &>/dev/null
+}}
+
+install_snap() {{
+    timeout 60 snap wait system seed.loaded 2>/dev/null || true
+    for i in $(seq 1 $MAX_RETRIES); do
+        snap install "$1" --classic &>>"$LOG" && return 0
+        snap install "$1" &>>"$LOG" && return 0
+        sleep 5
+    done
+    return 1
+}}
+
+connect_interfaces() {{
+    local snap="$1"
+    local ifaces="${{SNAP_INTERFACES[$snap]:-$DEFAULT_IFACES}}"
+    for iface in $ifaces; do
+        snap connect "$snap:$iface" ":$iface" 2>/dev/null && log "    ${{GREEN}}✓${{NC}} $snap:$iface" || true
+    done
+}}
+
+test_launch() {{
+    case "$1" in
+        pycharm-community) /snap/pycharm-community/current/jbr/bin/java -version &>/dev/null ;;
+        chromium) timeout 10 chromium --headless=new --dump-dom about:blank &>/dev/null ;;
+        firefox) timeout 10 firefox --headless --screenshot /tmp/ff-test.png about:blank &>/dev/null; rm -f /tmp/ff-test.png ;;
+        docker) docker info &>/dev/null ;;
+        *) command -v "$1" &>/dev/null ;;
+    esac
+}}
+
+header "CloneBox VM Boot Diagnostic"
+write_status "starting" "boot diagnostic starting"
+
+APT_PACKAGES=({apt_packages})
+SNAP_PACKAGES=({snap_packages})
+SERVICES=({services})
+
+section "1/5" "Checking APT packages..."
+write_status "checking_apt" "checking APT packages"
+for pkg in "${{APT_PACKAGES[@]}}"; do
+    [ -z "$pkg" ] && continue
+    if check_apt "$pkg"; then
+        ok "$pkg"
+    else
+        repair "Installing $pkg..."
+        if install_apt "$pkg"; then
+            ok "$pkg installed"
+            ((REPAIRED++))
+        else
+            fail "$pkg FAILED"
+        fi
+    fi
+done
+
+section "2/5" "Checking Snap packages..."
+write_status "checking_snaps" "checking snap packages"
+timeout 120 snap wait system seed.loaded 2>/dev/null || true
+for pkg in "${{SNAP_PACKAGES[@]}}"; do
+    [ -z "$pkg" ] && continue
+    if check_snap "$pkg"; then
+        ok "$pkg (snap)"
+    else
+        repair "Installing $pkg..."
+        if install_snap "$pkg"; then
+            ok "$pkg installed"
+            ((REPAIRED++))
+        else
+            fail "$pkg FAILED"
+        fi
+    fi
+done
+
+section "3/5" "Connecting Snap interfaces..."
+write_status "connecting_interfaces" "connecting snap interfaces"
+for pkg in "${{SNAP_PACKAGES[@]}}"; do
+    [ -z "$pkg" ] && continue
+    check_snap "$pkg" && connect_interfaces "$pkg"
+done
+systemctl restart snapd 2>/dev/null || true
+
+section "4/5" "Testing application launch..."
+write_status "testing_launch" "testing application launch"
+APPS_TO_TEST=()
+for pkg in "${{SNAP_PACKAGES[@]}}"; do
+    [ -z "$pkg" ] && continue
+    APPS_TO_TEST+=("$pkg")
+done
+if [ "{str(wants_google_chrome).lower()}" = "true" ]; then
+    APPS_TO_TEST+=("google-chrome")
+fi
+if printf '%s\n' "${{APT_PACKAGES[@]}}" | grep -qx "docker.io"; then
+    APPS_TO_TEST+=("docker")
+fi
+
+for app in "${{APPS_TO_TEST[@]}}"; do
+    [ -z "$app" ] && continue
+    case "$app" in
+        google-chrome)
+            if ! command -v google-chrome >/dev/null 2>&1 && ! command -v google-chrome-stable >/dev/null 2>&1; then
+                repair "Installing google-chrome..."
+                tmp_deb="/tmp/google-chrome-stable_current_amd64.deb"
+                if curl -fsSL -o "$tmp_deb" "https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb" \
+                    && DEBIAN_FRONTEND=noninteractive apt-get install -y "$tmp_deb" &>>"$LOG"; then
+                    rm -f "$tmp_deb"
+                    ((REPAIRED++))
+                else
+                    rm -f "$tmp_deb" 2>/dev/null || true
+                fi
+            fi
+            ;;
+        docker)
+            check_apt "docker.io" || continue
+            ;;
+        *)
+            if check_snap "$app"; then
+                :
+            else
+                continue
+            fi
+            ;;
+    esac
+
+    if test_launch "$app"; then
+        ok "$app launches OK"
+    else
+        fail "$app launch test FAILED"
+    fi
+done
+
+section "5/6" "Checking mount points..."
+write_status "checking_mounts" "checking mount points"
+while IFS= read -r line; do
+    tag=$(echo "$line" | awk '{{print $1}}')
+    mp=$(echo "$line" | awk '{{print $2}}')
+    if [[ "$tag" =~ ^mount[0-9]+$ ]] && [[ "$mp" == /* ]]; then
+        if mountpoint -q "$mp" 2>/dev/null; then
+            ok "$mp mounted"
+        else
+            repair "Mounting $mp..."
+            mkdir -p "$mp" 2>/dev/null || true
+            if mount "$mp" &>>"$LOG"; then
+                ok "$mp mounted"
+                ((REPAIRED++))
+            else
+                fail "$mp mount FAILED"
+            fi
+        fi
+    fi
+done < /etc/fstab
+
+section "6/6" "Checking services..."
+write_status "checking_services" "checking services"
+for svc in "${{SERVICES[@]}}"; do
+    [ -z "$svc" ] && continue
+    if systemctl is-active "$svc" &>/dev/null; then
+        ok "$svc running"
+    else
+        repair "Starting $svc..."
+        systemctl enable --now "$svc" &>/dev/null && ok "$svc started" && ((REPAIRED++)) || fail "$svc FAILED"
+    fi
+done
+
+header "Diagnostic Summary"
+log ""
+log "  Total:    $TOTAL"
+log "  ${{GREEN}}Passed:${{NC}}   $PASSED"
+log "  ${{YELLOW}}Repaired:${{NC}} $REPAIRED"
+log "  ${{RED}}Failed:${{NC}}   $FAILED"
+log ""
+
+write_status "complete" "complete"
+
+if [ $FAILED -eq 0 ]; then
+    log "${{GREEN}}${{BOLD}}═══════════════════════════════════════════════════════════${{NC}}"
+    log "${{GREEN}}${{BOLD}}  ✅ All checks passed! CloneBox VM is ready.${{NC}}"
+    log "${{GREEN}}${{BOLD}}═══════════════════════════════════════════════════════════${{NC}}"
+    exit 0
+else
+    log "${{RED}}${{BOLD}}═══════════════════════════════════════════════════════════${{NC}}"
+    log "${{RED}}${{BOLD}}  ⚠️  $FAILED checks failed. See /var/log/clonebox-boot.log${{NC}}"
+    log "${{RED}}${{BOLD}}═══════════════════════════════════════════════════════════${{NC}}"
+    exit 1
+fi
+'''
+        return base64.b64encode(script.encode()).decode()
+
     def _generate_health_check_script(self, config: VMConfig) -> str:
         """Generate a health check script that validates all installed components."""
         import base64
@@ -759,6 +1021,61 @@ fi
         runcmd_lines.append("  - /usr/local/bin/clonebox-health >> /var/log/clonebox-health.log 2>&1")
         runcmd_lines.append("  - echo 'CloneBox VM ready!' > /var/log/clonebox-ready")
         
+        # Generate boot diagnostic script (self-healing)
+        boot_diag_script = self._generate_boot_diagnostic_script(config)
+        runcmd_lines.append(f"  - echo '{boot_diag_script}' | base64 -d > /usr/local/bin/clonebox-boot-diagnostic")
+        runcmd_lines.append("  - chmod +x /usr/local/bin/clonebox-boot-diagnostic")
+        
+        # Create systemd service for boot diagnostic (runs before GDM on subsequent boots)
+        systemd_service = '''[Unit]
+Description=CloneBox Boot Diagnostic
+After=network-online.target snapd.service
+Before=gdm.service display-manager.service
+Wants=network-online.target
+
+[Service]
+Type=oneshot
+ExecStart=/usr/local/bin/clonebox-boot-diagnostic
+StandardOutput=journal+console
+StandardError=journal+console
+TTYPath=/dev/tty1
+TTYReset=yes
+TTYVHangup=yes
+RemainAfterExit=yes
+TimeoutStartSec=600
+
+[Install]
+WantedBy=multi-user.target'''
+        import base64
+        systemd_b64 = base64.b64encode(systemd_service.encode()).decode()
+        runcmd_lines.append(f"  - echo '{systemd_b64}' | base64 -d > /etc/systemd/system/clonebox-diagnostic.service")
+        runcmd_lines.append("  - systemctl daemon-reload")
+        runcmd_lines.append("  - systemctl enable clonebox-diagnostic.service")
+        runcmd_lines.append("  - systemctl start clonebox-diagnostic.service || true")
+        
+        # Create MOTD banner
+        motd_banner = '''#!/bin/bash
+S="/var/run/clonebox-status"
+echo ""
+echo -e "\\033[1;34m═══════════════════════════════════════════════════════════\\033[0m"
+echo -e "\\033[1;34m                  CloneBox VM Status\\033[0m"
+echo -e "\\033[1;34m═══════════════════════════════════════════════════════════\\033[0m"
+if [ -f "$S" ]; then
+    source "$S"
+    if [ "${failed:-0}" -eq 0 ]; then
+        echo -e "  \\033[0;32m✅ All systems operational\\033[0m"
+    else
+        echo -e "  \\033[0;31m⚠️  $failed checks failed\\033[0m"
+    fi
+    echo -e "  Passed: ${passed:-0} | Repaired: ${repaired:-0} | Failed: ${failed:-0}"
+fi
+echo -e "  Log: /var/log/clonebox-boot.log"
+echo -e "\\033[1;34m═══════════════════════════════════════════════════════════\\033[0m"
+echo ""'''
+        motd_b64 = base64.b64encode(motd_banner.encode()).decode()
+        runcmd_lines.append(f"  - echo '{motd_b64}' | base64 -d > /etc/update-motd.d/99-clonebox")
+        runcmd_lines.append("  - chmod +x /etc/update-motd.d/99-clonebox")
+        
         # Add reboot command at the end if GUI is enabled
         if config.gui:
             runcmd_lines.append("  - echo 'Rebooting in 10 seconds to start GUI...'")

clonebox/validator.py

@@ -8,23 +8,35 @@ import time
 from typing import Dict, List, Tuple, Optional
 from pathlib import Path
 from rich.console import Console
+from rich.panel import Panel
 from rich.table import Table
 
 
 class VMValidator:
     """Validates VM configuration against expected state from YAML."""
     
-    def __init__(self, config: dict, vm_name: str, conn_uri: str, console: Console = None):
+    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, "total": 0, "details": []},
             "packages": {"passed": 0, "failed": 0, "total": 0, "details": []},
             "snap_packages": {"passed": 0, "failed": 0, "total": 0, "details": []},
             "services": {"passed": 0, "failed": 0, "total": 0, "details": []},
             "apps": {"passed": 0, "failed": 0, "total": 0, "details": []},
+            "smoke": {"passed": 0, "failed": 0, "total": 0, "details": []},
             "overall": "unknown"
         }
     
@@ -263,11 +275,12 @@ class VMValidator:
         svc_table.add_column("Service", style="bold")
         svc_table.add_column("Enabled", justify="center")
         svc_table.add_column("Running", justify="center")
+        svc_table.add_column("PID", justify="right", style="dim")
         svc_table.add_column("Note", style="dim")
 
         for service in services:
             if service in self.VM_EXCLUDED_SERVICES:
-                svc_table.add_row(service, "[dim]—[/]", "[dim]—[/]", "host-only")
+                svc_table.add_row(service, "[dim]—[/]", "[dim]—[/]", "[dim]—[/]", "host-only")
                 self.results["services"]["skipped"] += 1
                 self.results["services"]["details"].append(
                     {
@@ -290,10 +303,20 @@ class VMValidator:
             running_status = self._exec_in_vm(running_cmd)
             is_running = running_status == "active"
 
+            pid_value = ""
+            if is_running:
+                pid_out = self._exec_in_vm(f"systemctl show -p MainPID --value {service} 2>/dev/null")
+                if pid_out is None:
+                    pid_value = "?"
+                else:
+                    pid_value = pid_out.strip() or "?"
+            else:
+                pid_value = "—"
+
             enabled_icon = "[green]✅[/]" if is_enabled else "[yellow]⚠️[/]"
             running_icon = "[green]✅[/]" if is_running else "[red]❌[/]"
 
-            svc_table.add_row(service, enabled_icon, running_icon, "")
+            svc_table.add_row(service, enabled_icon, running_icon, pid_value, "")
 
             if is_enabled and is_running:
                 self.results["services"]["passed"] += 1
@@ -305,6 +328,7 @@ class VMValidator:
                     "service": service,
                     "enabled": is_enabled,
                     "running": is_running,
+                    "pid": None if pid_value in ("", "—", "?") else pid_value,
                     "skipped": False,
                 }
             )
@@ -322,13 +346,35 @@ class VMValidator:
         packages = self.config.get("packages", [])
         snap_packages = self.config.get("snap_packages", [])
         app_data_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")
-        if "pycharm-community" in snap_packages:
-            expected.append("pycharm-community")
+
+        for snap_pkg in snap_packages:
+            if snap_pkg in snap_app_specs:
+                expected.append(snap_pkg)
 
         for _, guest_path in app_data_paths.items():
             if guest_path == "/home/ubuntu/.config/google-chrome":
@@ -344,6 +390,90 @@ class VMValidator:
         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(
@@ -356,6 +486,9 @@ class VMValidator:
             self.results["apps"]["total"] += 1
             installed = False
             profile_ok = False
+            running: Optional[bool] = None
+            pid: Optional[str] = None
+            note = ""
 
             if app == "firefox":
                 installed = (
@@ -367,16 +500,37 @@ class VMValidator:
                 elif _check_dir_nonempty("/home/ubuntu/.mozilla/firefox"):
                     profile_ok = True
 
-            elif app == "pycharm-community":
+                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(
-                        "snap list pycharm-community >/dev/null 2>&1 && echo yes || echo no"
-                    )
+                    self._exec_in_vm(f"snap list {app} >/dev/null 2>&1 && echo yes || echo no")
                     == "yes"
                 )
-                profile_ok = _check_dir_nonempty(
-                    "/home/ubuntu/snap/pycharm-community/common/.config/JetBrains"
-                )
+                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 = (
@@ -387,23 +541,190 @@ class VMValidator:
                 )
                 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"
+
+            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 "—"))
+
             table.add_row(
                 app,
                 "[green]✅[/]" if installed else "[red]❌[/]",
                 "[green]✅[/]" if profile_ok else "[red]❌[/]",
+                running_icon,
+                pid_value,
+                note,
             )
 
-            if installed and profile_ok:
+            should_pass = installed and profile_ok
+            if self.require_running_apps and installed and profile_ok:
+                should_pass = running is True
+
+            if 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}
+                {
+                    "app": app,
+                    "installed": installed,
+                    "profile": profile_ok,
+                    "running": running,
+                    "pid": pid,
+                    "note": note,
+                }
             )
 
+            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"]
+
+    def validate_smoke_tests(self) -> Dict:
+        packages = self.config.get("packages", [])
+        snap_packages = self.config.get("snap_packages", [])
+        app_data_paths = self.config.get("app_data_paths", {})
+        vm_user = self.config.get("vm", {}).get("username", "ubuntu")
+
+        expected = []
+
+        if "firefox" in packages:
+            expected.append("firefox")
+
+        for snap_pkg in snap_packages:
+            if snap_pkg in {"pycharm-community", "chromium", "firefox", "code"}:
+                expected.append(snap_pkg)
+
+        for _, guest_path in app_data_paths.items():
+            if guest_path == "/home/ubuntu/.config/google-chrome":
+                expected.append("google-chrome")
+                break
+
+        if "docker" in (self.config.get("services", []) or []) or "docker.io" in packages:
+            expected.append("docker")
+
+        expected = sorted(set(expected))
+        if not expected:
+            return self.results["smoke"]
+
+        def _installed(app: str) -> Optional[bool]:
+            if app in {"pycharm-community", "chromium", "firefox", "code"}:
+                out = self._exec_in_vm(f"snap list {app} >/dev/null 2>&1 && echo yes || echo no", timeout=10)
+                return None if out is None else out.strip() == "yes"
+
+            if app == "google-chrome":
+                out = 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",
+                    timeout=10,
+                )
+                return None if out is None else out.strip() == "yes"
+
+            if app == "docker":
+                out = self._exec_in_vm("command -v docker >/dev/null 2>&1 && echo yes || echo no", timeout=10)
+                return None if out is None else out.strip() == "yes"
+
+            if app == "firefox":
+                out = self._exec_in_vm("command -v firefox >/dev/null 2>&1 && echo yes || echo no", timeout=10)
+                return None if out is None else out.strip() == "yes"
+
+            out = self._exec_in_vm(f"command -v {app} >/dev/null 2>&1 && echo yes || echo no", timeout=10)
+            return None if out is None else out.strip() == "yes"
+
+        def _run_test(app: str) -> Optional[bool]:
+            user_env = f"sudo -u {vm_user} env HOME=/home/{vm_user} XDG_RUNTIME_DIR=/run/user/1000"
+
+            if app == "pycharm-community":
+                out = self._exec_in_vm(
+                    "/snap/pycharm-community/current/jbr/bin/java -version >/dev/null 2>&1 && echo yes || echo no",
+                    timeout=20,
+                )
+                return None if out is None else out.strip() == "yes"
+
+            if app == "chromium":
+                out = self._exec_in_vm(
+                    f"{user_env} timeout 20 chromium --headless=new --no-sandbox --disable-gpu --dump-dom about:blank >/dev/null 2>&1 && echo yes || echo no",
+                    timeout=30,
+                )
+                return None if out is None else out.strip() == "yes"
+
+            if app == "firefox":
+                out = self._exec_in_vm(
+                    f"{user_env} timeout 20 firefox --headless --screenshot /tmp/clonebox-firefox.png about:blank >/dev/null 2>&1 && rm -f /tmp/clonebox-firefox.png && echo yes || echo no",
+                    timeout=30,
+                )
+                return None if out is None else out.strip() == "yes"
+
+            if app == "google-chrome":
+                out = self._exec_in_vm(
+                    f"{user_env} timeout 20 google-chrome --headless=new --no-sandbox --disable-gpu --dump-dom about:blank >/dev/null 2>&1 && echo yes || echo no",
+                    timeout=30,
+                )
+                return None if out is None else out.strip() == "yes"
+
+            if app == "docker":
+                out = self._exec_in_vm("timeout 20 docker info >/dev/null 2>&1 && echo yes || echo no", timeout=30)
+                return None if out is None else out.strip() == "yes"
+
+            out = self._exec_in_vm(f"timeout 20 {app} --version >/dev/null 2>&1 && echo yes || echo no", timeout=30)
+            return None if out is None else out.strip() == "yes"
+
+        self.console.print("\n[bold]🧪 Smoke Tests (installed ≠ works)...[/]")
+        table = Table(title="Smoke Tests", border_style="cyan")
+        table.add_column("App", style="bold")
+        table.add_column("Installed", justify="center")
+        table.add_column("Launch", justify="center")
+        table.add_column("Note", style="dim")
+
+        for app in expected:
+            self.results["smoke"]["total"] += 1
+            installed = _installed(app)
+            launched: Optional[bool] = None
+            note = ""
+
+            if installed is True:
+                launched = _run_test(app)
+                if launched is None:
+                    note = "test failed to execute"
+            elif installed is False:
+                note = "not installed"
+            else:
+                note = "install status unknown"
+
+            installed_icon = "[green]✅[/]" if installed is True else "[red]❌[/]" if installed is False else "[dim]?[/]"
+            launch_icon = "[green]✅[/]" if launched is True else "[red]❌[/]" if launched is False else ("[dim]—[/]" if installed is not True else "[dim]?[/]")
+
+            table.add_row(app, installed_icon, launch_icon, note)
+
+            passed = installed is True and launched is True
+            if passed:
+                self.results["smoke"]["passed"] += 1
+            else:
+                self.results["smoke"]["failed"] += 1
+
+            self.results["smoke"]["details"].append(
+                {
+                    "app": app,
+                    "installed": installed,
+                    "launched": launched,
+                    "note": note,
+                }
+            )
+
+        self.console.print(table)
+        return self.results["smoke"]
     
     def validate_all(self) -> Dict:
         """Run all validations and return comprehensive results."""
@@ -433,30 +754,41 @@ class VMValidator:
         self.validate_snap_packages()
         self.validate_services()
         self.validate_apps()
+        if self.smoke_test:
+            self.validate_smoke_tests()
+
+        recent_err = self._exec_in_vm("journalctl -p err -n 30 --no-pager 2>/dev/null || true", timeout=20)
+        if recent_err:
+            recent_err = recent_err.strip()
+            if recent_err:
+                self.console.print(Panel(recent_err, title="Recent system errors", border_style="red"))
         
         # Calculate overall status
         total_checks = (
-            self.results["mounts"]["total"] +
-            self.results["packages"]["total"] +
-            self.results["snap_packages"]["total"] +
-            self.results["services"]["total"] +
-            self.results["apps"]["total"]
+            self.results["mounts"]["total"]
+            + self.results["packages"]["total"]
+            + self.results["snap_packages"]["total"]
+            + self.results["services"]["total"]
+            + self.results["apps"]["total"]
+            + (self.results["smoke"]["total"] if self.smoke_test else 0)
         )
         
         total_passed = (
-            self.results["mounts"]["passed"] +
-            self.results["packages"]["passed"] +
-            self.results["snap_packages"]["passed"] +
-            self.results["services"]["passed"] +
-            self.results["apps"]["passed"]
+            self.results["mounts"]["passed"]
+            + self.results["packages"]["passed"]
+            + self.results["snap_packages"]["passed"]
+            + self.results["services"]["passed"]
+            + self.results["apps"]["passed"]
+            + (self.results["smoke"]["passed"] if self.smoke_test else 0)
         )
         
         total_failed = (
-            self.results["mounts"]["failed"] +
-            self.results["packages"]["failed"] +
-            self.results["snap_packages"]["failed"] +
-            self.results["services"]["failed"] +
-            self.results["apps"]["failed"]
+            self.results["mounts"]["failed"]
+            + self.results["packages"]["failed"]
+            + self.results["snap_packages"]["failed"]
+            + self.results["services"]["failed"]
+            + self.results["apps"]["failed"]
+            + (self.results["smoke"]["failed"] if self.smoke_test else 0)
         )
         
         # Get skipped services count

{clonebox-0.1.21.dist-info → clonebox-0.1.22.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clonebox
-Version: 0.1.21
+Version: 0.1.22
 Summary: Clone your workstation environment to an isolated VM with selective apps, paths and services
 Author: CloneBox Team
 License: Apache-2.0
@@ -274,6 +274,7 @@ clonebox
 clonebox clone . --user --run --replace --base-image ~/ubuntu-22.04-cloud.qcow2 --disk-size-gb 30
 
 clonebox test . --user --validate
+clonebox test . --user --validate --require-running-apps
 ```
 
 ### Profiles (Reusable presets)

{clonebox-0.1.21.dist-info → clonebox-0.1.22.dist-info}/RECORD

@@ -1,17 +1,17 @@
 clonebox/__init__.py,sha256=CyfHVVq6KqBr4CNERBpXk_O6Q5B35q03YpdQbokVvvI,408
 clonebox/__main__.py,sha256=Fcoyzwwyz5-eC_sBlQk5a5RbKx8uodQz5sKJ190U0NU,135
-clonebox/cli.py,sha256=ItXPNJmQeWbv-Bf9IxYi4e6AsX04pJwRk8fBXP0MglA,104376
-clonebox/cloner.py,sha256=jR-pIBewc8zNE_h_sTcID1uZYKeQjNc6VInhE3aikfQ,34156
+clonebox/cli.py,sha256=vbJ65ShdXG1nGkQteCaFtDTas0L2RNV--aay2Qx-6F0,110765
+clonebox/cloner.py,sha256=dX6K56goT3qZD3GOYjZBuAPMrAI0PriyFJWsJpQvyKc,46320
 clonebox/container.py,sha256=tiYK1ZB-DhdD6A2FuMA0h_sRNkUI7KfYcJ0tFOcdyeM,6105
 clonebox/dashboard.py,sha256=RhSPvR6kWglqXeLkCWesBZQid7wv2WpJa6w78mXbPjY,4268
 clonebox/detector.py,sha256=aS_QlbG93-DE3hsjRt88E7O-PGC2TUBgUbP9wqT9g60,23221
 clonebox/models.py,sha256=yBRUlJejpeJHZjvCYMGq1nXPFcmhLFxN-LqkEyveWsA,7913
 clonebox/profiles.py,sha256=VaKVuxCrgyMxx-8_WOTcw7E8irwGxUPhZHVY6RxYYiE,2034
-clonebox/validator.py,sha256=LnQSZEdJXFGcJrTPxzS2cQUmAXucGeHDKwxrX632h_s,21188
+clonebox/validator.py,sha256=z4YuIgVnX6ZqfIdJtjKIFwZ-iWlRUnpX7gmWwq-Jr88,35352
 clonebox/templates/profiles/ml-dev.yaml,sha256=MT7Wu3xGBnYIsO5mzZ2GDI4AAEFGOroIx0eU3XjNARg,140
-clonebox-0.1.21.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-clonebox-0.1.21.dist-info/METADATA,sha256=xvEQjhq84KYnf5oveMK8GRcfZXoBB54sZ9CrcRfTRpg,41534
-clonebox-0.1.21.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-clonebox-0.1.21.dist-info/entry_points.txt,sha256=FES95Vi3btfViLEEoHdb8nikNxTqzaooi9ehZw9ZfWI,47
-clonebox-0.1.21.dist-info/top_level.txt,sha256=LdMo2cvCrEcRGH2M8JgQNVsCoszLV0xug6kx1JnaRjo,9
-clonebox-0.1.21.dist-info/RECORD,,
+clonebox-0.1.22.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+clonebox-0.1.22.dist-info/METADATA,sha256=MuI44ArtnU0ql1rF99Hf_4frTRHe7_AikJK9w2jk6tI,41591
+clonebox-0.1.22.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+clonebox-0.1.22.dist-info/entry_points.txt,sha256=FES95Vi3btfViLEEoHdb8nikNxTqzaooi9ehZw9ZfWI,47
+clonebox-0.1.22.dist-info/top_level.txt,sha256=LdMo2cvCrEcRGH2M8JgQNVsCoszLV0xug6kx1JnaRjo,9
+clonebox-0.1.22.dist-info/RECORD,,