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

clonebox/validation/disk.py

@@ -0,0 +1,149 @@
+from typing import Dict, List, Optional, Tuple
+
+from rich.table import Table
+
+
+class DiskValidationMixin:
+    def validate_disk_space(self) -> Dict:
+        """Validate disk space on root filesystem."""
+        setup_in_progress = self._setup_in_progress() is True
+        self.console.print("\n[bold]💾 Validating Disk Space...[/]")
+
+        df_output = self._exec_in_vm("df -h / --output=pcent,avail,size | tail -n 1", timeout=20)
+        if not df_output:
+            self.console.print("[red]❌ Could not check disk space[/]")
+            return {"status": "error"}
+
+        try:
+            parts = df_output.split()
+            usage_pct = int(parts[0].replace("%", ""))
+            avail = parts[1]
+            total = parts[2]
+
+            self.results["disk"] = {"usage_pct": usage_pct, "avail": avail, "total": total}
+
+            if usage_pct > 90:
+                self.console.print(
+                    f"[red]❌ Disk nearly full: {usage_pct}% used ({avail} available of {total})[/]"
+                )
+                status = "fail"
+            elif usage_pct > 85:
+                self.console.print(
+                    f"[yellow]⚠️  Disk usage high: {usage_pct}% used ({avail} available of {total})[/]"
+                )
+                status = "warning"
+            else:
+                self.console.print(
+                    f"[green]✅ Disk space OK: {usage_pct}% used ({avail} available of {total})[/]"
+                )
+                status = "pass"
+
+            if usage_pct > 80:
+                self._print_disk_usage_breakdown()
+
+            return self.results["disk"]
+        except Exception as e:
+            self.console.print(f"[red]❌ Error parsing df output: {e}[/]")
+            return {"status": "error"}
+
+    def _print_disk_usage_breakdown(self) -> None:
+        def _parse_du_lines(out: Optional[str]) -> List[Tuple[str, str]]:
+            if not out:
+                return []
+            rows: List[Tuple[str, str]] = []
+            for line in out.splitlines():
+                line = line.strip()
+                if not line:
+                    continue
+                parts = line.split(maxsplit=1)
+                if len(parts) != 2:
+                    continue
+                size, path = parts
+                rows.append((path, size))
+            return rows
+
+        def _dir_size(path: str, timeout: int = 30) -> Optional[str]:
+            out = self._exec_in_vm(
+                f"du -x -s -h {path} 2>/dev/null | head -n 1 | cut -f1", timeout=timeout
+            )
+            return out.strip() if out else None
+
+        self.console.print("\n[bold]📁 Disk usage breakdown (largest directories)[/]")
+
+        top_level = self._exec_in_vm(
+            "du -x -h --max-depth=1 / 2>/dev/null | sort -hr | head -n 15",
+            timeout=60,
+        )
+        top_rows = _parse_du_lines(top_level)
+
+        if top_rows:
+            table = Table(title="Disk Usage: / (Top 15)", border_style="cyan")
+            table.add_column("Path", style="bold")
+            table.add_column("Size", justify="right")
+            for path, size in top_rows:
+                table.add_row(path, size)
+            self.console.print(table)
+        else:
+            self.console.print("[dim]Could not compute top-level directory sizes (du may be busy)[/]")
+
+        var_sz = _dir_size("/var")
+        home_sz = _dir_size("/home")
+        if var_sz or home_sz:
+            sum_table = Table(title="Disk Usage: Key Directories", border_style="cyan")
+            sum_table.add_column("Path", style="bold")
+            sum_table.add_column("Size", justify="right")
+            for p in [
+                "/var",
+                "/var/lib",
+                "/var/log",
+                "/var/cache",
+                "/var/lib/snapd",
+                "/home",
+                "/home/ubuntu",
+                "/tmp",
+            ]:
+                sz = _dir_size(p, timeout=30)
+                if sz:
+                    sum_table.add_row(p, sz)
+            self.console.print(sum_table)
+
+        var_breakdown = self._exec_in_vm(
+            "du -x -h --max-depth=1 /var 2>/dev/null | sort -hr | head -n 12",
+            timeout=60,
+        )
+        var_rows = _parse_du_lines(var_breakdown)
+        if var_rows:
+            vtable = Table(title="Disk Usage: /var (Top 12)", border_style="cyan")
+            vtable.add_column("Path", style="bold")
+            vtable.add_column("Size", justify="right")
+            for path, size in var_rows:
+                vtable.add_row(path, size)
+            self.console.print(vtable)
+
+        home_breakdown = self._exec_in_vm(
+            "du -x -h --max-depth=2 /home/ubuntu 2>/dev/null | sort -hr | head -n 12",
+            timeout=60,
+        )
+        home_rows = _parse_du_lines(home_breakdown)
+        if home_rows:
+            htable = Table(title="Disk Usage: /home/ubuntu (Top 12)", border_style="cyan")
+            htable.add_column("Path", style="bold")
+            htable.add_column("Size", justify="right")
+            for path, size in home_rows:
+                htable.add_row(path, size)
+            self.console.print(htable)
+
+        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", {})
+        if copy_paths:
+            ctable = Table(title="Disk Usage: Configured Imported Paths", border_style="cyan")
+            ctable.add_column("Guest Path", style="bold")
+            ctable.add_column("Size", justify="right")
+            for _, guest_path in copy_paths.items():
+                sz = _dir_size(guest_path, timeout=30)
+                if sz:
+                    ctable.add_row(str(guest_path), sz)
+                else:
+                    ctable.add_row(str(guest_path), "—")
+            self.console.print(ctable)

clonebox/validation/mounts.py

@@ -0,0 +1,128 @@
+from typing import Dict
+
+from rich.table import Table
+
+
+class MountValidationMixin:
+    def validate_mounts(self) -> Dict:
+        """Validate all mount points and copied data paths."""
+        setup_in_progress = self._setup_in_progress_cache is True
+        self.console.print("\n[bold]💾 Validating Mounts & Data...[/]")
+
+        paths = self.config.get("paths", {})
+        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", {})
+
+        if not paths and not copy_paths:
+            self.console.print("[dim]No mounts or data paths configured[/]")
+            return self.results["mounts"]
+
+        mount_output = self._exec_in_vm("mount | grep 9p")
+        mounted_paths = []
+        if mount_output:
+            for line in mount_output.split("\n"):
+                line = line.strip()
+                if not line:
+                    continue
+                parts = line.split()
+                if len(parts) >= 3:
+                    mounted_paths.append(parts[2])
+
+        mount_table = Table(title="Data Validation", border_style="cyan")
+        mount_table.add_column("Guest Path", style="bold")
+        mount_table.add_column("Type", justify="center")
+        mount_table.add_column("Status", justify="center")
+        mount_table.add_column("Files", justify="right")
+
+        for host_path, guest_path in paths.items():
+            self.results["mounts"]["total"] += 1
+
+            is_mounted = any(guest_path in mp for mp in mounted_paths)
+
+            accessible = False
+            file_count = "?"
+
+            if is_mounted:
+                test_result = self._exec_in_vm(f"test -d {guest_path} && echo 'yes' || echo 'no'")
+                accessible = test_result == "yes"
+
+                if accessible:
+                    count_str = self._exec_in_vm(f"ls -A {guest_path} 2>/dev/null | wc -l")
+                    if count_str and count_str.isdigit():
+                        file_count = count_str
+
+            if is_mounted and accessible:
+                status_icon = "[green]✅ Mounted[/]"
+                self.results["mounts"]["passed"] += 1
+                status = "pass"
+            elif is_mounted:
+                status_icon = "[red]❌ Inaccessible[/]"
+                self.results["mounts"]["failed"] += 1
+                status = "mounted_but_inaccessible"
+            elif setup_in_progress:
+                status_icon = "[yellow]⏳ Pending[/]"
+                status = "pending"
+                self.results["mounts"]["skipped"] += 1
+            else:
+                status_icon = "[red]❌ Not Mounted[/]"
+                self.results["mounts"]["failed"] += 1
+                status = "not_mounted"
+
+            mount_table.add_row(guest_path, "Bind Mount", status_icon, str(file_count))
+            self.results["mounts"]["details"].append(
+                {
+                    "path": guest_path,
+                    "type": "mount",
+                    "mounted": is_mounted,
+                    "accessible": accessible,
+                    "files": file_count,
+                    "status": status,
+                }
+            )
+
+        for host_path, guest_path in copy_paths.items():
+            self.results["mounts"]["total"] += 1
+
+            exists = False
+            file_count = "?"
+
+            test_result = self._exec_in_vm(f"test -d {guest_path} && echo 'yes' || echo 'no'")
+            exists = test_result == "yes"
+
+            if exists:
+                count_str = self._exec_in_vm(f"ls -A {guest_path} 2>/dev/null | wc -l")
+                if count_str and count_str.isdigit():
+                    file_count = count_str
+
+            if exists:
+                status_icon = "[green]✅ Copied[/]"
+                self.results["mounts"]["passed"] += 1
+                status = "pass"
+            elif setup_in_progress:
+                status_icon = "[yellow]⏳ Pending[/]"
+                status = "pending"
+                self.results["mounts"]["skipped"] += 1
+            else:
+                status_icon = "[red]❌ Missing[/]"
+                self.results["mounts"]["failed"] += 1
+                status = "missing"
+
+            mount_table.add_row(guest_path, "Imported", status_icon, str(file_count))
+            self.results["mounts"]["details"].append(
+                {
+                    "path": guest_path,
+                    "type": "copy",
+                    "mounted": False,
+                    "accessible": exists,
+                    "files": file_count,
+                    "status": status,
+                }
+            )
+
+        self.console.print(mount_table)
+        self.console.print(
+            f"[dim]{self.results['mounts']['passed']}/{self.results['mounts']['total']} paths valid[/]"
+        )
+
+        return self.results["mounts"]

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"]