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

clonebox/validation/overall.py

@@ -0,0 +1,240 @@
+import subprocess
+import time
+from typing import Dict, Optional
+
+from rich.panel import Panel
+from rich.table import Table
+
+
+class OverallValidationMixin:
+    def validate_all(self) -> Dict:
+        """Run all validations and return comprehensive results."""
+        setup_in_progress = self._setup_in_progress() is True
+        self.console.print("[bold cyan]🔍 Running Full Validation...[/]")
+
+        try:
+            result = subprocess.run(
+                ["virsh", "--connect", self.conn_uri, "domstate", self.vm_name],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            vm_state = result.stdout.strip()
+
+            if "running" not in vm_state.lower():
+                self.console.print(f"[yellow]⚠️  VM is not running (state: {vm_state})[/]")
+                self.console.print("[dim]Start VM with: clonebox start .[/]")
+                self.results["overall"] = "vm_not_running"
+                return self.results
+        except Exception as e:
+            self.console.print(f"[red]❌ Cannot check VM state: {e}[/]")
+            self.results["overall"] = "error"
+            return self.results
+
+        if not self._check_qga_ready():
+            wait_deadline = time.time() + 180
+            self.console.print("[yellow]⏳ Waiting for QEMU Guest Agent (up to 180s)...[/]")
+            last_log = 0
+            while time.time() < wait_deadline:
+                time.sleep(5)
+                if self._check_qga_ready():
+                    break
+                elapsed = int(180 - (wait_deadline - time.time()))
+                if elapsed - last_log >= 15:
+                    self.console.print(f"[dim]   ...still waiting for QGA ({elapsed}s elapsed)[/]")
+                    last_log = elapsed
+
+        if not self._check_qga_ready():
+            self.console.print("[yellow]⚠️  QEMU Guest Agent not responding - trying SSH fallback...[/]")
+            self._exec_transport = "ssh"
+            smoke = self._ssh_exec("echo ok", timeout=10)
+            if smoke != "ok":
+                self.console.print("[red]❌ SSH fallback failed[/]")
+                try:
+                    key_path = self._get_ssh_key_path()
+                    ssh_port = self._get_ssh_port()
+                    if key_path is None:
+                        self.console.print(
+                            "[dim]SSH key not found for this VM (expected: <images_dir>/<vm_name>/ssh_key)[/]"
+                        )
+                    else:
+                        self.console.print(f"[dim]Expected SSH key: {key_path}[/]")
+                    self.console.print(
+                        f"[dim]Expected SSH port (passt forward): 127.0.0.1:{ssh_port} -> guest:22[/]"
+                    )
+                    self.console.print(
+                        "[dim]SSH fallback requires libvirt user networking with passt + <portForward> in VM XML.[/]"
+                    )
+                except Exception:
+                    pass
+                self.console.print("\n[bold]🔧 Troubleshooting QGA:[/]")
+                self.console.print("  1. The VM might still be booting. Wait 30-60 seconds.")
+                self.console.print("  2. Ensure the agent is installed and running inside the VM:")
+                self.console.print("     [dim]virsh console " + self.vm_name + "[/]")
+                self.console.print("     [dim]sudo systemctl status qemu-guest-agent[/]")
+                self.console.print("  3. If newly created, cloud-init might still be running.")
+                self.console.print("  4. Check VM logs: [dim]clonebox logs " + self.vm_name + "[/]")
+                self.console.print(
+                    "\n[yellow]⚠️  Skipping deep validation as it requires a working Guest Agent or SSH access.[/]"
+                )
+                self.results["overall"] = "qga_not_ready"
+                return self.results
+
+            self.console.print("[green]✅ SSH fallback connected (executing validations over SSH)[/]")
+
+        ci_status = self._exec_in_vm(
+            "cloud-init status --long 2>/dev/null || cloud-init status 2>/dev/null || true", timeout=20
+        )
+        if ci_status:
+            ci_lower = ci_status.lower()
+            if "running" in ci_lower:
+                self.console.print(
+                    "[yellow]⏳ Cloud-init still running - deep validation will show pending states[/]"
+                )
+                setup_in_progress = True
+
+        ready_msg = self._exec_in_vm("cat /var/log/clonebox-ready 2>/dev/null || true", timeout=10)
+        if not setup_in_progress and not (ready_msg and "clonebox vm ready" in ready_msg.lower()):
+            self.console.print(
+                "[yellow]⚠️  CloneBox ready marker not found - provisioning may not have completed[/]"
+            )
+
+        self.validate_disk_space()
+        self.validate_mounts()
+        self.validate_packages()
+        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"))
+
+        disk_failed = 1 if self.results.get("disk", {}).get("usage_pct", 0) > 90 else 0
+        total_checks = (
+            1
+            + 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 = (
+            (1 - disk_failed)
+            + 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 = (
+            disk_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)
+        )
+
+        skipped_mounts = self.results["mounts"].get("skipped", 0)
+        skipped_packages = self.results["packages"].get("skipped", 0)
+        skipped_services = self.results["services"].get("skipped", 0)
+        skipped_snaps = self.results["snap_packages"].get("skipped", 0)
+        skipped_apps = self.results["apps"].get("skipped", 0)
+        skipped_smoke = self.results["smoke"].get("skipped", 0) if self.smoke_test else 0
+        total_skipped = (
+            skipped_mounts + skipped_packages + skipped_services + skipped_snaps + skipped_apps + skipped_smoke
+        )
+
+        self.console.print("\n[bold]📊 Validation Summary[/]")
+        summary_table = Table(border_style="cyan")
+        summary_table.add_column("Category", style="bold")
+        summary_table.add_column("Passed", justify="right", style="green")
+        summary_table.add_column("Failed", justify="right", style="red")
+        summary_table.add_column("Skipped/Pending", justify="right", style="dim")
+        summary_table.add_column("Total", justify="right")
+
+        disk_usage_pct = self.results.get("disk", {}).get("usage_pct", 0)
+        disk_avail = self.results.get("disk", {}).get("avail", "?")
+        disk_total = self.results.get("disk", {}).get("total", "?")
+
+        disk_status_passed = "[green]OK[/]" if disk_usage_pct <= 90 else "—"
+        disk_status_failed = "—" if disk_usage_pct <= 90 else f"[red]FULL ({disk_usage_pct}%)[/]"
+
+        summary_table.add_row(
+            "Disk Space",
+            disk_status_passed,
+            disk_status_failed,
+            "—",
+            f"{disk_usage_pct}% of {disk_total} ({disk_avail} free)",
+        )
+
+        summary_table.add_row(
+            "Mounts",
+            str(self.results["mounts"]["passed"]),
+            str(self.results["mounts"]["failed"]),
+            str(skipped_mounts) if skipped_mounts else "—",
+            str(self.results["mounts"]["total"]),
+        )
+        summary_table.add_row(
+            "APT Packages",
+            str(self.results["packages"]["passed"]),
+            str(self.results["packages"]["failed"]),
+            str(skipped_packages) if skipped_packages else "—",
+            str(self.results["packages"]["total"]),
+        )
+        summary_table.add_row(
+            "Snap Packages",
+            str(self.results["snap_packages"]["passed"]),
+            str(self.results["snap_packages"]["failed"]),
+            str(skipped_snaps) if skipped_snaps else "—",
+            str(self.results["snap_packages"]["total"]),
+        )
+        summary_table.add_row(
+            "Services",
+            str(self.results["services"]["passed"]),
+            str(self.results["services"]["failed"]),
+            str(skipped_services) if skipped_services else "—",
+            str(self.results["services"]["total"]),
+        )
+        summary_table.add_row(
+            "Apps",
+            str(self.results["apps"]["passed"]),
+            str(self.results["apps"]["failed"]),
+            str(skipped_apps) if skipped_apps else "—",
+            str(self.results["apps"]["total"]),
+        )
+        summary_table.add_row(
+            "[bold]TOTAL",
+            f"[bold green]{total_passed}",
+            f"[bold red]{total_failed}",
+            f"[dim]{total_skipped}[/]" if total_skipped else "[dim]0[/]",
+            f"[bold]{total_checks}",
+        )
+
+        self.console.print(summary_table)
+
+        if total_failed == 0 and total_checks > 0 and total_skipped > 0:
+            self.results["overall"] = "pending"
+            self.console.print("\n[bold yellow]⏳ Setup in progress - some checks are pending[/]")
+        elif total_failed == 0 and total_checks > 0:
+            self.results["overall"] = "pass"
+            self.console.print("\n[bold green]✅ All validations passed![/]")
+        elif total_failed > 0:
+            self.results["overall"] = "partial"
+            self.console.print(f"\n[bold yellow]⚠️  {total_failed}/{total_checks} checks failed[/]")
+            self.console.print("[dim]Consider rebuilding VM: clonebox clone . --user --run --replace[/]")
+        else:
+            self.results["overall"] = "no_checks"
+            self.console.print("\n[dim]No validation checks configured[/]")
+
+        return self.results

clonebox/validation/packages.py

@@ -0,0 +1,117 @@
+from typing import Dict
+
+from rich.table import Table
+
+
+class PackageValidationMixin:
+    def validate_packages(self) -> Dict:
+        """Validate APT packages are installed."""
+        setup_in_progress = self._setup_in_progress() is True
+        self.console.print("\n[bold]📦 Validating APT Packages...[/]")
+
+        packages = self.config.get("packages", [])
+        if not packages:
+            self.console.print("[dim]No APT packages configured[/]")
+            return self.results["packages"]
+
+        total_pkgs = len(packages)
+        self.console.print(f"[dim]Checking {total_pkgs} packages via QGA...[/]")
+
+        pkg_table = Table(title="Package Validation", border_style="cyan")
+        pkg_table.add_column("Package", style="bold")
+        pkg_table.add_column("Status", justify="center")
+        pkg_table.add_column("Version", style="dim")
+
+        for idx, package in enumerate(packages, 1):
+            if idx == 1 or idx % 25 == 0 or idx == total_pkgs:
+                self.console.print(f"[dim]   ...packages progress: {idx}/{total_pkgs}[/]")
+            self.results["packages"]["total"] += 1
+
+            check_cmd = f"dpkg -l | grep -E '^ii  {package}' | awk '{{print $3}}'"
+            version = self._exec_in_vm(check_cmd)
+
+            if version:
+                pkg_table.add_row(package, "[green]✅ Installed[/]", version[:40])
+                self.results["packages"]["passed"] += 1
+                self.results["packages"]["details"].append(
+                    {"package": package, "installed": True, "version": version}
+                )
+            else:
+                if setup_in_progress:
+                    pkg_table.add_row(package, "[yellow]⏳ Pending[/]", "")
+                    self.results["packages"]["skipped"] += 1
+                    self.results["packages"]["details"].append(
+                        {"package": package, "installed": False, "version": None, "pending": True}
+                    )
+                else:
+                    pkg_table.add_row(package, "[red]❌ Missing[/]", "")
+                    self.results["packages"]["failed"] += 1
+                    self.results["packages"]["details"].append(
+                        {"package": package, "installed": False, "version": None}
+                    )
+
+        self.console.print(pkg_table)
+        self.console.print(
+            f"[dim]{self.results['packages']['passed']}/{self.results['packages']['total']} packages installed[/]"
+        )
+
+        return self.results["packages"]
+
+    def validate_snap_packages(self) -> Dict:
+        """Validate snap packages are installed."""
+        setup_in_progress = self._setup_in_progress() is True
+        self.console.print("\n[bold]📦 Validating Snap Packages...[/]")
+
+        snap_packages = self.config.get("snap_packages", [])
+        if not snap_packages:
+            self.console.print("[dim]No snap packages configured[/]")
+            return self.results["snap_packages"]
+
+        total_snaps = len(snap_packages)
+        self.console.print(f"[dim]Checking {total_snaps} snap packages via QGA...[/]")
+
+        snap_table = Table(title="Snap Package Validation", border_style="cyan")
+        snap_table.add_column("Package", style="bold")
+        snap_table.add_column("Status", justify="center")
+        snap_table.add_column("Version", style="dim")
+
+        for idx, package in enumerate(snap_packages, 1):
+            if idx == 1 or idx % 25 == 0 or idx == total_snaps:
+                self.console.print(f"[dim]   ...snap progress: {idx}/{total_snaps}[/]")
+            self.results["snap_packages"]["total"] += 1
+
+            check_cmd = f"snap list | grep '^{package}' | awk '{{print $2}}'"
+            version = self._exec_in_vm(check_cmd)
+
+            if version:
+                snap_table.add_row(package, "[green]✅ Installed[/]", version[:40])
+                self.results["snap_packages"]["passed"] += 1
+                self.results["snap_packages"]["details"].append(
+                    {"package": package, "installed": True, "version": version}
+                )
+            else:
+                if setup_in_progress:
+                    snap_table.add_row(package, "[yellow]⏳ Pending[/]", "")
+                    self.results["snap_packages"]["skipped"] += 1
+                    self.results["snap_packages"]["details"].append(
+                        {
+                            "package": package,
+                            "installed": False,
+                            "version": None,
+                            "pending": True,
+                        }
+                    )
+                else:
+                    snap_table.add_row(package, "[red]❌ Missing[/]", "")
+                    self.results["snap_packages"]["failed"] += 1
+                    self.results["snap_packages"]["details"].append(
+                        {"package": package, "installed": False, "version": None}
+                    )
+
+        self.console.print(snap_table)
+        msg = f"{self.results['snap_packages']['passed']}/{self.results['snap_packages']['total']} snap packages installed"
+        if self.results["snap_packages"].get("skipped", 0) > 0:
+            msg += f" ({self.results['snap_packages']['skipped']} pending)"
+        self.console.print(f"[dim]{msg}[/]")
+
+        return self.results["snap_packages"]

clonebox/validation/services.py

@@ -0,0 +1,125 @@
+from typing import Dict
+
+from rich.table import Table
+
+
+class ServiceValidationMixin:
+    # Services that should NOT be validated in VM (host-specific)
+    VM_EXCLUDED_SERVICES = {
+        "libvirtd",
+        "virtlogd",
+        "libvirt-guests",
+        "qemu-guest-agent",
+        "bluetooth",
+        "bluez",
+        "upower",
+        "thermald",
+        "tlp",
+        "power-profiles-daemon",
+        "gdm",
+        "gdm3",
+        "sddm",
+        "lightdm",
+        "snap.cups.cups-browsed",
+        "snap.cups.cupsd",
+        "ModemManager",
+        "wpa_supplicant",
+        "accounts-daemon",
+        "colord",
+        "switcheroo-control",
+    }
+
+    def validate_services(self) -> Dict:
+        """Validate services are enabled and running."""
+        setup_in_progress = self._setup_in_progress() is True
+        self.console.print("\n[bold]⚙️  Validating Services...[/]")
+
+        services = self.config.get("services", [])
+        if not services:
+            self.console.print("[dim]No services configured[/]")
+            return self.results["services"]
+
+        total_svcs = len(services)
+        self.console.print(f"[dim]Checking {total_svcs} services via QGA...[/]")
+
+        if "skipped" not in self.results["services"]:
+            self.results["services"]["skipped"] = 0
+
+        svc_table = Table(title="Service Validation", border_style="cyan")
+        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 idx, service in enumerate(services, 1):
+            if idx == 1 or idx % 25 == 0 or idx == total_svcs:
+                self.console.print(f"[dim]   ...services progress: {idx}/{total_svcs}[/]")
+            if service in self.VM_EXCLUDED_SERVICES:
+                svc_table.add_row(service, "[dim]—[/]", "[dim]—[/]", "[dim]—[/]", "host-only")
+                self.results["services"]["skipped"] += 1
+                self.results["services"]["details"].append(
+                    {
+                        "service": service,
+                        "enabled": None,
+                        "running": None,
+                        "skipped": True,
+                        "reason": "host-specific service",
+                    }
+                )
+                continue
+
+            self.results["services"]["total"] += 1
+
+            enabled_cmd = f"systemctl is-enabled {service} 2>/dev/null"
+            enabled_status = self._exec_in_vm(enabled_cmd)
+            is_enabled = enabled_status == "enabled"
+
+            running_cmd = f"systemctl is-active {service} 2>/dev/null"
+            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]⏳[/]" if setup_in_progress else "[yellow]⚠️[/]")
+            )
+            running_icon = (
+                "[green]✅[/]" if is_running else ("[yellow]⏳[/]" if setup_in_progress else "[red]❌[/]")
+            )
+
+            svc_table.add_row(service, enabled_icon, running_icon, pid_value, "")
+
+            if is_enabled and is_running:
+                self.results["services"]["passed"] += 1
+            elif setup_in_progress:
+                self.results["services"]["skipped"] += 1
+            else:
+                self.results["services"]["failed"] += 1
+
+            self.results["services"]["details"].append(
+                {
+                    "service": service,
+                    "enabled": is_enabled,
+                    "running": is_running,
+                    "pid": None if pid_value in ("", "—", "?") else pid_value,
+                    "skipped": False,
+                }
+            )
+
+        self.console.print(svc_table)
+        skipped = self.results["services"].get("skipped", 0)
+        msg = f"{self.results['services']['passed']}/{self.results['services']['total']} services active"
+        if skipped > 0:
+            msg += f" ({skipped} host-only skipped)"
+        self.console.print(f"[dim]{msg}[/]")
+
+        return self.results["services"]

clonebox/validation/smoke.py

@@ -0,0 +1,177 @@
+from typing import Dict, Optional
+
+from rich.table import Table
+
+
+class SmokeValidationMixin:
+    def validate_smoke_tests(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")
+
+        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 copy_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]:
+            uid_out = self._exec_in_vm(f"id -u {vm_user} 2>/dev/null || true", timeout=10)
+            vm_uid = (uid_out or "").strip()
+            if not vm_uid.isdigit():
+                vm_uid = "1000"
+
+            runtime_dir = f"/run/user/{vm_uid}"
+            self._exec_in_vm(
+                f"mkdir -p {runtime_dir} && chown {vm_uid}:{vm_uid} {runtime_dir} && chmod 700 {runtime_dir}",
+                timeout=10,
+            )
+
+            user_env = (
+                f"sudo -u {vm_user} env HOME=/home/{vm_user} USER={vm_user} LOGNAME={vm_user} XDG_RUNTIME_DIR={runtime_dir}"
+            )
+
+            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 --version >/dev/null 2>&1 && 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 = ""
+            pending = False
+
+            if installed is True:
+                launched = _run_test(app)
+                if launched is None:
+                    note = "test failed to execute"
+                elif launched is False and setup_in_progress:
+                    pending = True
+                    note = note or "setup in progress"
+            elif installed is False:
+                if setup_in_progress:
+                    pending = True
+                    note = "setup in progress"
+                else:
+                    note = "not installed"
+            else:
+                note = "install status unknown"
+
+            installed_icon = (
+                "[green]✅[/]"
+                if installed is True
+                else ("[yellow]⏳[/]" if pending else "[red]❌[/]")
+                if installed is False
+                else "[dim]?[/]"
+            )
+            launch_icon = (
+                "[green]✅[/]"
+                if launched is True
+                else ("[yellow]⏳[/]" if pending 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 pending:
+                self.results["smoke"]["skipped"] += 1
+            elif 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,
+                    "pending": pending,
+                }
+            )
+
+        self.console.print(table)
+        return self.results["smoke"]