clonebox 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

clonebox/detector.py

@@ -4,11 +4,10 @@ SystemDetector - Detects running services, applications and important paths.
 """
 
 import os
-import subprocess
 import pwd
-from pathlib import Path
+import subprocess
 from dataclasses import dataclass, field
-from typing import Optional
+from pathlib import Path
 
 import psutil
 
@@ -16,6 +15,7 @@ import psutil
 @dataclass
 class DetectedService:
     """A detected systemd service."""
+
     name: str
     status: str  # running, stopped, failed
     description: str = ""
@@ -25,6 +25,7 @@ class DetectedService:
 @dataclass
 class DetectedApplication:
     """A detected running application."""
+
     name: str
     pid: int
     cmdline: str
@@ -36,6 +37,7 @@ class DetectedApplication:
 @dataclass
 class DetectedPath:
     """A detected important path."""
+
     path: str
     type: str  # config, data, project, home
     size_mb: float = 0.0
@@ -45,14 +47,15 @@ class DetectedPath:
 @dataclass
 class SystemSnapshot:
     """Complete snapshot of detected system state."""
+
     services: list = field(default_factory=list)
     applications: list = field(default_factory=list)
     paths: list = field(default_factory=list)
-    
+
     @property
     def running_services(self) -> list:
         return [s for s in self.services if s.status == "running"]
-    
+
     @property
     def running_apps(self) -> list:
         return self.applications
@@ -60,43 +63,93 @@ class SystemSnapshot:
 
 class SystemDetector:
     """Detects running services, applications and important paths on the system."""
-    
+
     # Common development/server services to look for
     INTERESTING_SERVICES = [
-        "docker", "containerd", "podman",
-        "nginx", "apache2", "httpd", "caddy",
-        "postgresql", "mysql", "mariadb", "mongodb", "redis", "memcached",
-        "elasticsearch", "kibana", "grafana", "prometheus",
-        "jenkins", "gitlab-runner",
-        "sshd", "rsync",
-        "rabbitmq-server", "kafka",
-        "nodejs", "pm2",
-        "supervisor", "systemd-resolved",
-        "cups", "bluetooth", "NetworkManager",
-        "libvirtd", "virtlogd",
+        "docker",
+        "containerd",
+        "podman",
+        "nginx",
+        "apache2",
+        "httpd",
+        "caddy",
+        "postgresql",
+        "mysql",
+        "mariadb",
+        "mongodb",
+        "redis",
+        "memcached",
+        "elasticsearch",
+        "kibana",
+        "grafana",
+        "prometheus",
+        "jenkins",
+        "gitlab-runner",
+        "sshd",
+        "rsync",
+        "rabbitmq-server",
+        "kafka",
+        "nodejs",
+        "pm2",
+        "supervisor",
+        "systemd-resolved",
+        "cups",
+        "bluetooth",
+        "NetworkManager",
+        "libvirtd",
+        "virtlogd",
     ]
-    
+
     # Interesting process names
     INTERESTING_PROCESSES = [
-        "python", "python3", "node", "npm", "yarn", "pnpm",
-        "java", "gradle", "mvn",
-        "go", "cargo", "rustc",
-        "docker", "docker-compose", "podman",
-        "nginx", "apache", "httpd",
-        "postgres", "mysql", "mongod", "redis-server",
-        "code", "code-server", "cursor",
-        "vim", "nvim", "emacs",
-        "firefox", "chrome", "chromium",
-        "jupyter", "jupyter-lab",
-        "gunicorn", "uvicorn", "flask", "django",
-        "webpack", "vite", "esbuild",
-        "tmux", "screen",
+        "python",
+        "python3",
+        "node",
+        "npm",
+        "yarn",
+        "pnpm",
+        "java",
+        "gradle",
+        "mvn",
+        "go",
+        "cargo",
+        "rustc",
+        "docker",
+        "docker-compose",
+        "podman",
+        "nginx",
+        "apache",
+        "httpd",
+        "postgres",
+        "mysql",
+        "mongod",
+        "redis-server",
+        "code",
+        "code-server",
+        "cursor",
+        "vim",
+        "nvim",
+        "emacs",
+        "firefox",
+        "chrome",
+        "chromium",
+        "jupyter",
+        "jupyter-lab",
+        "gunicorn",
+        "uvicorn",
+        "flask",
+        "django",
+        "webpack",
+        "vite",
+        "esbuild",
+        "tmux",
+        "screen",
     ]
-    
+
     def __init__(self):
         self.user = pwd.getpwuid(os.getuid()).pw_name
         self.home = Path.home()
-    
+
     def detect_all(self) -> SystemSnapshot:
         """Detect all services, applications and paths."""
         return SystemSnapshot(
@@ -104,95 +157,104 @@ class SystemDetector:
             applications=self.detect_applications(),
             paths=self.detect_paths(),
         )
-    
+
     def detect_services(self) -> list:
         """Detect systemd services."""
         services = []
-        
+
         try:
             # Get all services
             result = subprocess.run(
                 ["systemctl", "list-units", "--type=service", "--all", "--no-pager", "--plain"],
-                capture_output=True, text=True, timeout=10
+                capture_output=True,
+                text=True,
+                timeout=10,
             )
-            
+
             for line in result.stdout.strip().split("\n")[1:]:  # Skip header
                 parts = line.split()
                 if len(parts) >= 4:
                     name = parts[0].replace(".service", "")
-                    
+
                     # Filter to interesting services
-                    if any(interesting in name.lower() for interesting in self.INTERESTING_SERVICES):
+                    if any(
+                        interesting in name.lower() for interesting in self.INTERESTING_SERVICES
+                    ):
                         status = "running" if parts[3] == "running" else parts[3]
-                        
+
                         # Get description
                         desc = " ".join(parts[4:]) if len(parts) > 4 else ""
-                        
+
                         # Check if enabled
                         enabled = False
                         try:
                             en_result = subprocess.run(
                                 ["systemctl", "is-enabled", name],
-                                capture_output=True, text=True, timeout=5
+                                capture_output=True,
+                                text=True,
+                                timeout=5,
                             )
                             enabled = en_result.stdout.strip() == "enabled"
                         except:
                             pass
-                        
-                        services.append(DetectedService(
-                            name=name,
-                            status=status,
-                            description=desc,
-                            enabled=enabled
-                        ))
+
+                        services.append(
+                            DetectedService(
+                                name=name, status=status, description=desc, enabled=enabled
+                            )
+                        )
         except Exception:
             pass
-        
+
         return services
-    
+
     def detect_applications(self) -> list:
         """Detect running applications/processes."""
         applications = []
         seen_names = set()
-        
-        for proc in psutil.process_iter(['pid', 'name', 'cmdline', 'exe', 'cwd', 'memory_info']):
+
+        for proc in psutil.process_iter(["pid", "name", "cmdline", "exe", "cwd", "memory_info"]):
             try:
                 info = proc.info
-                name = info['name'] or ""
-                
+                name = info["name"] or ""
+
                 # Filter to interesting processes
-                if not any(interesting in name.lower() for interesting in self.INTERESTING_PROCESSES):
+                if not any(
+                    interesting in name.lower() for interesting in self.INTERESTING_PROCESSES
+                ):
                     continue
-                
+
                 # Skip duplicates by name (keep first)
                 if name in seen_names:
                     continue
                 seen_names.add(name)
-                
-                cmdline = " ".join(info['cmdline'] or [])[:200]
-                exe = info['exe'] or ""
-                cwd = info['cwd'] or ""
-                mem = (info['memory_info'].rss / 1024 / 1024) if info['memory_info'] else 0
-                
-                applications.append(DetectedApplication(
-                    name=name,
-                    pid=info['pid'],
-                    cmdline=cmdline,
-                    exe=exe,
-                    working_dir=cwd,
-                    memory_mb=round(mem, 1)
-                ))
+
+                cmdline = " ".join(info["cmdline"] or [])[:200]
+                exe = info["exe"] or ""
+                cwd = info["cwd"] or ""
+                mem = (info["memory_info"].rss / 1024 / 1024) if info["memory_info"] else 0
+
+                applications.append(
+                    DetectedApplication(
+                        name=name,
+                        pid=info["pid"],
+                        cmdline=cmdline,
+                        exe=exe,
+                        working_dir=cwd,
+                        memory_mb=round(mem, 1),
+                    )
+                )
             except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
                 continue
-        
+
         # Sort by memory usage
         applications.sort(key=lambda x: x.memory_mb, reverse=True)
         return applications
-    
+
     def detect_paths(self) -> list:
         """Detect important paths (projects, configs, data)."""
         paths = []
-        
+
         # User home subdirectories
         important_home_dirs = [
             ("projects", "project"),
@@ -217,18 +279,20 @@ class SystemDetector:
             ("Documents", "data"),
             ("Downloads", "data"),
         ]
-        
+
         for dirname, path_type in important_home_dirs:
             full_path = self.home / dirname
             if full_path.exists() and full_path.is_dir():
                 size = self._get_dir_size(full_path, max_depth=1)
-                paths.append(DetectedPath(
-                    path=str(full_path),
-                    type=path_type,
-                    size_mb=round(size / 1024 / 1024, 1),
-                    description=f"User {dirname}"
-                ))
-        
+                paths.append(
+                    DetectedPath(
+                        path=str(full_path),
+                        type=path_type,
+                        size_mb=round(size / 1024 / 1024, 1),
+                        description=f"User {dirname}",
+                    )
+                )
+
         # System paths that might be interesting
         system_paths = [
             ("/var/www", "data", "Web server root"),
@@ -239,21 +303,35 @@ class SystemDetector:
             ("/etc/nginx", "config", "Nginx config"),
             ("/etc/apache2", "config", "Apache config"),
         ]
-        
+
         for path, path_type, desc in system_paths:
             p = Path(path)
             if p.exists():
                 size = self._get_dir_size(p, max_depth=1)
-                paths.append(DetectedPath(
-                    path=path,
-                    type=path_type,
-                    size_mb=round(size / 1024 / 1024, 1),
-                    description=desc
-                ))
-        
+                paths.append(
+                    DetectedPath(
+                        path=path,
+                        type=path_type,
+                        size_mb=round(size / 1024 / 1024, 1),
+                        description=desc,
+                    )
+                )
+
         # Detect project directories (with .git, package.json, etc.)
-        project_markers = [".git", "package.json", "Cargo.toml", "go.mod", "pyproject.toml", "setup.py"]
-        for search_dir in [self.home / "projects", self.home / "code", self.home / "github", self.home]:
+        project_markers = [
+            ".git",
+            "package.json",
+            "Cargo.toml",
+            "go.mod",
+            "pyproject.toml",
+            "setup.py",
+        ]
+        for search_dir in [
+            self.home / "projects",
+            self.home / "code",
+            self.home / "github",
+            self.home,
+        ]:
             if search_dir.exists():
                 for item in search_dir.iterdir():
                     if item.is_dir() and not item.name.startswith("."):
@@ -261,18 +339,20 @@ class SystemDetector:
                             if (item / marker).exists():
                                 size = self._get_dir_size(item, max_depth=2)
                                 if str(item) not in [p.path for p in paths]:
-                                    paths.append(DetectedPath(
-                                        path=str(item),
-                                        type="project",
-                                        size_mb=round(size / 1024 / 1024, 1),
-                                        description=f"Project ({marker})"
-                                    ))
+                                    paths.append(
+                                        DetectedPath(
+                                            path=str(item),
+                                            type="project",
+                                            size_mb=round(size / 1024 / 1024, 1),
+                                            description=f"Project ({marker})",
+                                        )
+                                    )
                                 break
-        
+
         # Sort by type then path
         paths.sort(key=lambda x: (x.type, x.path))
         return paths
-    
+
     def _get_dir_size(self, path: Path, max_depth: int = 2) -> int:
         """Get approximate directory size in bytes."""
         total = 0
@@ -290,28 +370,26 @@ class SystemDetector:
         except (PermissionError, FileNotFoundError, OSError):
             pass
         return total
-    
+
     def detect_docker_containers(self) -> list:
         """Detect running Docker containers."""
         containers = []
         try:
             result = subprocess.run(
                 ["docker", "ps", "--format", "{{.Names}}\t{{.Image}}\t{{.Status}}"],
-                capture_output=True, text=True, timeout=10
+                capture_output=True,
+                text=True,
+                timeout=10,
             )
             for line in result.stdout.strip().split("\n"):
                 if line:
                     parts = line.split("\t")
                     if len(parts) >= 3:
-                        containers.append({
-                            "name": parts[0],
-                            "image": parts[1],
-                            "status": parts[2]
-                        })
+                        containers.append({"name": parts[0], "image": parts[1], "status": parts[2]})
         except:
             pass
         return containers
-    
+
     def get_system_info(self) -> dict:
         """Get basic system information."""
         return {

{clonebox-0.1.2.dist-info → clonebox-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clonebox
-Version: 0.1.2
+Version: 0.1.4
 Summary: Clone your workstation environment to an isolated VM with selective apps, paths and services
 Author: CloneBox Team
 License: Apache-2.0
@@ -65,7 +65,28 @@ CloneBox lets you create isolated virtual machines with only the applications, d
 
 ## Installation
 
-### Prerequisites
+### Quick Setup (Recommended)
+
+Run the setup script to automatically install dependencies and configure the environment:
+
+```bash
+# Clone the repository
+git clone https://github.com/wronai/clonebox.git
+cd clonebox
+
+# Run the setup script
+./setup.sh
+```
+
+The setup script will:
+- Install all required packages (QEMU, libvirt, Python, etc.)
+- Add your user to the necessary groups
+- Configure libvirt networks
+- Install clonebox in development mode
+
+### Manual Installation
+
+#### Prerequisites
 
 ```bash
 # Install libvirt and QEMU/KVM
@@ -82,7 +103,7 @@ newgrp libvirt
 sudo apt install genisoimage
 ```
 
-### Install CloneBox
+#### Install CloneBox
 
 ```bash
 # From source
@@ -270,6 +291,29 @@ clonebox detect --yaml --dedupe
 clonebox detect --yaml --dedupe -o my-config.yaml
 ```
 
+### User Session & Networking
+
+CloneBox supports creating VMs in user session (no root required) with automatic network fallback:
+
+```bash
+# Create VM in user session (uses ~/.local/share/libvirt/images)
+clonebox clone . --user
+
+# Explicitly use user-mode networking (slirp) - works without libvirt network
+clonebox clone . --user --network user
+
+# Force libvirt default network (may fail in user session)
+clonebox clone . --network default
+
+# Auto mode (default): tries libvirt network, falls back to user-mode if unavailable
+clonebox clone . --network auto
+```
+
+**Network modes:**
+- `auto` (default): Uses libvirt default network if available, otherwise falls back to user-mode (slirp)
+- `default`: Forces use of libvirt default network
+- `user`: Uses user-mode networking (slirp) - no bridge setup required
+
 ## Commands Reference
 
 | Command | Description |
@@ -278,6 +322,9 @@ clonebox detect --yaml --dedupe -o my-config.yaml
 | `clonebox clone <path>` | Generate `.clonebox.yaml` from path + running processes |
 | `clonebox clone . --run` | Clone and immediately start VM |
 | `clonebox clone . --edit` | Clone, edit config, then create |
+| `clonebox clone . --user` | Clone in user session (no root) |
+| `clonebox clone . --network user` | Use user-mode networking (slirp) |
+| `clonebox clone . --network auto` | Auto-detect network mode (default) |
 | `clonebox start .` | Start VM from `.clonebox.yaml` in current dir |
 | `clonebox start <name>` | Start existing VM by name |
 | `clonebox stop <name>` | Stop a VM (graceful shutdown) |
@@ -296,6 +343,66 @@ clonebox detect --yaml --dedupe -o my-config.yaml
 - Python 3.8+
 - User in `libvirt` group
 
+## Troubleshooting
+
+### Network Issues
+
+If you encounter "Network not found" or "network 'default' is not active" errors:
+
+```bash
+# Option 1: Use user-mode networking (no setup required)
+clonebox clone . --user --network user
+
+# Option 2: Run the network fix script
+./fix-network.sh
+
+# Or manually fix:
+virsh --connect qemu:///session net-destroy default 2>/dev/null
+virsh --connect qemu:///session net-undefine default 2>/dev/null
+virsh --connect qemu:///session net-define /tmp/default-network.xml
+virsh --connect qemu:///session net-start default
+```
+
+### Permission Issues
+
+If you get permission errors:
+
+```bash
+# Ensure user is in libvirt and kvm groups
+sudo usermod -aG libvirt $USER
+sudo usermod -aG kvm $USER
+
+# Log out and log back in for groups to take effect
+```
+
+### VM Already Exists
+
+If you get "domain already exists" error:
+
+```bash
+# List VMs
+clonebox list
+
+# Stop and delete the existing VM
+clonebox delete <vm-name>
+
+# Or use virsh directly
+virsh --connect qemu:///session destroy <vm-name>
+virsh --connect qemu:///session undefine <vm-name>
+```
+
+### virt-viewer not found
+
+If GUI doesn't open:
+
+```bash
+# Install virt-viewer
+sudo apt install virt-viewer
+
+# Then connect manually
+virt-viewer --connect qemu:///session <vm-name>
+```
+
 ## License
 
 MIT License - see [LICENSE](LICENSE) file.

clonebox-0.1.4.dist-info/RECORD

@@ -0,0 +1,11 @@
+clonebox/__init__.py,sha256=IOk7G0DiSQ33EGbFC0xbnnFB9aou_6yuyFxvycQEvA0,407
+clonebox/__main__.py,sha256=Fcoyzwwyz5-eC_sBlQk5a5RbKx8uodQz5sKJ190U0NU,135
+clonebox/cli.py,sha256=gtnFl0Jibfwuy4uMF9_BPTOvbHzTgpXsy71WwLEtY64,31781
+clonebox/cloner.py,sha256=Uoh9mCUX-3p2tFL_3qlf2R2232JCXO5YhWrgKTpEr0s,19369
+clonebox/detector.py,sha256=jkzENmi4720n5e04k6gM7MNvXbQdYX-z1_O3Id0WK9w,12505
+clonebox-0.1.4.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+clonebox-0.1.4.dist-info/METADATA,sha256=YQg_Br_7JJcWvhNTKhWokMXftG2Xht_zfPQ_zmJuzSQ,13126
+clonebox-0.1.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+clonebox-0.1.4.dist-info/entry_points.txt,sha256=FES95Vi3btfViLEEoHdb8nikNxTqzaooi9ehZw9ZfWI,47
+clonebox-0.1.4.dist-info/top_level.txt,sha256=LdMo2cvCrEcRGH2M8JgQNVsCoszLV0xug6kx1JnaRjo,9
+clonebox-0.1.4.dist-info/RECORD,,

clonebox-0.1.2.dist-info/RECORD

@@ -1,10 +0,0 @@
-clonebox/__init__.py,sha256=IOk7G0DiSQ33EGbFC0xbnnFB9aou_6yuyFxvycQEvA0,407
-clonebox/cli.py,sha256=Zk9D99G2Zcaeb0Pw3eNhv0EtLYKPcpE0GyB3QtuhvgQ,31625
-clonebox/cloner.py,sha256=qfMpx7tS5Eozvhi2ZzBc5GY6HLYotncuMakeknHnTwo,18099
-clonebox/detector.py,sha256=Umg4CRJU61yV3a1AvR_0tOfjBMCCIbiQdDAAhlrOL5k,11916
-clonebox-0.1.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-clonebox-0.1.2.dist-info/METADATA,sha256=YtSqXudDO6TrPtAZzbP5fbMvf-PHarUpkY55ZGpHplw,10374
-clonebox-0.1.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-clonebox-0.1.2.dist-info/entry_points.txt,sha256=FES95Vi3btfViLEEoHdb8nikNxTqzaooi9ehZw9ZfWI,47
-clonebox-0.1.2.dist-info/top_level.txt,sha256=LdMo2cvCrEcRGH2M8JgQNVsCoszLV0xug6kx1JnaRjo,9
-clonebox-0.1.2.dist-info/RECORD,,