clonebox 1.1.14__py3-none-any.whl → 1.1.16__py3-none-any.whl

clonebox/cloner.py

@@ -35,6 +35,7 @@ from clonebox.logging import get_logger, log_operation
 from clonebox.resources import ResourceLimits
 from clonebox.rollback import vm_creation_transaction
 from clonebox.secrets import SecretsManager, SSHKeyPair
+from clonebox.audit import get_audit_logger, AuditEventType, AuditOutcome
 
 log = get_logger(__name__)
 
@@ -365,121 +366,131 @@ class SelectiveVMCloner:
         Returns:
             UUID of created VM
         """
-        with log_operation(
-            log, "vm.create", vm_name=config.name, ram_mb=config.ram_mb
-        ):
-            with vm_creation_transaction(self, config, console) as ctx:
-                # If VM already exists, optionally replace it
-                existing_vm = None
-                try:
-                    candidate_vm = self.conn.lookupByName(config.name)
-                    if candidate_vm is not None:
-                        try:
-                            if hasattr(candidate_vm, "name") and callable(candidate_vm.name):
-                                if candidate_vm.name() == config.name:
+        audit = get_audit_logger()
+        with audit.operation(
+            AuditEventType.VM_CREATE,
+            target_type="vm",
+            target_name=config.name,
+        ) as audit_ctx:
+            audit_ctx.add_detail("ram_mb", config.ram_mb)
+            audit_ctx.add_detail("vcpus", config.vcpus)
+            audit_ctx.add_detail("disk_size_gb", config.disk_size_gb)
+
+            with log_operation(
+                log, "vm.create", vm_name=config.name, ram_mb=config.ram_mb
+            ):
+                with vm_creation_transaction(self, config, console) as ctx:
+                    # If VM already exists, optionally replace it
+                    existing_vm = None
+                    try:
+                        candidate_vm = self.conn.lookupByName(config.name)
+                        if candidate_vm is not None:
+                            try:
+                                if hasattr(candidate_vm, "name") and callable(candidate_vm.name):
+                                    if candidate_vm.name() == config.name:
+                                        existing_vm = candidate_vm
+                                else:
                                     existing_vm = candidate_vm
-                            else:
+                            except Exception:
                                 existing_vm = candidate_vm
-                        except Exception:
-                            existing_vm = candidate_vm
-                except Exception:
-                    existing_vm = None
-
-                if existing_vm is not None:
-                    if not replace:
-                        raise RuntimeError(
-                            f"VM '{config.name}' already exists.\n\n"
+                    except Exception:
+                        existing_vm = None
+
+                    if existing_vm is not None:
+                        if not replace:
+                            raise RuntimeError(
+                                f"VM '{config.name}' already exists.\n\n"
+                                f"🔧 Solutions:\n"
+                                f"  1. Reuse existing VM: clonebox start {config.name}\n"
+                                f"  2. Replace it: clonebox clone . --name {config.name} --replace\n"
+                                f"  3. Delete it: clonebox delete {config.name}\n"
+                            )
+
+                        log.info(f"VM '{config.name}' already exists - replacing...")
+                        self.delete_vm(config.name, delete_storage=True, console=console, ignore_not_found=True)
+
+                    # Determine images directory
+                    images_dir = self.get_images_dir()
+                    try:
+                        vm_dir = ctx.add_directory(images_dir / config.name)
+                        vm_dir.mkdir(parents=True, exist_ok=True)
+                    except PermissionError as e:
+                        raise PermissionError(
+                            f"Cannot create VM directory: {images_dir / config.name}\n\n"
                             f"🔧 Solutions:\n"
-                            f"  1. Reuse existing VM: clonebox start {config.name}\n"
-                            f"  2. Replace it: clonebox clone . --name {config.name} --replace\n"
-                            f"  3. Delete it: clonebox delete {config.name}\n"
-                        )
-
-                    log.info(f"VM '{config.name}' already exists - replacing...")
-                    self.delete_vm(config.name, delete_storage=True, console=console, ignore_not_found=True)
-
-                # Determine images directory
-                images_dir = self.get_images_dir()
-                try:
-                    vm_dir = ctx.add_directory(images_dir / config.name)
-                    vm_dir.mkdir(parents=True, exist_ok=True)
-                except PermissionError as e:
-                    raise PermissionError(
-                        f"Cannot create VM directory: {images_dir / config.name}\n\n"
-                        f"🔧 Solutions:\n"
-                        f"  1. Use --user flag to run in user session (recommended):\n"
-                        f"     clonebox clone . --user\n\n"
-                        f"  2. Run with sudo (not recommended):\n"
-                        f"     sudo clonebox clone .\n\n"
-                        f"  3. Fix directory permissions:\n"
-                        f"     sudo mkdir -p {images_dir}\n"
-                        f"     sudo chown -R $USER:libvirt {images_dir}\n\n"
-                        f"Original error: {e}"
-                    ) from e
-
-                # Create root disk
-                root_disk = ctx.add_file(vm_dir / "root.qcow2")
-
-                if not config.base_image:
-                    config.base_image = str(self._ensure_default_base_image(console=console))
-
-                if config.base_image and Path(config.base_image).exists():
-                    # Use backing file for faster creation
-                    log.debug(f"Creating disk with backing file: {config.base_image}")
-                    cmd = [
-                        "qemu-img",
-                        "create",
-                        "-f",
-                        "qcow2",
-                        "-b",
-                        config.base_image,
-                        "-F",
-                        "qcow2",
-                        str(root_disk),
-                        f"{config.disk_size_gb}G",
-                    ]
-                else:
-                    # Create empty disk
-                    log.debug(f"Creating empty {config.disk_size_gb}GB disk...")
-                    cmd = ["qemu-img", "create", "-f", "qcow2", str(root_disk), f"{config.disk_size_gb}G"]
-
-                subprocess.run(cmd, check=True, capture_output=True)
-
-                # Create cloud-init ISO if packages/services specified
-                cloudinit_iso = None
-                if (
-                    config.packages
-                    or config.services
-                    or config.snap_packages
-                    or config.post_commands
-                    or config.gui
-                ):
-                    cloudinit_iso = ctx.add_file(self._create_cloudinit_iso(vm_dir, config))
-                    log.info(f"Created cloud-init ISO with {len(config.packages)} packages")
-
-                # Generate VM XML
-                vm_xml = self._generate_vm_xml(config, root_disk, cloudinit_iso)
-                ctx.add_libvirt_domain(self.conn, config.name)
-
-                # Define VM
-                log.info(f"Defining VM '{config.name}'...")
-                try:
-                    vm = self.conn.defineXML(vm_xml)
-                except Exception as e:
-                    raise RuntimeError(
-                        f"Failed to define VM '{config.name}'.\n"
-                        f"Error: {e}\n\n"
-                        f"If the VM already exists, try: clonebox clone . --name {config.name} --replace\n"
-                    ) from e
+                            f"  1. Use --user flag to run in user session (recommended):\n"
+                            f"     clonebox clone . --user\n\n"
+                            f"  2. Run with sudo (not recommended):\n"
+                            f"     sudo clonebox clone .\n\n"
+                            f"  3. Fix directory permissions:\n"
+                            f"     sudo mkdir -p {images_dir}\n"
+                            f"     sudo chown -R $USER:libvirt {images_dir}\n\n"
+                            f"Original error: {e}"
+                        ) from e
+
+                    # Create root disk
+                    root_disk = ctx.add_file(vm_dir / "root.qcow2")
+
+                    if not config.base_image:
+                        config.base_image = str(self._ensure_default_base_image(console=console))
+
+                    if config.base_image and Path(config.base_image).exists():
+                        # Use backing file for faster creation
+                        log.debug(f"Creating disk with backing file: {config.base_image}")
+                        cmd = [
+                            "qemu-img",
+                            "create",
+                            "-f",
+                            "qcow2",
+                            "-b",
+                            config.base_image,
+                            "-F",
+                            "qcow2",
+                            str(root_disk),
+                            f"{config.disk_size_gb}G",
+                        ]
+                    else:
+                        # Create empty disk
+                        log.debug(f"Creating empty {config.disk_size_gb}GB disk...")
+                        cmd = ["qemu-img", "create", "-f", "qcow2", str(root_disk), f"{config.disk_size_gb}G"]
+
+                    subprocess.run(cmd, check=True, capture_output=True)
+
+                    # Create cloud-init ISO if packages/services specified
+                    cloudinit_iso = None
+                    if (
+                        config.packages
+                        or config.services
+                        or config.snap_packages
+                        or config.post_commands
+                        or config.gui
+                    ):
+                        cloudinit_iso = ctx.add_file(self._create_cloudinit_iso(vm_dir, config, self.user_session))
+                        log.info(f"Created cloud-init ISO with {len(config.packages)} packages")
+
+                    # Generate VM XML
+                    vm_xml = self._generate_vm_xml(config, root_disk, cloudinit_iso)
+                    ctx.add_libvirt_domain(self.conn, config.name)
+
+                    # Define VM
+                    log.info(f"Defining VM '{config.name}'...")
+                    try:
+                        vm = self.conn.defineXML(vm_xml)
+                    except Exception as e:
+                        raise RuntimeError(
+                            f"Failed to define VM '{config.name}'.\n"
+                            f"Error: {e}\n\n"
+                            f"If the VM already exists, try: clonebox clone . --name {config.name} --replace\n"
+                        ) from e
 
-                # Start if autostart requested
-                if getattr(config, "autostart", False):
-                    self.start_vm(config.name, open_viewer=True)
+                    # Start if autostart requested
+                    if getattr(config, "autostart", False):
+                        self.start_vm(config.name, open_viewer=True)
 
-                # All good - commit transaction
-                ctx.commit()
+                    # All good - commit transaction
+                    ctx.commit()
 
-                return vm.UUIDString()
+                    return vm.UUIDString()
 
     def _generate_vm_xml(
         self, config: VMConfig = None, root_disk: Path = None, cloudinit_iso: Optional[Path] = None
@@ -706,6 +717,9 @@ class SelectiveVMCloner:
             for snap, ifaces in SNAP_INTERFACES.items()
         )
 
+        mount_points_bash = "\n".join(str(p) for p in (config.paths or {}).values())
+        copy_paths_bash = "\n".join(str(p) for p in (config.copy_paths or {}).values())
+
         script = f"""#!/bin/bash
 set -uo pipefail
 LOG="/var/log/clonebox-boot.log"
@@ -1000,12 +1014,23 @@ for app in "${{APPS_TO_TEST[@]}}"; do
     fi
 done
 
-section "5/7" "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
+section "5/7" "Checking mounts & imported paths..."
+write_status "checking_mounts" "checking mounts & imported paths"
+
+MOUNT_POINTS=$(cat <<'EOF'
+{mount_points_bash}
+EOF
+)
+
+COPIED_PATHS=$(cat <<'EOF'
+{copy_paths_bash}
+EOF
+)
+
+# Bind mounts (shared live)
+if [ -n "$(echo "$MOUNT_POINTS" | tr -d '[:space:]')" ]; then
+    while IFS= read -r mp; do
+        [ -z "$mp" ] && continue
         if mountpoint -q "$mp" 2>/dev/null; then
             ok "$mp mounted"
         else
@@ -1018,8 +1043,28 @@ while IFS= read -r line; do
                 fail "$mp mount FAILED"
             fi
         fi
-    fi
-done < /etc/fstab
+    done <<< "$MOUNT_POINTS"
+else
+    log "    (no bind mounts configured)"
+fi
+
+# Imported/copied paths (one-time import)
+if [ -n "$(echo "$COPIED_PATHS" | tr -d '[:space:]')" ]; then
+    while IFS= read -r p; do
+        [ -z "$p" ] && continue
+        if [ -d "$p" ]; then
+            if [ "$(ls -A "$p" 2>/dev/null | wc -l)" -gt 0 ]; then
+                ok "$p copied"
+            else
+                ok "$p copied (empty)"
+            fi
+        else
+            fail "$p missing (copy)"
+        fi
+    done <<< "$COPIED_PATHS"
+else
+    log "    (no copied paths configured)"
+fi
 
 section "6/7" "Checking services..."
 write_status "checking_services" "checking services"
@@ -1077,6 +1122,12 @@ fi
         mount_checks = []
         for idx, (host_path, guest_path) in enumerate(config.paths.items()):
             mount_checks.append(f'check_mount "{guest_path}" "mount{idx}"')
+        
+        # Add copied paths checks
+        copy_paths = config.copy_paths or config.app_data_paths
+        if copy_paths:
+            for idx, (host_path, guest_path) in enumerate(copy_paths.items()):
+                mount_checks.append(f'check_copy_path "{guest_path}"')
 
         apt_checks_str = "\n".join(apt_checks) if apt_checks else "echo 'No apt packages to check'"
         snap_checks_str = (
@@ -1183,6 +1234,30 @@ check_mount() {{
         log "[INFO] Mount point '$path' does not exist yet"
         return 0
     fi
+}
+
+check_copy_path() {
+    local path="$1"
+    if [ -d "$path" ]; then
+        if [ "$(ls -A "$path" 2>/dev/null | wc -l)" -gt 0 ]; then
+            log "[PASS] Path '$path' exists and contains data"
+            ((PASSED++))
+            return 0
+        else
+            log "[WARN] Path '$path' exists but is EMPTY"
+            ((WARNINGS++))
+            return 1
+        fi
+    else
+        if [ $SETUP_IN_PROGRESS -eq 1 ]; then
+            log "[INFO] Path '$path' not imported yet"
+            return 0
+        else
+            log "[FAIL] Path '$path' MISSING"
+            ((FAILED++))
+            return 1
+        fi
+    fi
 }}
 
 check_gui() {{
@@ -1262,7 +1337,7 @@ fi
         encoded = base64.b64encode(script.encode()).decode()
         return encoded
 
-    def _create_cloudinit_iso(self, vm_dir: Path, config: VMConfig) -> Path:
+    def _create_cloudinit_iso(self, vm_dir: Path, config: VMConfig, user_session: bool = False) -> Path:
         """Create cloud-init ISO with secure credential handling."""
         secrets_mgr = SecretsManager()
 
@@ -1287,6 +1362,17 @@ fi
                 ssh_authorized_keys = [key_pair.public_key]
                 log.info(f"SSH key generated and saved to: {ssh_key_path}")
 
+            local_password = getattr(config, "password", None)
+            if getattr(config, "gui", False) and local_password:
+                chpasswd_config = (
+                    "chpasswd:\n"
+                    "  list: |\n"
+                    f"    {config.username}:{local_password}\n"
+                    "  expire: False"
+                )
+                lock_passwd = "false"
+                ssh_pwauth = "true"
+
         elif auth_method == "one_time_password":
             otp, chpasswd_raw = SecretsManager.generate_one_time_password()
             chpasswd_config = chpasswd_raw
@@ -1356,37 +1442,38 @@ fi
 
         # Handle copy_paths (import then copy)
         all_copy_paths = dict(config.copy_paths) if config.copy_paths else {}
-        for idx, (host_path, guest_path) in enumerate(all_copy_paths.items()):
-            if Path(host_path).exists():
-                tag = f"import{idx}"
-                temp_mount_point = f"/mnt/import{idx}"
-                # Use regular mount options
-                mount_opts = "trans=virtio,version=9p2000.L,mmap,uid=1000,gid=1000"
-
-                # 1. Create temp mount point
-                mount_commands.append(f"  - mkdir -p {temp_mount_point}")
-                
-                # 2. Mount the 9p share
-                mount_commands.append(f"  - mount -t 9p -o {mount_opts} {tag} {temp_mount_point} || true")
-                
-                # 3. Ensure target directory exists and permissions are prepared
-                if str(guest_path).startswith("/home/ubuntu/"):
-                    mount_commands.append(f"  - mkdir -p {guest_path}")
-                    mount_commands.append(f"  - chown 1000:1000 {guest_path}")
-                else:
-                    mount_commands.append(f"  - mkdir -p {guest_path}")
+        existing_copy_paths = {h: g for h, g in all_copy_paths.items() if Path(h).exists()}
+        
+        for idx, (host_path, guest_path) in enumerate(existing_copy_paths.items()):
+            tag = f"import{idx}"
+            temp_mount_point = f"/mnt/import{idx}"
+            # Use regular mount options
+            mount_opts = "trans=virtio,version=9p2000.L,mmap,uid=1000,gid=1000"
+
+            # 1. Create temp mount point
+            mount_commands.append(f"  - mkdir -p {temp_mount_point}")
+            
+            # 2. Mount the 9p share
+            mount_commands.append(f"  - mount -t 9p -o {mount_opts} {tag} {temp_mount_point} || true")
+            
+            # 3. Ensure target directory exists and permissions are prepared
+            if str(guest_path).startswith("/home/ubuntu/"):
+                mount_commands.append(f"  - mkdir -p {guest_path}")
+                mount_commands.append(f"  - chown 1000:1000 {guest_path}")
+            else:
+                mount_commands.append(f"  - mkdir -p {guest_path}")
 
-                # 4. Copy contents (cp -rT to copy contents of source to target)
-                # We use || true to ensure boot continues even if copy fails
-                mount_commands.append(f"  - echo 'Importing {host_path} to {guest_path}...'")
-                mount_commands.append(f"  - cp -rT {temp_mount_point} {guest_path} || true")
-                
-                # 5. Fix ownership recursively
-                mount_commands.append(f"  - chown -R 1000:1000 {guest_path}")
+            # 4. Copy contents (cp -rT to copy contents of source to target)
+            # We use || true to ensure boot continues even if copy fails
+            mount_commands.append(f"  - echo 'Importing {host_path} to {guest_path}...'")
+            mount_commands.append(f"  - cp -rT {temp_mount_point} {guest_path} || true")
+            
+            # 5. Fix ownership recursively
+            mount_commands.append(f"  - chown -R 1000:1000 {guest_path}")
 
-                # 6. Unmount and cleanup
-                mount_commands.append(f"  - umount {temp_mount_point} || true")
-                mount_commands.append(f"  - rmdir {temp_mount_point} || true")
+            # 6. Unmount and cleanup
+            mount_commands.append(f"  - umount {temp_mount_point} || true")
+            mount_commands.append(f"  - rmdir {temp_mount_point} || true")
 
         # User-data
         # Add desktop environment if GUI is enabled
@@ -1405,31 +1492,82 @@ fi
         # Build runcmd - services, mounts, snaps, post_commands
         runcmd_lines = []
 
+        # Add detailed logging header
+        runcmd_lines.append("  - echo '═══════════════════════════════════════════════════════════'")
+        runcmd_lines.append("  - echo '           CloneBox VM Installation Progress'")
+        runcmd_lines.append("  - echo '═══════════════════════════════════════════════════════════'")
+        runcmd_lines.append("  - echo ''")
+        
+        # Phase 1: APT Packages
+        if all_packages:
+            runcmd_lines.append(f"  - echo '[1/9] 📦 Installing APT packages ({len(all_packages)} total)...'")
+            runcmd_lines.append("  - export DEBIAN_FRONTEND=noninteractive")
+            runcmd_lines.append("  - apt-get update")
+            for i, pkg in enumerate(all_packages, 1):
+                runcmd_lines.append(f"  - echo '  → [{i}/{len(all_packages)}] Installing {pkg}...'")
+                runcmd_lines.append(f"  - apt-get install -y {pkg} || echo '    ⚠️  Failed to install {pkg}'")
+            runcmd_lines.append("  - echo '  ✓ APT packages installed'")
+            runcmd_lines.append("  - echo ''")
+        else:
+            runcmd_lines.append("  - echo '[1/9] 📦 No APT packages to install'")
+            runcmd_lines.append("  - echo ''")
+
+        # Phase 2: Core services
+        runcmd_lines.append("  - echo '[2/9] 🔧 Enabling core services...'")
+        runcmd_lines.append("  - echo '  → qemu-guest-agent'")
         runcmd_lines.append("  - systemctl enable --now qemu-guest-agent || true")
+        runcmd_lines.append("  - echo '  → snapd'")
         runcmd_lines.append("  - systemctl enable --now snapd || true")
+        runcmd_lines.append("  - echo '  → Waiting for snap system seed...'")
         runcmd_lines.append("  - timeout 300 snap wait system seed.loaded || true")
+        runcmd_lines.append("  - echo '  ✓ Core services enabled'")
+        runcmd_lines.append("  - echo ''")
 
-        # Add service enablement
-        for svc in config.services:
+        # Phase 3: User services
+        runcmd_lines.append(f"  - echo '[3/9] 🔧 Enabling user services ({len(config.services)} total)...'")
+        for i, svc in enumerate(config.services, 1):
+            runcmd_lines.append(f"  - echo '  → [{i}/{len(config.services)}] {svc}'")
             runcmd_lines.append(f"  - systemctl enable --now {svc} || true")
+        runcmd_lines.append("  - echo '  ✓ User services enabled'")
+        runcmd_lines.append("  - echo ''")
 
-        # Add fstab entries for persistent mounts after reboot
+        # Phase 4: Filesystem mounts
+        runcmd_lines.append(f"  - echo '[4/9] 📁 Mounting shared directories ({len(fstab_entries)} mounts)...'")
         if fstab_entries:
             runcmd_lines.append(
                 "  - grep -q '^# CloneBox 9p mounts' /etc/fstab || echo '# CloneBox 9p mounts' >> /etc/fstab"
             )
-            for entry in fstab_entries:
+            for i, entry in enumerate(fstab_entries, 1):
+                mount_point = entry.split()[1] if len(entry.split()) > 1 else entry
+                runcmd_lines.append(f"  - echo '  → [{i}/{len(fstab_entries)}] {mount_point}'")
                 runcmd_lines.append(
                     f"  - grep -qF \"{entry}\" /etc/fstab || echo '{entry}' >> /etc/fstab"
                 )
             runcmd_lines.append("  - mount -a || true")
+        runcmd_lines.append("  - echo '  ✓ Mounts configured'")
+        runcmd_lines.append("  - echo ''")
+
+        # Phase 5: Data Import (copied paths)
+        if existing_copy_paths:
+            runcmd_lines.append(f"  - echo '[5/9] 📥 Importing data ({len(existing_copy_paths)} paths)...'")
+            # Add mounts (immediate, before reboot)
+            import_count = 0
+            for cmd in mount_commands:
+                if "Importing" in cmd:
+                    import_count += 1
+                    runcmd_lines.append(cmd.replace("Importing", f"  → [{import_count}/{len(existing_copy_paths)}] Importing"))
+                else:
+                    runcmd_lines.append(cmd)
+            runcmd_lines.append("  - echo '  ✓ Data import completed'")
+            runcmd_lines.append("  - echo ''")
+        else:
+            runcmd_lines.append("  - echo '[5/9] 📥 No data to import'")
+            runcmd_lines.append("  - echo ''")
 
-        # Add mounts (immediate, before reboot)
-        for cmd in mount_commands:
-            runcmd_lines.append(cmd)
-
-        # Create user directories with correct permissions EARLY to avoid race conditions with GDM
+        # Phase 6: GUI Environment Setup
         if config.gui:
+            runcmd_lines.append("  - echo '[6/9] 🖥️  Setting up GUI environment...'")
+            runcmd_lines.append("  - echo '  → Creating user directories'")
             # Create directories that GNOME services need
             runcmd_lines.extend(
                 [
@@ -1439,41 +1577,56 @@ fi
                     "  - chown -R 1000:1000 /home/ubuntu/.config /home/ubuntu/.cache /home/ubuntu/.local",
                     "  - chmod 700 /home/ubuntu/.config /home/ubuntu/.cache",
                     "  - systemctl set-default graphical.target",
-                    "  - systemctl enable --now gdm3 || systemctl enable --now gdm || true",
-                    "  - systemctl start display-manager || true",
+                    "  - echo '  → Starting display manager'",
                 ]
             )
+            runcmd_lines.append("  - systemctl enable --now gdm3 || systemctl enable --now gdm || true")
+            runcmd_lines.append("  - systemctl start display-manager || true")
+            runcmd_lines.append("  - echo '  ✓ GUI environment ready'")
+            runcmd_lines.append("  - echo ''")
+        else:
+            runcmd_lines.append("  - echo '[6/9] 🖥️  No GUI requested'")
+            runcmd_lines.append("  - echo ''")
 
         runcmd_lines.append("  - chown -R 1000:1000 /home/ubuntu || true")
         runcmd_lines.append("  - chown -R 1000:1000 /home/ubuntu/snap || true")
 
-        # Install snap packages (with retry logic)
+        # Phase 7: Snap packages
         if config.snap_packages:
-            runcmd_lines.append("  - echo 'Installing snap packages...'")
-            for snap_pkg in config.snap_packages:
+            runcmd_lines.append(f"  - echo '[7/9] 📦 Installing snap packages ({len(config.snap_packages)} packages)...'")
+            for i, snap_pkg in enumerate(config.snap_packages, 1):
+                runcmd_lines.append(f"  - echo '  → [{i}/{len(config.snap_packages)}] {snap_pkg}'")
                 # Try classic first, then strict, with retries
                 cmd = (
                     f"for i in 1 2 3; do "
-                    f"snap install {snap_pkg} --classic && break || "
-                    f"snap install {snap_pkg} && break || "
-                    f"sleep 10; "
+                    f"snap install {snap_pkg} --classic && echo '    ✓ {snap_pkg} installed (classic)' && break || "
+                    f"snap install {snap_pkg} && echo '    ✓ {snap_pkg} installed' && break || "
+                    f"echo '    ⟳ Retry $i/3...' && sleep 10; "
                     f"done"
                 )
                 runcmd_lines.append(f"  - {cmd}")
+            runcmd_lines.append("  - echo '  ✓ Snap packages installed'")
+            runcmd_lines.append("  - echo ''")
 
             # Connect snap interfaces for GUI apps (not auto-connected via cloud-init)
-            runcmd_lines.append("  - echo 'Connecting snap interfaces...'")
+            runcmd_lines.append(f"  - echo '  🔌 Connecting snap interfaces...'")
             for snap_pkg in config.snap_packages:
+                runcmd_lines.append(f"  - echo '    → {snap_pkg}'")
                 interfaces = SNAP_INTERFACES.get(snap_pkg, DEFAULT_SNAP_INTERFACES)
                 for iface in interfaces:
                     runcmd_lines.append(
                         f"  - snap connect {snap_pkg}:{iface} :{iface} 2>/dev/null || true"
                     )
-
+            runcmd_lines.append("  - echo '    ✓ Snap interfaces connected'")
             runcmd_lines.append("  - systemctl restart snapd || true")
+            runcmd_lines.append("  - echo ''")
+        else:
+            runcmd_lines.append("  - echo '[7/9] 📦 No snap packages to install'")
+            runcmd_lines.append("  - echo ''")
 
         # Add remaining GUI setup if enabled
         if config.gui:
+            runcmd_lines.append("  - echo '  ⚙️  Creating autostart entries...'")
             # Create autostart entries for GUI apps
             autostart_apps = {
                 "pycharm-community": (
@@ -1525,15 +1678,28 @@ Comment=CloneBox autostart
 
             # Fix ownership of autostart directory
             runcmd_lines.append("  - chown -R 1000:1000 /home/ubuntu/.config/autostart")
+            runcmd_lines.append("  - echo '  ✓ Autostart entries created'")
+            runcmd_lines.append("  - echo ''")
 
-        # Run user-defined post commands
+        # Phase 8: Post commands
         if config.post_commands:
-            runcmd_lines.append("  - echo 'Running post-setup commands...'")
-            for cmd in config.post_commands:
+            runcmd_lines.append(f"  - echo '[8/9] ⚙️  Running post-setup commands ({len(config.post_commands)} commands)...'")
+            for i, cmd in enumerate(config.post_commands, 1):
+                # Truncate long commands for display
+                display_cmd = cmd[:60] + '...' if len(cmd) > 60 else cmd
+                runcmd_lines.append(f"  - echo '  → [{i}/{len(config.post_commands)}] {display_cmd}'")
                 runcmd_lines.append(f"  - {cmd}")
+                runcmd_lines.append(f"  - echo '    ✓ Command {i} completed'")
+            runcmd_lines.append("  - echo '  ✓ Post-setup commands completed'")
+            runcmd_lines.append("  - echo ''")
+        else:
+            runcmd_lines.append("  - echo '[8/9] ⚙️  No post-setup commands'")
+            runcmd_lines.append("  - echo ''")
 
         # Generate health check script
         health_script = self._generate_health_check_script(config)
+        # Phase 9: Health checks and finalization
+        runcmd_lines.append("  - echo '[9/9] 🏥 Running health checks...'")
         runcmd_lines.append(
             f"  - echo '{health_script}' | base64 -d > /usr/local/bin/clonebox-health"
         )
@@ -1541,8 +1707,15 @@ Comment=CloneBox autostart
         runcmd_lines.append(
             "  - /usr/local/bin/clonebox-health >> /var/log/clonebox-health.log 2>&1 || true"
         )
+        runcmd_lines.append("  - echo '  ✓ Health checks completed'")
         runcmd_lines.append("  - echo 'CloneBox VM ready!' > /var/log/clonebox-ready")
-
+        
+        # Final status
+        runcmd_lines.append("  - echo ''")
+        runcmd_lines.append("  - echo '═══════════════════════════════════════════════════════════'")
+        runcmd_lines.append("  - echo '           ✅ CloneBox VM Installation Complete!'")
+        runcmd_lines.append("  - echo '═══════════════════════════════════════════════════════════'")
+        runcmd_lines.append("  - echo ''")
         # Generate boot diagnostic script (self-healing)
         boot_diag_script = self._generate_boot_diagnostic_script(config)
         runcmd_lines.append(
@@ -2273,25 +2446,32 @@ if __name__ == "__main__":
         # Note: The bash monitor is already installed above, no need to install Python monitor
 
         # Create logs disk for host access
+        # Use different paths based on session type
+        if user_session:
+            logs_disk_path = str(Path.home() / ".local/share/libvirt/images/clonebox-logs.qcow2")
+        else:
+            logs_disk_path = "/var/lib/libvirt/images/clonebox-logs.qcow2"
+        
         runcmd_lines.extend(
             [
                 "  - mkdir -p /mnt/logs",
-                "  - truncate -s 1G /var/lib/libvirt/images/clonebox-logs.qcow2",
-                "  - mkfs.ext4 -F /var/lib/libvirt/images/clonebox-logs.qcow2",
-                "  - echo '/var/lib/libvirt/images/clonebox-logs.qcow2 /mnt/logs ext4 loop,defaults 0 0' >> /etc/fstab",
+                f"  - truncate -s 1G {logs_disk_path}",
+                f"  - mkfs.ext4 -F {logs_disk_path}",
+                f"  - echo '{logs_disk_path} /mnt/logs ext4 loop,defaults 0 0' >> /etc/fstab",
                 "  - mount -a",
                 "  - mkdir -p /mnt/logs/var/log",
                 "  - mkdir -p /mnt/logs/tmp",
                 "  - cp -r /var/log/clonebox*.log /mnt/logs/var/log/ 2>/dev/null || true",
                 "  - cp -r /tmp/*-error.log /mnt/logs/tmp/ 2>/dev/null || true",
-                "  - echo 'Logs disk mounted at /mnt/logs - accessible from host as /var/lib/libvirt/images/clonebox-logs.qcow2'",
-                "  - \"echo 'To view logs on host: sudo mount -o loop /var/lib/libvirt/images/clonebox-logs.qcow2 /mnt/clonebox-logs'\"",
+                f"  - echo 'Logs disk mounted at /mnt/logs - accessible from host as {logs_disk_path}'",
+                f"  - \"echo 'To view logs on host: sudo mount -o loop {logs_disk_path} /mnt/clonebox-logs'\"",
             ]
         )
 
         # Add reboot command at the end if GUI is enabled
         if config.gui:
-            runcmd_lines.append("  - echo 'Rebooting in 10 seconds to start GUI...'")
+            runcmd_lines.append("  - echo '🔄 Rebooting in 10 seconds to start GUI...'")
+            runcmd_lines.append("  - echo '   (After reboot, GUI will auto-start)'")
             runcmd_lines.append("  - sleep 10 && reboot")
 
         runcmd_yaml = "\n".join(runcmd_lines) if runcmd_lines else ""
@@ -2339,9 +2519,8 @@ package_update: true
 package_upgrade: false
 {bootcmd_block}
 
-# Install packages (cloud-init waits for completion before runcmd)
-packages:
-{packages_yaml}
+# Install packages moved to runcmd for better logging
+packages: []
 
 # Run after packages are installed
 runcmd: