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

clonebox/cli.py

@@ -2498,6 +2498,18 @@ def monitor_cloud_init_status(vm_name: str, user_session: bool = False, timeout:
                     "grep -E '\\[[0-9]/[0-9]\\]|→' /var/log/cloud-init-output.log 2>/dev/null | tail -n 5"
                 )
                 
+                # Check disk space in real-time
+                disk_info = _exec_in_vm_qga(
+                    vm_name,
+                    conn_uri,
+                    "df / --output=pcent | tail -n 1 | tr -dc '0-9'"
+                )
+                if disk_info and disk_info.isdigit():
+                    usage = int(disk_info)
+                    if usage > 90:
+                        console.print(f"[bold red]⚠️  WARNING: VM Disk is nearly full ({usage}%)![/]")
+                        console.print("[red]   Installation may fail. Consider increasing --disk-size-gb.[/]")
+                
                 if raw_info:
                     lines = [l.strip() for l in raw_info.strip().split('\n') if l.strip()]
                     for line in lines:

clonebox/cloner.py

@@ -1124,7 +1124,7 @@ fi
             mount_checks.append(f'check_mount "{guest_path}" "mount{idx}"')
         
         # Add copied paths checks
-        copy_paths = config.copy_paths or config.app_data_paths
+        copy_paths = config.copy_paths or getattr(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}"')
@@ -1161,6 +1161,27 @@ log() {{
     echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$REPORT_FILE"
 }}
 
+check_disk_space() {{
+    local usage
+    usage=$(df / --output=pcent | tail -n 1 | tr -dc '0-9')
+    local avail
+    avail=$(df -h / --output=avail | tail -n 1 | tr -d ' ')
+    
+    if [ "$usage" -gt 95 ]; then
+        log "[FAIL] Disk space nearly full: ${{usage}}% used ($avail available)"
+        ((FAILED++))
+        return 1
+    elif [ "$usage" -gt 85 ]; then
+        log "[WARN] Disk usage high: ${{usage}}% used ($avail available)"
+        ((WARNINGS++))
+        return 0
+    else
+        log "[PASS] Disk space OK: ${{usage}}% used ($avail available)"
+        ((PASSED++))
+        return 0
+    fi
+}}
+
 check_apt_package() {{
     local pkg="$1"
     if dpkg -l "$pkg" 2>/dev/null | grep -q "^ii"; then
@@ -1234,9 +1255,9 @@ check_mount() {{
         log "[INFO] Mount point '$path' does not exist yet"
         return 0
     fi
-}
+}}
 
-check_copy_path() {
+check_copy_path() {{
     local path="$1"
     if [ -d "$path" ]; then
         if [ "$(ls -A "$path" 2>/dev/null | wc -l)" -gt 0 ]; then
@@ -1283,6 +1304,11 @@ log "VM Name: {config.name}"
 log "Date: $(date)"
 log "=========================================="
 
+log ""
+log "--- System Health ---"
+check_disk_space
+check_gui
+
 log ""
 log "--- APT Packages ---"
 {apt_checks_str}
@@ -1403,7 +1429,7 @@ fi
         (cloudinit_dir / "meta-data").write_text(meta_data)
 
         # Generate mount commands and fstab entries for 9p filesystems
-        mount_commands = []
+        bind_mount_commands = []
         fstab_entries = []
         all_paths = dict(config.paths) if config.paths else {}
         pre_chown_dirs: set[str] = set()
@@ -1421,8 +1447,8 @@ fi
                             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}")
+                                bind_mount_commands.append(f"  - mkdir -p {d_str}")
+                                bind_mount_commands.append(f"  - chown 1000:1000 {d_str}")
                     except ValueError:
                         pass
 
@@ -1433,14 +1459,15 @@ fi
                 
                 # 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}")
+                    bind_mount_commands.append(f"  - mkdir -p {guest_path}")
+                    bind_mount_commands.append(f"  - chown 1000:1000 {guest_path}")
 
-                mount_commands.append(f"  - mount -t 9p -o {mount_opts} {tag} {guest_path} || true")
+                bind_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)
+        import_mount_commands = []
         all_copy_paths = dict(config.copy_paths) if config.copy_paths else {}
         existing_copy_paths = {h: g for h, g in all_copy_paths.items() if Path(h).exists()}
         
@@ -1451,29 +1478,29 @@ fi
             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}")
+            import_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")
+            import_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}")
+                import_mount_commands.append(f"  - mkdir -p {guest_path}")
+                import_mount_commands.append(f"  - chown 1000:1000 {guest_path}")
             else:
-                mount_commands.append(f"  - mkdir -p {guest_path}")
+                import_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")
+            import_mount_commands.append(f"  - echo 'Importing {host_path} to {guest_path}...'")
+            import_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}")
+            import_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")
+            import_mount_commands.append(f"  - umount {temp_mount_point} || true")
+            import_mount_commands.append(f"  - rmdir {temp_mount_point} || true")
 
         # User-data
         # Add desktop environment if GUI is enabled
@@ -1506,7 +1533,8 @@ fi
             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("  - apt-get clean")
+            runcmd_lines.append("  - echo '  ✓ APT packages installed and cache cleaned'")
             runcmd_lines.append("  - echo ''")
         else:
             runcmd_lines.append("  - echo '[1/9] 📦 No APT packages to install'")
@@ -1532,14 +1560,21 @@ fi
         runcmd_lines.append("  - echo ''")
 
         # Phase 4: Filesystem mounts
-        runcmd_lines.append(f"  - echo '[4/9] 📁 Mounting shared directories ({len(fstab_entries)} mounts)...'")
+        runcmd_lines.append(f"  - echo '[4/9] 📁 Mounting shared directories ({len(config.paths)} mounts)...'")
+        if bind_mount_commands:
+            for cmd in bind_mount_commands:
+                if "mount -t 9p" in cmd:
+                    # Extract mount point for logging
+                    parts = cmd.split()
+                    mp = parts[-2] if len(parts) > 2 else "path"
+                    runcmd_lines.append(f"  - echo '  → Mounting {mp}...'")
+                runcmd_lines.append(cmd)
+        
         if fstab_entries:
             runcmd_lines.append(
                 "  - grep -q '^# CloneBox 9p mounts' /etc/fstab || echo '# CloneBox 9p mounts' >> /etc/fstab"
             )
             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"
                 )
@@ -1550,9 +1585,9 @@ fi
         # 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)
+            # Add import commands with progress
             import_count = 0
-            for cmd in mount_commands:
+            for cmd in import_mount_commands:
                 if "Importing" in cmd:
                     import_count += 1
                     runcmd_lines.append(cmd.replace("Importing", f"  → [{import_count}/{len(existing_copy_paths)}] Importing"))
@@ -2446,25 +2481,21 @@ 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"
+        # Inside the VM, we use a fixed path for the image file
+        vm_logs_img_path = "/var/lib/clonebox/logs.img"
         
         runcmd_lines.extend(
             [
-                "  - mkdir -p /mnt/logs",
-                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",
+                "  - mkdir -p /var/lib/clonebox /mnt/logs",
+                f"  - truncate -s 1G {vm_logs_img_path}",
+                f"  - mkfs.ext4 -F {vm_logs_img_path}",
+                f"  - echo '{vm_logs_img_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",
-                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'\"",
+                f"  - echo 'Logs disk mounted at /mnt/logs - backing file: {vm_logs_img_path}'",
             ]
         )
 

clonebox/validator.py

@@ -76,39 +76,38 @@ class VMValidator:
 
             pid = response["return"]["pid"]
 
-            # Wait a bit for command to complete
-            time.sleep(0.3)
-
-            # Get result
-            status_result = subprocess.run(
-                [
-                    "virsh",
-                    "--connect",
-                    self.conn_uri,
-                    "qemu-agent-command",
-                    self.vm_name,
-                    f'{{"execute":"guest-exec-status","arguments":{{"pid":{pid}}}}}',
-                ],
-                capture_output=True,
-                text=True,
-                timeout=5,
-            )
+            deadline = time.time() + timeout
+            while time.time() < deadline:
+                status_result = subprocess.run(
+                    [
+                        "virsh",
+                        "--connect",
+                        self.conn_uri,
+                        "qemu-agent-command",
+                        self.vm_name,
+                        f'{{"execute":"guest-exec-status","arguments":{{"pid":{pid}}}}}',
+                    ],
+                    capture_output=True,
+                    text=True,
+                    timeout=5,
+                )
 
-            if status_result.returncode != 0:
-                return None
+                if status_result.returncode != 0:
+                    return None
 
-            status_resp = json.loads(status_result.stdout)
-            if "return" not in status_resp:
-                return None
+                status_resp = json.loads(status_result.stdout)
+                if "return" not in status_resp:
+                    return None
 
-            ret = status_resp["return"]
-            if not ret.get("exited", False):
-                return None
+                ret = status_resp["return"]
+                if ret.get("exited", False):
+                    if "out-data" in ret:
+                        return base64.b64decode(ret["out-data"]).decode().strip()
+                    return ""
 
-            if "out-data" in ret:
-                return base64.b64decode(ret["out-data"]).decode().strip()
+                time.sleep(0.2)
 
-            return ""
+            return None
 
         except Exception:
             return None
@@ -397,6 +396,8 @@ class VMValidator:
         svc_table.add_column("PID", justify="right", style="dim")
         svc_table.add_column("Note", style="dim")
 
+        setup_in_progress = self._setup_in_progress() is True
+
         for service in services:
             if service in self.VM_EXCLUDED_SERVICES:
                 svc_table.add_row(service, "[dim]—[/]", "[dim]—[/]", "[dim]—[/]", "host-only")
@@ -413,6 +414,7 @@ class VMValidator:
                 continue
 
             self.results["services"]["total"] += 1
+            setup_in_progress = self._setup_in_progress() is True
 
             enabled_cmd = f"systemctl is-enabled {service} 2>/dev/null"
             enabled_status = self._exec_in_vm(enabled_cmd)
@@ -970,6 +972,138 @@ class VMValidator:
         except Exception:
             return False
 
+    def validate_disk_space(self) -> Dict:
+        """Validate disk space on root filesystem."""
+        self.console.print("\n[bold]💾 Validating Disk Space...[/]")
+        
+        df_output = self._exec_in_vm("df -h / --output=pcent,avail,size | tail -n 1", timeout=20)
+        if not df_output:
+            self.console.print("[red]❌ Could not check disk space[/]")
+            return {"status": "error"}
+
+        try:
+            # Format:  pcent avail size
+            # Example: 98%   100M  30G
+            parts = df_output.split()
+            usage_pct = int(parts[0].replace('%', ''))
+            avail = parts[1]
+            total = parts[2]
+
+            self.results["disk"] = {
+                "usage_pct": usage_pct,
+                "avail": avail,
+                "total": total
+            }
+
+            if usage_pct > 95:
+                self.console.print(f"[red]❌ Disk nearly full: {usage_pct}% used ({avail} available of {total})[/]")
+                status = "fail"
+            elif usage_pct > 80:
+                self.console.print(f"[yellow]⚠️  Disk usage high: {usage_pct}% used ({avail} available of {total})[/]")
+                status = "warning"
+            else:
+                self.console.print(f"[green]✅ Disk space OK: {usage_pct}% used ({avail} available of {total})[/]")
+                status = "pass"
+
+            if usage_pct > 80:
+                self._print_disk_usage_breakdown()
+            
+            return self.results["disk"]
+        except Exception as e:
+            self.console.print(f"[red]❌ Error parsing df output: {e}[/]")
+            return {"status": "error"}
+
+    def _print_disk_usage_breakdown(self) -> None:
+        def _parse_du_lines(out: Optional[str]) -> List[Tuple[str, str]]:
+            if not out:
+                return []
+            rows: List[Tuple[str, str]] = []
+            for line in out.splitlines():
+                line = line.strip()
+                if not line:
+                    continue
+                parts = line.split(maxsplit=1)
+                if len(parts) != 2:
+                    continue
+                size, path = parts
+                rows.append((path, size))
+            return rows
+
+        def _dir_size(path: str, timeout: int = 30) -> Optional[str]:
+            out = self._exec_in_vm(f"du -x -s -h {path} 2>/dev/null | head -n 1 | cut -f1", timeout=timeout)
+            return out.strip() if out else None
+
+        self.console.print("\n[bold]📁 Disk usage breakdown (largest directories)[/]")
+
+        top_level = self._exec_in_vm(
+            "du -x -h --max-depth=1 / 2>/dev/null | sort -hr | head -n 15",
+            timeout=60,
+        )
+        top_rows = _parse_du_lines(top_level)
+
+        if top_rows:
+            table = Table(title="Disk Usage: / (Top 15)", border_style="cyan")
+            table.add_column("Path", style="bold")
+            table.add_column("Size", justify="right")
+            for path, size in top_rows:
+                table.add_row(path, size)
+            self.console.print(table)
+        else:
+            self.console.print("[dim]Could not compute top-level directory sizes (du may be busy)[/]")
+
+        var_sz = _dir_size("/var")
+        home_sz = _dir_size("/home")
+        if var_sz or home_sz:
+            sum_table = Table(title="Disk Usage: Key Directories", border_style="cyan")
+            sum_table.add_column("Path", style="bold")
+            sum_table.add_column("Size", justify="right")
+            for p in ["/var", "/var/lib", "/var/log", "/var/cache", "/var/lib/snapd", "/home", "/home/ubuntu", "/tmp"]:
+                sz = _dir_size(p, timeout=30)
+                if sz:
+                    sum_table.add_row(p, sz)
+            self.console.print(sum_table)
+
+        var_breakdown = self._exec_in_vm(
+            "du -x -h --max-depth=1 /var 2>/dev/null | sort -hr | head -n 12",
+            timeout=60,
+        )
+        var_rows = _parse_du_lines(var_breakdown)
+        if var_rows:
+            vtable = Table(title="Disk Usage: /var (Top 12)", border_style="cyan")
+            vtable.add_column("Path", style="bold")
+            vtable.add_column("Size", justify="right")
+            for path, size in var_rows:
+                vtable.add_row(path, size)
+            self.console.print(vtable)
+
+        home_breakdown = self._exec_in_vm(
+            "du -x -h --max-depth=2 /home/ubuntu 2>/dev/null | sort -hr | head -n 12",
+            timeout=60,
+        )
+        home_rows = _parse_du_lines(home_breakdown)
+        if home_rows:
+            htable = Table(title="Disk Usage: /home/ubuntu (Top 12)", border_style="cyan")
+            htable.add_column("Path", style="bold")
+            htable.add_column("Size", justify="right")
+            for path, size in home_rows:
+                htable.add_row(path, size)
+            self.console.print(htable)
+
+        copy_paths = self.config.get("copy_paths", None)
+        if not isinstance(copy_paths, dict) or not copy_paths:
+            copy_paths = self.config.get("app_data_paths", {})
+        if copy_paths:
+            ctable = Table(title="Disk Usage: Configured Imported Paths", border_style="cyan")
+            ctable.add_column("Guest Path", style="bold")
+            ctable.add_column("Size", justify="right")
+            for _, guest_path in copy_paths.items():
+                sz = _dir_size(guest_path, timeout=30)
+                if sz:
+                    ctable.add_row(str(guest_path), sz)
+                else:
+                    ctable.add_row(str(guest_path), "—")
+            self.console.print(ctable)
+
     def validate_all(self) -> Dict:
         """Run all validations and return comprehensive results."""
         self.console.print("[bold cyan]🔍 Running Full Validation...[/]")
@@ -1026,6 +1160,7 @@ class VMValidator:
             )
 
         # Run all validations
+        self.validate_disk_space()
         self.validate_mounts()
         self.validate_packages()
         self.validate_snap_packages()

{clonebox-1.1.16.dist-info → clonebox-1.1.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clonebox
-Version: 1.1.16
+Version: 1.1.18
 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.16.dist-info → clonebox-1.1.18.dist-info}/RECORD

@@ -1,8 +1,8 @@
 clonebox/__init__.py,sha256=CyfHVVq6KqBr4CNERBpXk_O6Q5B35q03YpdQbokVvvI,408
 clonebox/__main__.py,sha256=Fcoyzwwyz5-eC_sBlQk5a5RbKx8uodQz5sKJ190U0NU,135
 clonebox/audit.py,sha256=1W9vaIjB0A--_p7CgE3cIP5RNckJG1RxJrL-tOb-QmU,14298
-clonebox/cli.py,sha256=k3q-JrzsiDcGPjhzHbm1jPKajxD2chYJxSGGftCbA20,178481
-clonebox/cloner.py,sha256=ZMeIpEuzT8ZO9fav99JdE3krWT6e06K8pBR7XxDKbos,106958
+clonebox/cli.py,sha256=x0VQ9WI1KZrNQGAh7FDf_036jDypdT5Q7vuTlr-dgi0,179087
+clonebox/cloner.py,sha256=WEMNjhHVdXwiA2zCq14fr5eVD6vhLuX4vnJ47p3SiNI,107839
 clonebox/container.py,sha256=tiYK1ZB-DhdD6A2FuMA0h_sRNkUI7KfYcJ0tFOcdyeM,6105
 clonebox/dashboard.py,sha256=dMY6odvPq3j6FronhRRsX7aY3qdCwznB-aCWKEmHDNw,5768
 clonebox/detector.py,sha256=vS65cvFNPmUBCX1Y_TMTnSRljw6r1Ae9dlVtACs5XFc,23075
@@ -20,7 +20,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=l1jwJcEPB1qMoGNLPjyrkKKr1khh9VmftFJI9BWhgK0,10628
-clonebox/validator.py,sha256=uXBkdrWSk8oBhRnD1y4mwxRdxOPduRraroSIs14bAo8,45342
+clonebox/validator.py,sha256=PWPgkR9cjewTh6-uW_2YyjxuEj2wI9O7h7hk7NK8nAI,51181
 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
@@ -40,9 +40,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.16.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-clonebox-1.1.16.dist-info/METADATA,sha256=mPn_uTUwAXlnakSJc8DLWyg1KlNERP5-oIEyWABxuwA,49052
-clonebox-1.1.16.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-clonebox-1.1.16.dist-info/entry_points.txt,sha256=FES95Vi3btfViLEEoHdb8nikNxTqzaooi9ehZw9ZfWI,47
-clonebox-1.1.16.dist-info/top_level.txt,sha256=LdMo2cvCrEcRGH2M8JgQNVsCoszLV0xug6kx1JnaRjo,9
-clonebox-1.1.16.dist-info/RECORD,,
+clonebox-1.1.18.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+clonebox-1.1.18.dist-info/METADATA,sha256=n1VJE8-Mk-zf9QgHBbvt1Z5fbJMdpD1vjZVVjEBeaxE,49052
+clonebox-1.1.18.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+clonebox-1.1.18.dist-info/entry_points.txt,sha256=FES95Vi3btfViLEEoHdb8nikNxTqzaooi9ehZw9ZfWI,47
+clonebox-1.1.18.dist-info/top_level.txt,sha256=LdMo2cvCrEcRGH2M8JgQNVsCoszLV0xug6kx1JnaRjo,9
+clonebox-1.1.18.dist-info/RECORD,,