clonebox 0.1.20__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()
@@ -653,6 +759,7 @@ def interactive_mode():
     summary_table.add_row("Name", vm_name)
     summary_table.add_row("RAM", f"{ram_mb} MB")
     summary_table.add_row("vCPUs", str(vcpus))
+    summary_table.add_row("Disk", f"{20 if enable_gui else 10} GB")
     summary_table.add_row("Services", ", ".join(selected_services) or "None")
     summary_table.add_row(
         "Packages",
@@ -684,6 +791,7 @@ def interactive_mode():
         name=vm_name,
         ram_mb=ram_mb,
         vcpus=vcpus,
+        disk_size_gb=20 if enable_gui else 10,
         gui=enable_gui,
         base_image=base_image if base_image else None,
         paths=paths_mapping,
@@ -732,6 +840,7 @@ def cmd_create(args):
         name=args.name,
         ram_mb=args.ram,
         vcpus=args.vcpus,
+        disk_size_gb=getattr(args, "disk_size_gb", 10),
         gui=not args.no_gui,
         base_image=args.base_image,
         paths=config_data.get("paths", {}),
@@ -1441,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
@@ -1633,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
@@ -1708,6 +1826,7 @@ def generate_clonebox_yaml(
     vm_name: str = None,
     network_mode: str = "auto",
     base_image: Optional[str] = None,
+    disk_size_gb: Optional[int] = None,
 ) -> str:
     """Generate YAML config from system snapshot."""
     sys_info = detector.get_system_info()
@@ -1813,6 +1932,9 @@ def generate_clonebox_yaml(
     ram_mb = min(4096, int(sys_info["memory_available_gb"] * 1024 * 0.5))
     vcpus = max(2, sys_info["cpu_count"] // 2)
 
+    if disk_size_gb is None:
+        disk_size_gb = 20
+
     # Auto-detect packages from running applications and services
     app_packages = detector.suggest_packages_for_apps(snapshot.applications)
     service_packages = detector.suggest_packages_for_services(snapshot.running_services)
@@ -1871,6 +1993,7 @@ def generate_clonebox_yaml(
             "name": vm_name,
             "ram_mb": ram_mb,
             "vcpus": vcpus,
+            "disk_size_gb": disk_size_gb,
             "gui": True,
             "base_image": base_image,
             "network_mode": network_mode,
@@ -2024,6 +2147,7 @@ def create_vm_from_config(
         name=config["vm"]["name"],
         ram_mb=config["vm"].get("ram_mb", 4096),
         vcpus=config["vm"].get("vcpus", 4),
+        disk_size_gb=config["vm"].get("disk_size_gb", 10),
         gui=config["vm"].get("gui", True),
         base_image=config["vm"].get("base_image"),
         paths=all_paths,
@@ -2103,6 +2227,7 @@ def cmd_clone(args):
         vm_name=vm_name,
         network_mode=args.network,
         base_image=getattr(args, "base_image", None),
+        disk_size_gb=getattr(args, "disk_size_gb", None),
     )
 
     profile_name = getattr(args, "profile", None)
@@ -2345,6 +2470,12 @@ def main():
     )
     create_parser.add_argument("--ram", type=int, default=4096, help="RAM in MB")
     create_parser.add_argument("--vcpus", type=int, default=4, help="Number of vCPUs")
+    create_parser.add_argument(
+        "--disk-size-gb",
+        type=int,
+        default=10,
+        help="Root disk size in GB (default: 10)",
+    )
     create_parser.add_argument("--base-image", help="Path to base qcow2 image")
     create_parser.add_argument("--no-gui", action="store_true", help="Disable SPICE graphics")
     create_parser.add_argument("--start", "-s", action="store_true", help="Start VM after creation")
@@ -2551,6 +2682,12 @@ def main():
         "--base-image",
         help="Path to a bootable qcow2 image to use as a base disk",
     )
+    clone_parser.add_argument(
+        "--disk-size-gb",
+        type=int,
+        default=None,
+        help="Root disk size in GB (default: 20 for generated configs)",
+    )
     clone_parser.add_argument(
         "--profile",
         help="Profile name (loads ~/.clonebox.d/<name>.yaml, .clonebox.d/<name>.yaml, or built-in templates)",
@@ -2607,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(
@@ -2652,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()