clonebox 1.1.9__py3-none-any.whl → 1.1.11__py3-none-any.whl

clonebox/cli.py

@@ -2724,20 +2724,69 @@ def cmd_monitor(args) -> None:
 def cmd_exec(args) -> None:
     """Execute command in VM via QEMU Guest Agent."""
     vm_name, config_file = _resolve_vm_name_and_config_file(args.name)
-    conn_uri = "qemu:///session" if getattr(args, "user", False) else "qemu:///system"
-    command = args.command
-    if isinstance(command, list):
-        command = " ".join(command).strip()
+    user_session = getattr(args, "user", False)
+    timeout = getattr(args, "timeout", 30)
+
+    # When using argparse.REMAINDER for `command`, any flags placed after the VM name
+    # may end up inside args.command. Recover common exec flags from the remainder.
+    command_tokens = args.command
+    if not isinstance(command_tokens, list):
+        command_tokens = [str(command_tokens)] if command_tokens is not None else []
+
+    if "--" in command_tokens:
+        sep_idx = command_tokens.index("--")
+        pre_tokens = command_tokens[:sep_idx]
+        post_tokens = command_tokens[sep_idx + 1 :]
+    else:
+        pre_tokens = command_tokens
+        post_tokens = []
+
+    i = 0
+    while i < len(pre_tokens):
+        tok = pre_tokens[i]
+        if tok in ("-u", "--user"):
+            user_session = True
+            i += 1
+            continue
+        if tok in ("-t", "--timeout"):
+            if i + 1 < len(pre_tokens):
+                try:
+                    timeout = int(pre_tokens[i + 1])
+                except ValueError:
+                    pass
+                i += 2
+                continue
+        break
+
+    remaining_pre = pre_tokens[i:]
+    if post_tokens:
+        command_tokens = remaining_pre + post_tokens
+    else:
+        command_tokens = remaining_pre
+
+    command = " ".join(command_tokens).strip()
     if not command:
         console.print("[red]❌ No command specified[/]")
         return
-    timeout = getattr(args, "timeout", 30)
+
+    conn_uri = "qemu:///session" if user_session else "qemu:///system"
+    other_conn_uri = "qemu:///system" if conn_uri == "qemu:///session" else "qemu:///session"
 
     qga_ready = _qga_ping(vm_name, conn_uri)
+    if not qga_ready:
+        alt_ready = _qga_ping(vm_name, other_conn_uri)
+        if alt_ready:
+            conn_uri = other_conn_uri
+            qga_ready = True
     if not qga_ready:
         for _ in range(12):  # ~60s
             time.sleep(5)
             qga_ready = _qga_ping(vm_name, conn_uri)
+            if not qga_ready:
+                alt_ready = _qga_ping(vm_name, other_conn_uri)
+                if alt_ready:
+                    conn_uri = other_conn_uri
+                    qga_ready = True
             if qga_ready:
                 break
 

clonebox/cloner.py

@@ -92,6 +92,7 @@ class VMConfig:
     snap_packages: list = field(default_factory=list)  # Snap packages to install
     services: list = field(default_factory=list)
     post_commands: list = field(default_factory=list)  # Commands to run after setup
+    copy_paths: dict = field(default_factory=dict)  # Paths to copy (import) instead of bind-mount
     user_session: bool = field(
         default_factory=lambda: os.getenv("VM_USER_SESSION", "false").lower() == "true"
     )  # Use qemu:///session instead of qemu:///system
@@ -183,7 +184,13 @@ class SelectiveVMCloner:
             )
 
         try:
-            self.conn = libvirt.open(self.conn_uri)
+            # Use openAuth to avoid blocking on graphical auth dialogs (polkit)
+            # This is more robust for CLI usage
+            def auth_cb(creds, opaque):
+                return 0
+
+            auth = [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_NOECHOPROMPT], auth_cb, None]
+            self.conn = libvirt.openAuth(self.conn_uri, auth, 0)
         except libvirt.libvirtError as e:
             raise ConnectionError(
                 f"Cannot connect to {self.conn_uri}\n"
@@ -523,7 +530,8 @@ class SelectiveVMCloner:
             pass
 
         # CPU tuning element
-        if limits.cpu.shares or limits.cpu.quota or limits.cpu.pin:
+        # Only available in system session (requires cgroups)
+        if not self.user_session and (limits.cpu.shares or limits.cpu.quota or limits.cpu.pin):
             cputune = ET.SubElement(root, "cputune")
             ET.SubElement(cputune, "shares").text = str(limits.cpu.shares)
             if limits.cpu.quota:
@@ -534,7 +542,8 @@ class SelectiveVMCloner:
                     ET.SubElement(cputune, "vcpupin", vcpu=str(idx), cpuset=str(cpu))
 
         # Memory tuning element
-        if limits.memory.soft_limit or limits.memory.swap:
+        # Only available in system session (requires cgroups)
+        if not self.user_session and (limits.memory.soft_limit or limits.memory.swap):
             memtune = ET.SubElement(root, "memtune")
             ET.SubElement(memtune, "hard_limit", unit="KiB").text = str(limit_kib)
             if limits.memory.soft_limit_bytes:
@@ -558,7 +567,8 @@ class SelectiveVMCloner:
         ET.SubElement(disk, "target", dev="vda", bus="virtio")
         
         # Disk I/O tuning
-        if limits.disk.read_bps or limits.disk.write_bps or limits.disk.read_iops or limits.disk.write_iops:
+        # Only available in system session (requires cgroups)
+        if not self.user_session and (limits.disk.read_bps or limits.disk.write_bps or limits.disk.read_iops or limits.disk.write_iops):
             iotune = ET.SubElement(disk, "iotune")
             if limits.disk.read_bps_bytes:
                 ET.SubElement(iotune, "read_bytes_sec").text = str(limits.disk.read_bps_bytes)
@@ -588,6 +598,16 @@ class SelectiveVMCloner:
                 tag = f"mount{idx}"
                 ET.SubElement(fs, "target", dir=tag)
 
+        # 9p filesystem mounts for COPY paths (mounted to temp location for import)
+        for idx, (host_path, guest_path) in enumerate(config.copy_paths.items()):
+            if Path(host_path).exists():
+                fs = ET.SubElement(devices, "filesystem", type="mount", accessmode="mapped")
+                ET.SubElement(fs, "driver", type="path", wrpolicy="immediate")
+                ET.SubElement(fs, "source", dir=host_path)
+                # Use import tag names for copy mounts
+                tag = f"import{idx}"
+                ET.SubElement(fs, "target", dir=tag)
+
         # Network interface
         network_mode = self.resolve_network_mode(config)
         if network_mode == "user":
@@ -655,7 +675,8 @@ class SelectiveVMCloner:
         import base64
 
         wants_google_chrome = any(
-            p == "/home/ubuntu/.config/google-chrome" for p in (config.paths or {}).values()
+            p == "/home/ubuntu/.config/google-chrome"
+            for p in list((config.paths or {}).values()) + list((config.copy_paths or {}).values())
         )
 
         apt_pkg_list = list(config.packages or [])
@@ -1267,29 +1288,71 @@ fi
         pre_chown_dirs: set[str] = set()
         for idx, (host_path, guest_path) in enumerate(all_paths.items()):
             if Path(host_path).exists():
-                if str(guest_path).startswith("/home/ubuntu/snap/"):
-                    guest_parts = Path(guest_path).parts
-                    if len(guest_parts) > 4:
-                        snap_name = guest_parts[4]
-                        for d in (
-                            "/home/ubuntu",
-                            "/home/ubuntu/snap",
-                            f"/home/ubuntu/snap/{snap_name}",
-                        ):
-                            if d not in pre_chown_dirs:
-                                pre_chown_dirs.add(d)
-                                mount_commands.append(f"  - mkdir -p {d}")
-                                mount_commands.append(f"  - chown 1000:1000 {d}")
+                # Ensure all parent directories in /home/ubuntu are owned by user
+                # This prevents "Permission denied" when creating config dirs (e.g. .config) as root
+                if str(guest_path).startswith("/home/ubuntu/"):
+                    try:
+                        rel_path = Path(guest_path).relative_to("/home/ubuntu")
+                        current = Path("/home/ubuntu")
+                        # Create and chown each component in the path
+                        for part in rel_path.parts:
+                            current = current / part
+                            d_str = str(current)
+                            if d_str not in pre_chown_dirs:
+                                pre_chown_dirs.add(d_str)
+                                mount_commands.append(f"  - mkdir -p {d_str}")
+                                mount_commands.append(f"  - chown 1000:1000 {d_str}")
+                    except ValueError:
+                        pass
+
                 tag = f"mount{idx}"
                 # Use uid=1000,gid=1000 to give ubuntu user access to mounts
                 # mmap allows proper file mapping
                 mount_opts = "trans=virtio,version=9p2000.L,mmap,uid=1000,gid=1000,users"
-                mount_commands.append(f"  - mkdir -p {guest_path}")
-                mount_commands.append(f"  - chown 1000:1000 {guest_path}")
+                
+                # Ensure target exists and is owned by user (if not already handled)
+                if str(guest_path) not in pre_chown_dirs:
+                    mount_commands.append(f"  - mkdir -p {guest_path}")
+                    mount_commands.append(f"  - chown 1000:1000 {guest_path}")
+
                 mount_commands.append(f"  - mount -t 9p -o {mount_opts} {tag} {guest_path} || true")
                 # Add fstab entry for persistence after reboot
                 fstab_entries.append(f"{tag} {guest_path} 9p {mount_opts},nofail 0 0")
 
+        # 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}")
+
+                # 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")
+
         # User-data
         # Add desktop environment if GUI is enabled
         base_packages = ["qemu-guest-agent", "cloud-guest-utils"]
@@ -1330,16 +1393,37 @@ fi
         for cmd in mount_commands:
             runcmd_lines.append(cmd)
 
+        # Create user directories with correct permissions EARLY to avoid race conditions with GDM
+        if config.gui:
+            # Create directories that GNOME services need
+            runcmd_lines.extend(
+                [
+                    "  - mkdir -p /home/ubuntu/.config/pulse /home/ubuntu/.cache/ibus /home/ubuntu/.local/share",
+                    "  - mkdir -p /home/ubuntu/.config/dconf /home/ubuntu/.cache/tracker3",
+                    "  - mkdir -p /home/ubuntu/.config/autostart",
+                    "  - 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 gdm3 || systemctl enable gdm || true",
+                ]
+            )
+
         runcmd_lines.append("  - chown -R 1000:1000 /home/ubuntu || true")
         runcmd_lines.append("  - chown -R 1000:1000 /home/ubuntu/snap || true")
 
-        # Install snap packages
+        # Install snap packages (with retry logic)
         if config.snap_packages:
             runcmd_lines.append("  - echo 'Installing snap packages...'")
             for snap_pkg in config.snap_packages:
-                runcmd_lines.append(
-                    f"  - snap install {snap_pkg} --classic || snap install {snap_pkg} || true"
+                # 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"done"
                 )
+                runcmd_lines.append(f"  - {cmd}")
 
             # Connect snap interfaces for GUI apps (not auto-connected via cloud-init)
             runcmd_lines.append("  - echo 'Connecting snap interfaces...'")
@@ -1352,22 +1436,8 @@ fi
 
             runcmd_lines.append("  - systemctl restart snapd || true")
 
-        # Add GUI setup if enabled - runs AFTER package installation completes
+        # Add remaining GUI setup if enabled
         if config.gui:
-            # Create directories that GNOME services need BEFORE GUI starts
-            # These may conflict with mounted host directories, so ensure they exist with correct perms
-            runcmd_lines.extend(
-                [
-                    "  - mkdir -p /home/ubuntu/.config/pulse /home/ubuntu/.cache/ibus /home/ubuntu/.local/share",
-                    "  - mkdir -p /home/ubuntu/.config/dconf /home/ubuntu/.cache/tracker3",
-                    "  - mkdir -p /home/ubuntu/.config/autostart",
-                    "  - 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 gdm3 || systemctl enable gdm || true",
-                ]
-            )
-
             # Create autostart entries for GUI apps
             autostart_apps = {
                 "pycharm-community": (
@@ -1861,8 +1931,14 @@ esac
                             }
                         )
 
-            # Check for google-chrome from app_data_paths
-            for host_path, guest_path in (config.paths or {}).items():
+            # Check for google-chrome from app_data_paths (now in copy_paths or paths)
+            all_paths_to_check = {}
+            if config.paths:
+                all_paths_to_check.update(config.paths)
+            if config.copy_paths:
+                all_paths_to_check.update(config.copy_paths)
+
+            for host_path, guest_path in all_paths_to_check.items():
                 if guest_path == "/home/ubuntu/.config/google-chrome":
                     autostart_apps.append(
                         {
@@ -2315,7 +2391,31 @@ final_message: "CloneBox VM is ready after $UPTIME seconds"
             vm.destroy()
         else:
             log(f"[cyan]🛑 Shutting down VM '{vm_name}'...[/]")
-            vm.shutdown()
+            try:
+                vm.shutdown()
+            except libvirt.libvirtError as e:
+                log(f"[red]❌ Failed to request shutdown: {e}[/]")
+                return False
+
+            # Wait for shutdown
+            import time
+            waiting = True
+            for i in range(30):
+                try:
+                    if not vm.isActive():
+                        waiting = False
+                        break
+                except libvirt.libvirtError:
+                    # Domain might be gone
+                    waiting = False
+                    break
+                time.sleep(1)
+            
+            if waiting:
+                log(f"[red]❌ Shutdown timed out. VM is still running.[/]")
+                log(f"[dim]The guest OS is not responding to ACPI shutdown signal.[/]")
+                log(f"[dim]Try using: clonebox stop {vm_name} --force[/]")
+                return False
 
         log("[green]✅ VM stopped![/]")
         return True

clonebox/di.py

@@ -34,7 +34,7 @@ class DependencyContainer:
 
     def __init__(self):
         self._registrations: Dict[Type, ServiceRegistration] = {}
-        self._lock = threading.Lock()
+        self._lock = threading.RLock()
 
     def register(
         self,

clonebox/models.py

@@ -116,10 +116,6 @@ class CloneBoxConfig(BaseModel):
         """Convert to legacy VMConfig dataclass for compatibility."""
         from clonebox.cloner import VMConfig as VMConfigDataclass
 
-        # Merge paths and app_data_paths
-        all_paths = dict(self.paths)
-        all_paths.update(self.app_data_paths)
-
         return VMConfigDataclass(
             name=self.vm.name,
             ram_mb=self.vm.ram_mb,
@@ -127,7 +123,8 @@ class CloneBoxConfig(BaseModel):
             disk_size_gb=self.vm.disk_size_gb,
             gui=self.vm.gui,
             base_image=self.vm.base_image,
-            paths=all_paths,
+            paths=self.paths,
+            copy_paths=self.app_data_paths,  # Map app_data_paths to copy_paths
             packages=self.packages,
             snap_packages=self.snap_packages,
             services=self.services,

clonebox/validator.py

@@ -106,14 +106,14 @@ class VMValidator:
             return None
 
     def validate_mounts(self) -> Dict:
-        """Validate all mount points are accessible and contain data."""
-        self.console.print("\n[bold]💾 Validating Mount Points...[/]")
+        """Validate all mount points and copied data paths."""
+        self.console.print("\n[bold]💾 Validating Mounts & Data...[/]")
 
-        all_paths = self.config.get("paths", {}).copy()
-        all_paths.update(self.config.get("app_data_paths", {}))
+        paths = self.config.get("paths", {})
+        app_data_paths = self.config.get("app_data_paths", {})
 
-        if not all_paths:
-            self.console.print("[dim]No mount points configured[/]")
+        if not paths and not app_data_paths:
+            self.console.print("[dim]No mounts or data paths configured[/]")
             return self.results["mounts"]
 
         # Get mounted filesystems
@@ -122,64 +122,95 @@ class VMValidator:
         if mount_output:
             mounted_paths = [line.split()[2] for line in mount_output.split("\n") if line.strip()]
 
-        mount_table = Table(title="Mount Validation", border_style="cyan")
+        mount_table = Table(title="Data Validation", border_style="cyan")
         mount_table.add_column("Guest Path", style="bold")
-        mount_table.add_column("Mounted", justify="center")
-        mount_table.add_column("Accessible", justify="center")
+        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 all_paths.items():
+        # Validate bind mounts (paths)
+        for host_path, guest_path in paths.items():
             self.results["mounts"]["total"] += 1
-
+            
             # Check if mounted
             is_mounted = any(guest_path in mp for mp in mounted_paths)
-
+            
             # Check if accessible
             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:
-                    # Get file count
                     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
 
-            # Determine status
             if is_mounted and accessible:
-                mount_status = "[green]✅[/]"
-                access_status = "[green]✅[/]"
+                status_icon = "[green]✅ Mounted[/]"
                 self.results["mounts"]["passed"] += 1
                 status = "pass"
             elif is_mounted:
-                mount_status = "[green]✅[/]"
-                access_status = "[red]❌[/]"
+                status_icon = "[red]❌ Inaccessible[/]"
                 self.results["mounts"]["failed"] += 1
                 status = "mounted_but_inaccessible"
             else:
-                mount_status = "[red]❌[/]"
-                access_status = "[dim]N/A[/]"
+                status_icon = "[red]❌ Not Mounted[/]"
                 self.results["mounts"]["failed"] += 1
                 status = "not_mounted"
 
-            mount_table.add_row(guest_path, mount_status, access_status, str(file_count))
-
-            self.results["mounts"]["details"].append(
-                {
-                    "path": guest_path,
-                    "mounted": is_mounted,
-                    "accessible": accessible,
-                    "files": file_count,
-                    "status": status,
-                }
-            )
+            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
+            })
+
+        # Validate copied paths (app_data_paths)
+        for host_path, guest_path in app_data_paths.items():
+            self.results["mounts"]["total"] += 1
+            
+            # Check if exists and has content
+            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
+
+            # For copied paths, we just check existence and content
+            if exists:
+                # Warning if empty? Maybe, but strictly it passed existence check
+                status_icon = "[green]✅ Copied[/]"
+                self.results["mounts"]["passed"] += 1
+                status = "pass"
+            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, # Expected false for copies
+                "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']} mounts working[/]"
+            f"[dim]{self.results['mounts']['passed']}/{self.results['mounts']['total']} paths valid[/]"
         )
 
         return self.results["mounts"]
@@ -897,6 +928,23 @@ class VMValidator:
             self.results["overall"] = "qga_not_ready"
             return self.results
 
+        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 - skipping deep validation for now[/]")
+                self.results["overall"] = "cloud_init_running"
+                return self.results
+
+        ready_msg = self._exec_in_vm(
+            "cat /var/log/clonebox-ready 2>/dev/null || true",
+            timeout=10,
+        )
+        if 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[/]"
+            )
+
         # Run all validations
         self.validate_mounts()
         self.validate_packages()

{clonebox-1.1.9.dist-info → clonebox-1.1.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clonebox
-Version: 1.1.9
+Version: 1.1.11
 Summary: Clone your workstation environment to an isolated VM with selective apps, paths and services
 Author: CloneBox Team
 License: Apache-2.0

{clonebox-1.1.9.dist-info → clonebox-1.1.11.dist-info}/RECORD

@@ -1,15 +1,15 @@
 clonebox/__init__.py,sha256=CyfHVVq6KqBr4CNERBpXk_O6Q5B35q03YpdQbokVvvI,408
 clonebox/__main__.py,sha256=Fcoyzwwyz5-eC_sBlQk5a5RbKx8uodQz5sKJ190U0NU,135
-clonebox/cli.py,sha256=VZ1K0z0jLbqrEakXR4pC9d4FVTvzLiyzuOff3S0s2gg,136214
-clonebox/cloner.py,sha256=7JzouMKoqNQ2AYKA2HL4hk0jIDeaWh2b0mV1UW6nwD0,91267
+clonebox/cli.py,sha256=6aaIMefXxoRQgzlQDOqKFHq7e8U0CIH5TuYKrsobhH4,137848
+clonebox/cloner.py,sha256=sCUeGLY64rXVoEmstS5oFLbCmwwFyR8LhIzkmplMemI,96242
 clonebox/container.py,sha256=tiYK1ZB-DhdD6A2FuMA0h_sRNkUI7KfYcJ0tFOcdyeM,6105
 clonebox/dashboard.py,sha256=dMY6odvPq3j6FronhRRsX7aY3qdCwznB-aCWKEmHDNw,5768
 clonebox/detector.py,sha256=vS65cvFNPmUBCX1Y_TMTnSRljw6r1Ae9dlVtACs5XFc,23075
-clonebox/di.py,sha256=feFMXP5ff-7gwrIqgnoCpk1ivaiZA_lv2wcpkCSKiew,5648
+clonebox/di.py,sha256=TrPNNtyDcD_J6K8QMDsxnLVi1E6Qsj47CmOg4560tHs,5649
 clonebox/exporter.py,sha256=WIzVvmA0z_jjrpyXxvnXoLp9oaW6fKS7k0PGwzx_PIM,5629
 clonebox/importer.py,sha256=Q9Uk1IOA41mgGhU4ynW2k-h9GEoGxRKI3c9wWE4uxcA,7097
 clonebox/logging.py,sha256=jD_WgkHmt_h99EmX82QWK7D0OKWyxqcLwgT4UDQFp2g,3675
-clonebox/models.py,sha256=l9e5U4ZEEcgCTt2c47GpqFwppwVeifoCoNFi57lFGFo,8307
+clonebox/models.py,sha256=13B0lVAuaGnpY4h4iYUPigIvfxYx2pWaAEM1cYF_Hbo,8263
 clonebox/monitor.py,sha256=zlIarNf8w_i34XI8hZGxxrg5PVZK_Yxm6FQnkhLavRI,9181
 clonebox/p2p.py,sha256=6o0JnscKqF9-BftQhW5fF1W6YY1wXshY9LEklNcHGJc,5913
 clonebox/profiles.py,sha256=UP37fX_rhrG_O9ehNFJBUcULPmUtN1A8KsJ6cM44oK0,1986
@@ -17,7 +17,7 @@ clonebox/resource_monitor.py,sha256=lDR9KyPbVtImeeOkOBPPVP-5yCgoL5hsVFPZ_UqsY0w,
 clonebox/resources.py,sha256=IkuM4OdSDV4qhyc0eIynwbAHBTv0aVSxxW-gghsnCAs,6815
 clonebox/rollback.py,sha256=hpwO-8Ehe1pW0wHuZvJkC_qxZ6yEo9otCJRhGIUArCo,5711
 clonebox/secrets.py,sha256=QtGMIjhTKq14qQRGy-pX0TU3vKLiZt7CMloAlF2GmzQ,10515
-clonebox/validator.py,sha256=zX_E0X3IOZ8Dnmn8i9IVXViYXw-9Nyj0L_YyCKYRj9I,38722
+clonebox/validator.py,sha256=qKbT5dXka1Pts9GYqSt3ZEqF83gqdR0gFtFwOODWKvg,40918
 clonebox/backends/libvirt_backend.py,sha256=sIHFIvFO1hIOXEFR_foSkOGBgIzaJVQs-njOU8GdafA,7170
 clonebox/backends/qemu_disk.py,sha256=YsGjYX5sbEf35Y4yjTpNkZat73a4RGBxY-KTVzJhqIs,1687
 clonebox/backends/subprocess_runner.py,sha256=c-IyaMxM1cmUu64h654oAvulm83K5Mu-VQxXJ_0BOds,1506
@@ -34,9 +34,9 @@ clonebox/snapshots/manager.py,sha256=hGzM8V6ZJPXjTqj47c4Kr8idlE-c1Q3gPUvuw1HvS1A
 clonebox/snapshots/models.py,sha256=sRnn3OZE8JG9FZJlRuA3ihO-JXoPCQ3nD3SQytflAao,6206
 clonebox/templates/profiles/ml-dev.yaml,sha256=w07MToGh31xtxpjbeXTBk9BkpAN8A3gv8HeA3ESKG9M,461
 clonebox/templates/profiles/web-stack.yaml,sha256=EBnnGMzML5vAjXmIUbCpbTCwmRaNJiuWd3EcL43DOK8,485
-clonebox-1.1.9.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-clonebox-1.1.9.dist-info/METADATA,sha256=UjgHC8vzL5OL-yr1WP4XB0KAAacblP6YNiKsD9zWpa8,48915
-clonebox-1.1.9.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-clonebox-1.1.9.dist-info/entry_points.txt,sha256=FES95Vi3btfViLEEoHdb8nikNxTqzaooi9ehZw9ZfWI,47
-clonebox-1.1.9.dist-info/top_level.txt,sha256=LdMo2cvCrEcRGH2M8JgQNVsCoszLV0xug6kx1JnaRjo,9
-clonebox-1.1.9.dist-info/RECORD,,
+clonebox-1.1.11.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+clonebox-1.1.11.dist-info/METADATA,sha256=Nd5R6Fz4EC6YSoGP4Nyvylyazun0Hx_wbyRNiNndk34,48916
+clonebox-1.1.11.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+clonebox-1.1.11.dist-info/entry_points.txt,sha256=FES95Vi3btfViLEEoHdb8nikNxTqzaooi9ehZw9ZfWI,47
+clonebox-1.1.11.dist-info/top_level.txt,sha256=LdMo2cvCrEcRGH2M8JgQNVsCoszLV0xug6kx1JnaRjo,9
+clonebox-1.1.11.dist-info/RECORD,,