clonebox 0.1.21__tar.gz → 0.1.22__tar.gz

{clonebox-0.1.21/src/clonebox.egg-info → clonebox-0.1.22}/PKG-INFO

@@ -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 → clonebox-0.1.22}/README.md

@@ -226,6 +226,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 → clonebox-0.1.22}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "clonebox"
-version = "0.1.21"
+version = "0.1.22"
 description = "Clone your workstation environment to an isolated VM with selective apps, paths and services"
 readme = "README.md"
 license = {text = "Apache-2.0"}

{clonebox-0.1.21 → clonebox-0.1.22}/src/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-0.1.21 → clonebox-0.1.22}/src/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...'")