clonebox 1.1.3__py3-none-any.whl → 1.1.4__py3-none-any.whl

clonebox/cli.py

@@ -30,6 +30,7 @@ from clonebox.models import ContainerConfig
 from clonebox.profiles import merge_with_profile
 from clonebox.exporter import SecureExporter, VMExporter
 from clonebox.importer import SecureImporter, VMImporter
+from clonebox.monitor import ResourceMonitor, format_bytes
 from clonebox.p2p import P2PManager
 
 # Custom questionary style
@@ -2638,6 +2639,118 @@ def cmd_detect(args):
         console.print(table)
 
 
+def cmd_monitor(args) -> None:
+    """Real-time resource monitoring for VMs and containers."""
+    conn_uri = "qemu:///session" if getattr(args, "user", False) else "qemu:///system"
+    refresh = getattr(args, "refresh", 2.0)
+    once = getattr(args, "once", False)
+
+    monitor = ResourceMonitor(conn_uri)
+
+    try:
+        while True:
+            # Clear screen for live update
+            if not once:
+                console.clear()
+
+            console.print("[bold cyan]📊 CloneBox Resource Monitor[/]")
+            console.print()
+
+            # VM Stats
+            vm_stats = monitor.get_all_vm_stats()
+            if vm_stats:
+                table = Table(title="🖥️ Virtual Machines", border_style="cyan")
+                table.add_column("Name", style="bold")
+                table.add_column("State")
+                table.add_column("CPU %")
+                table.add_column("Memory")
+                table.add_column("Disk")
+                table.add_column("Network I/O")
+
+                for vm in vm_stats:
+                    state_color = "green" if vm.state == "running" else "yellow"
+                    cpu_color = "red" if vm.cpu_percent > 80 else "green"
+                    mem_pct = (vm.memory_used_mb / vm.memory_total_mb * 100) if vm.memory_total_mb > 0 else 0
+                    mem_color = "red" if mem_pct > 80 else "green"
+
+                    table.add_row(
+                        vm.name,
+                        f"[{state_color}]{vm.state}[/]",
+                        f"[{cpu_color}]{vm.cpu_percent:.1f}%[/]",
+                        f"[{mem_color}]{vm.memory_used_mb}/{vm.memory_total_mb} MB[/]",
+                        f"{vm.disk_used_gb:.1f}/{vm.disk_total_gb:.1f} GB",
+                        f"↓{format_bytes(vm.network_rx_bytes)} ↑{format_bytes(vm.network_tx_bytes)}",
+                    )
+                console.print(table)
+            else:
+                console.print("[dim]No VMs found.[/]")
+
+            console.print()
+
+            # Container Stats
+            container_stats = monitor.get_container_stats()
+            if container_stats:
+                table = Table(title="🐳 Containers", border_style="blue")
+                table.add_column("Name", style="bold")
+                table.add_column("State")
+                table.add_column("CPU %")
+                table.add_column("Memory")
+                table.add_column("Network I/O")
+                table.add_column("PIDs")
+
+                for c in container_stats:
+                    cpu_color = "red" if c.cpu_percent > 80 else "green"
+                    mem_pct = (c.memory_used_mb / c.memory_limit_mb * 100) if c.memory_limit_mb > 0 else 0
+                    mem_color = "red" if mem_pct > 80 else "green"
+
+                    table.add_row(
+                        c.name,
+                        f"[green]{c.state}[/]",
+                        f"[{cpu_color}]{c.cpu_percent:.1f}%[/]",
+                        f"[{mem_color}]{c.memory_used_mb}/{c.memory_limit_mb} MB[/]",
+                        f"↓{format_bytes(c.network_rx_bytes)} ↑{format_bytes(c.network_tx_bytes)}",
+                        str(c.pids),
+                    )
+                console.print(table)
+            else:
+                console.print("[dim]No containers running.[/]")
+
+            if once:
+                break
+
+            console.print(f"\n[dim]Refreshing every {refresh}s. Press Ctrl+C to exit.[/]")
+            time.sleep(refresh)
+
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Monitoring stopped.[/]")
+    finally:
+        monitor.close()
+
+
+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
+    timeout = getattr(args, "timeout", 30)
+
+    if not _qga_ping(vm_name, conn_uri):
+        console.print(f"[red]❌ Cannot connect to VM '{vm_name}' via QEMU Guest Agent[/]")
+        console.print("[dim]Make sure the VM is running and qemu-guest-agent is installed.[/]")
+        return
+
+    console.print(f"[cyan]▶ Executing in {vm_name}:[/] {command}")
+
+    result = _qga_exec(vm_name, conn_uri, command, timeout=timeout)
+
+    if result is None:
+        console.print("[red]❌ Command execution failed or timed out[/]")
+    elif result == "":
+        console.print("[dim](no output)[/]")
+    else:
+        console.print(result)
+
+
 def cmd_keygen(args) -> None:
     """Generate encryption key for secure P2P transfers."""
     key_path = SecureExporter.generate_key()
@@ -3198,6 +3311,35 @@ def main():
     )
     test_parser.set_defaults(func=cmd_test)
 
+    # Monitor command - real-time resource monitoring
+    monitor_parser = subparsers.add_parser("monitor", help="Real-time resource monitoring")
+    monitor_parser.add_argument(
+        "-u", "--user", action="store_true", help="Use user session (qemu:///session)"
+    )
+    monitor_parser.add_argument(
+        "--refresh", "-r", type=float, default=2.0, help="Refresh interval in seconds (default: 2)"
+    )
+    monitor_parser.add_argument(
+        "--once", action="store_true", help="Show stats once and exit"
+    )
+    monitor_parser.set_defaults(func=cmd_monitor)
+
+    # Exec command - execute command in VM
+    exec_parser = subparsers.add_parser("exec", help="Execute command in VM via QEMU Guest Agent")
+    exec_parser.add_argument(
+        "name", nargs="?", default=None, help="VM name or '.' to use .clonebox.yaml"
+    )
+    exec_parser.add_argument(
+        "command", help="Command to execute in VM"
+    )
+    exec_parser.add_argument(
+        "-u", "--user", action="store_true", help="Use user session (qemu:///session)"
+    )
+    exec_parser.add_argument(
+        "--timeout", "-t", type=int, default=30, help="Command timeout in seconds (default: 30)"
+    )
+    exec_parser.set_defaults(func=cmd_exec)
+
     # === P2P Secure Transfer Commands ===
 
     # Keygen command - generate encryption key

clonebox/health/__init__.py

@@ -0,0 +1,16 @@
+"""Health check system for CloneBox VMs."""
+
+from .models import HealthCheckResult, HealthStatus, ProbeConfig
+from .probes import HTTPProbe, TCPProbe, CommandProbe, ScriptProbe
+from .manager import HealthCheckManager
+
+__all__ = [
+    "HealthCheckResult",
+    "HealthStatus",
+    "ProbeConfig",
+    "HTTPProbe",
+    "TCPProbe",
+    "CommandProbe",
+    "ScriptProbe",
+    "HealthCheckManager",
+]

clonebox/health/models.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+"""Data models for health check system."""
+
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+from enum import Enum
+from typing import Any, Dict, List, Optional
+
+
+class HealthStatus(Enum):
+    """Health check status."""
+
+    HEALTHY = "healthy"
+    UNHEALTHY = "unhealthy"
+    DEGRADED = "degraded"
+    UNKNOWN = "unknown"
+    TIMEOUT = "timeout"
+
+
+class ProbeType(Enum):
+    """Type of health probe."""
+
+    HTTP = "http"
+    TCP = "tcp"
+    COMMAND = "command"
+    SCRIPT = "script"
+
+
+@dataclass
+class ProbeConfig:
+    """Configuration for a health probe."""
+
+    name: str
+    probe_type: ProbeType
+    enabled: bool = True
+
+    # Timing
+    timeout_seconds: float = 5.0
+    interval_seconds: float = 30.0
+    retries: int = 3
+    retry_delay_seconds: float = 1.0
+
+    # HTTP probe
+    url: Optional[str] = None
+    method: str = "GET"
+    expected_status: int = 200
+    expected_body: Optional[str] = None
+    expected_json: Optional[Dict[str, Any]] = None
+    headers: Dict[str, str] = field(default_factory=dict)
+
+    # TCP probe
+    host: str = "localhost"
+    port: Optional[int] = None
+
+    # Command probe
+    command: Optional[str] = None
+    expected_output: Optional[str] = None
+    expected_exit_code: int = 0
+
+    # Script probe
+    script_path: Optional[str] = None
+
+    # Thresholds
+    failure_threshold: int = 3  # Consecutive failures before unhealthy
+    success_threshold: int = 1  # Consecutive successes before healthy
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "name": self.name,
+            "type": self.probe_type.value,
+            "enabled": self.enabled,
+            "timeout": self.timeout_seconds,
+            "interval": self.interval_seconds,
+            "retries": self.retries,
+            "url": self.url,
+            "method": self.method,
+            "expected_status": self.expected_status,
+            "expected_body": self.expected_body,
+            "expected_json": self.expected_json,
+            "headers": self.headers,
+            "host": self.host,
+            "port": self.port,
+            "command": self.command,
+            "expected_output": self.expected_output,
+            "expected_exit_code": self.expected_exit_code,
+            "script_path": self.script_path,
+            "failure_threshold": self.failure_threshold,
+            "success_threshold": self.success_threshold,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "ProbeConfig":
+        """Create from dictionary."""
+        return cls(
+            name=data["name"],
+            probe_type=ProbeType(data.get("type", "command")),
+            enabled=data.get("enabled", True),
+            timeout_seconds=data.get("timeout", 5.0),
+            interval_seconds=data.get("interval", 30.0),
+            retries=data.get("retries", 3),
+            url=data.get("url"),
+            method=data.get("method", "GET"),
+            expected_status=data.get("expected_status", 200),
+            expected_body=data.get("expected_body"),
+            expected_json=data.get("expected_json"),
+            headers=data.get("headers", {}),
+            host=data.get("host", "localhost"),
+            port=data.get("port"),
+            command=data.get("command") or data.get("exec"),
+            expected_output=data.get("expected_output"),
+            expected_exit_code=data.get("expected_exit_code", data.get("exit_code", 0)),
+            script_path=data.get("script_path") or data.get("path"),
+            failure_threshold=data.get("failure_threshold", 3),
+            success_threshold=data.get("success_threshold", 1),
+        )
+
+
+@dataclass
+class HealthCheckResult:
+    """Result of a health check."""
+
+    probe_name: str
+    status: HealthStatus
+    checked_at: datetime
+    duration_ms: float
+
+    message: Optional[str] = None
+    error: Optional[str] = None
+    details: Dict[str, Any] = field(default_factory=dict)
+
+    # Response info (for HTTP)
+    response_code: Optional[int] = None
+    response_body: Optional[str] = None
+
+    # Command info
+    exit_code: Optional[int] = None
+    stdout: Optional[str] = None
+    stderr: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "probe_name": self.probe_name,
+            "status": self.status.value,
+            "checked_at": self.checked_at.isoformat(),
+            "duration_ms": self.duration_ms,
+            "message": self.message,
+            "error": self.error,
+            "details": self.details,
+            "response_code": self.response_code,
+            "exit_code": self.exit_code,
+        }
+
+    @property
+    def is_healthy(self) -> bool:
+        """Check if result indicates healthy status."""
+        return self.status == HealthStatus.HEALTHY
+
+
+@dataclass
+class VMHealthState:
+    """Aggregated health state for a VM."""
+
+    vm_name: str
+    overall_status: HealthStatus
+    last_check: datetime
+    check_results: List[HealthCheckResult] = field(default_factory=list)
+
+    # Counters
+    consecutive_failures: int = 0
+    consecutive_successes: int = 0
+    total_checks: int = 0
+    total_failures: int = 0
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "vm_name": self.vm_name,
+            "overall_status": self.overall_status.value,
+            "last_check": self.last_check.isoformat(),
+            "check_results": [r.to_dict() for r in self.check_results],
+            "consecutive_failures": self.consecutive_failures,
+            "consecutive_successes": self.consecutive_successes,
+            "total_checks": self.total_checks,
+            "total_failures": self.total_failures,
+        }
+
+    @property
+    def failure_rate(self) -> float:
+        """Calculate failure rate percentage."""
+        if self.total_checks == 0:
+            return 0.0
+        return (self.total_failures / self.total_checks) * 100

clonebox/monitor.py

@@ -0,0 +1,269 @@
+#!/usr/bin/env python3
+"""
+Real-time resource monitoring for CloneBox VMs and containers.
+"""
+
+import json
+import subprocess
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+try:
+    import libvirt
+except ImportError:
+    libvirt = None
+
+
+@dataclass
+class VMStats:
+    """VM resource statistics."""
+
+    name: str
+    state: str
+    cpu_percent: float
+    memory_used_mb: int
+    memory_total_mb: int
+    disk_used_gb: float
+    disk_total_gb: float
+    network_rx_bytes: int
+    network_tx_bytes: int
+    uptime_seconds: int
+
+
+@dataclass
+class ContainerStats:
+    """Container resource statistics."""
+
+    name: str
+    state: str
+    cpu_percent: float
+    memory_used_mb: int
+    memory_limit_mb: int
+    network_rx_bytes: int
+    network_tx_bytes: int
+    pids: int
+
+
+class ResourceMonitor:
+    """Monitor VM and container resources in real-time."""
+
+    def __init__(self, conn_uri: str = "qemu:///session"):
+        self.conn_uri = conn_uri
+        self._conn = None
+        self._prev_cpu: Dict[str, tuple] = {}
+
+    @property
+    def conn(self):
+        if self._conn is None:
+            if libvirt is None:
+                raise RuntimeError("libvirt-python not installed")
+            self._conn = libvirt.open(self.conn_uri)
+        return self._conn
+
+    def get_vm_stats(self, vm_name: str) -> Optional[VMStats]:
+        """Get resource statistics for a VM."""
+        try:
+            dom = self.conn.lookupByName(vm_name)
+            info = dom.info()
+
+            state_map = {
+                libvirt.VIR_DOMAIN_RUNNING: "running",
+                libvirt.VIR_DOMAIN_PAUSED: "paused",
+                libvirt.VIR_DOMAIN_SHUTDOWN: "shutdown",
+                libvirt.VIR_DOMAIN_SHUTOFF: "shutoff",
+                libvirt.VIR_DOMAIN_CRASHED: "crashed",
+            }
+            state = state_map.get(info[0], "unknown")
+
+            # Memory
+            memory_total_mb = info[1] // 1024
+            memory_used_mb = info[2] // 1024 if info[2] > 0 else memory_total_mb
+
+            # CPU percentage (requires two samples)
+            cpu_time = info[4]
+            now = time.time()
+            cpu_percent = 0.0
+
+            if vm_name in self._prev_cpu:
+                prev_time, prev_cpu = self._prev_cpu[vm_name]
+                time_delta = now - prev_time
+                if time_delta > 0:
+                    cpu_delta = cpu_time - prev_cpu
+                    # CPU time is in nanoseconds
+                    cpu_percent = (cpu_delta / (time_delta * 1e9)) * 100
+                    cpu_percent = min(cpu_percent, 100.0 * info[3])  # Cap at vcpus * 100%
+
+            self._prev_cpu[vm_name] = (now, cpu_time)
+
+            # Disk stats (from block devices)
+            disk_used_gb = 0.0
+            disk_total_gb = 0.0
+            try:
+                xml = dom.XMLDesc()
+                import xml.etree.ElementTree as ET
+
+                root = ET.fromstring(xml)
+                for disk in root.findall(".//disk[@type='file']"):
+                    source = disk.find(".//source")
+                    if source is not None and source.get("file"):
+                        disk_path = Path(source.get("file"))
+                        if disk_path.exists():
+                            size_bytes = disk_path.stat().st_size
+                            disk_total_gb += size_bytes / (1024**3)
+                            # Actual usage requires qemu-img info
+                            disk_used_gb += size_bytes / (1024**3)
+            except Exception:
+                pass
+
+            # Network stats
+            network_rx = 0
+            network_tx = 0
+            try:
+                for iface in dom.interfaceAddresses(
+                    libvirt.VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_AGENT
+                ).keys():
+                    stats = dom.interfaceStats(iface)
+                    network_rx += stats[0]
+                    network_tx += stats[4]
+            except Exception:
+                pass
+
+            return VMStats(
+                name=vm_name,
+                state=state,
+                cpu_percent=cpu_percent,
+                memory_used_mb=memory_used_mb,
+                memory_total_mb=memory_total_mb,
+                disk_used_gb=disk_used_gb,
+                disk_total_gb=disk_total_gb,
+                network_rx_bytes=network_rx,
+                network_tx_bytes=network_tx,
+                uptime_seconds=0,  # Would need guest agent for accurate uptime
+            )
+
+        except Exception:
+            return None
+
+    def get_all_vm_stats(self) -> List[VMStats]:
+        """Get stats for all VMs."""
+        stats = []
+        try:
+            for dom in self.conn.listAllDomains():
+                vm_stats = self.get_vm_stats(dom.name())
+                if vm_stats:
+                    stats.append(vm_stats)
+        except Exception:
+            pass
+        return stats
+
+    def get_container_stats(self, engine: str = "auto") -> List[ContainerStats]:
+        """Get resource statistics for containers."""
+        if engine == "auto":
+            engine = "podman" if self._check_engine("podman") else "docker"
+
+        try:
+            result = subprocess.run(
+                [engine, "stats", "--no-stream", "--format", "json"],
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+            if result.returncode != 0:
+                return []
+
+            containers = json.loads(result.stdout) if result.stdout.strip() else []
+            stats = []
+
+            for c in containers:
+                # Parse CPU percentage
+                cpu_str = c.get("CPUPerc", "0%").replace("%", "")
+                try:
+                    cpu_percent = float(cpu_str)
+                except ValueError:
+                    cpu_percent = 0.0
+
+                # Parse memory
+                mem_usage = c.get("MemUsage", "0MiB / 0MiB")
+                mem_parts = mem_usage.split("/")
+                mem_used = self._parse_memory(mem_parts[0].strip()) if len(mem_parts) > 0 else 0
+                mem_limit = self._parse_memory(mem_parts[1].strip()) if len(mem_parts) > 1 else 0
+
+                # Parse network
+                net_io = c.get("NetIO", "0B / 0B")
+                net_parts = net_io.split("/")
+                net_rx = self._parse_bytes(net_parts[0].strip()) if len(net_parts) > 0 else 0
+                net_tx = self._parse_bytes(net_parts[1].strip()) if len(net_parts) > 1 else 0
+
+                stats.append(
+                    ContainerStats(
+                        name=c.get("Name", c.get("Names", "unknown")),
+                        state="running",
+                        cpu_percent=cpu_percent,
+                        memory_used_mb=mem_used,
+                        memory_limit_mb=mem_limit,
+                        network_rx_bytes=net_rx,
+                        network_tx_bytes=net_tx,
+                        pids=int(c.get("PIDs", 0)),
+                    )
+                )
+
+            return stats
+
+        except Exception:
+            return []
+
+    def _check_engine(self, engine: str) -> bool:
+        """Check if container engine is available."""
+        try:
+            result = subprocess.run(
+                [engine, "--version"], capture_output=True, timeout=5
+            )
+            return result.returncode == 0
+        except Exception:
+            return False
+
+    def _parse_memory(self, mem_str: str) -> int:
+        """Parse memory string like '100MiB' to MB."""
+        mem_str = mem_str.upper()
+        try:
+            if "GIB" in mem_str or "GB" in mem_str:
+                return int(float(mem_str.replace("GIB", "").replace("GB", "").strip()) * 1024)
+            elif "MIB" in mem_str or "MB" in mem_str:
+                return int(float(mem_str.replace("MIB", "").replace("MB", "").strip()))
+            elif "KIB" in mem_str or "KB" in mem_str:
+                return int(float(mem_str.replace("KIB", "").replace("KB", "").strip()) / 1024)
+            else:
+                return int(float(mem_str.replace("B", "").strip()) / (1024 * 1024))
+        except ValueError:
+            return 0
+
+    def _parse_bytes(self, bytes_str: str) -> int:
+        """Parse byte string like '1.5GB' to bytes."""
+        bytes_str = bytes_str.upper()
+        try:
+            if "GB" in bytes_str:
+                return int(float(bytes_str.replace("GB", "").strip()) * 1024**3)
+            elif "MB" in bytes_str:
+                return int(float(bytes_str.replace("MB", "").strip()) * 1024**2)
+            elif "KB" in bytes_str:
+                return int(float(bytes_str.replace("KB", "").strip()) * 1024)
+            else:
+                return int(float(bytes_str.replace("B", "").strip()))
+        except ValueError:
+            return 0
+
+    def close(self) -> None:
+        if self._conn is not None:
+            self._conn.close()
+            self._conn = None
+
+
+def format_bytes(num_bytes: int) -> str:
+    """Format bytes to human-readable string."""
+    for unit in ["B", "KB", "MB", "GB", "TB"]:
+        if abs(num_bytes) < 1024.0:
+            return f"{num_bytes:.1f}{unit}"
+        num_bytes /= 1024.0
+    return f"{num_bytes:.1f}PB"

clonebox/snapshots/__init__.py

@@ -0,0 +1,12 @@
+"""Snapshot management for CloneBox VMs."""
+
+from .models import Snapshot, SnapshotType, SnapshotState, SnapshotPolicy
+from .manager import SnapshotManager
+
+__all__ = [
+    "Snapshot",
+    "SnapshotType",
+    "SnapshotState",
+    "SnapshotPolicy",
+    "SnapshotManager",
+]

clonebox/snapshots/manager.py

@@ -0,0 +1,355 @@
+#!/usr/bin/env python3
+"""Snapshot manager for CloneBox VMs."""
+
+import json
+import subprocess
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from .models import Snapshot, SnapshotPolicy, SnapshotState, SnapshotType
+
+try:
+    import libvirt
+except ImportError:
+    libvirt = None
+
+
+class SnapshotManager:
+    """Manage VM snapshots via libvirt."""
+
+    def __init__(self, conn_uri: str = "qemu:///session"):
+        self.conn_uri = conn_uri
+        self._conn = None
+        self._snapshots_dir = Path.home() / ".local/share/clonebox/snapshots"
+        self._snapshots_dir.mkdir(parents=True, exist_ok=True)
+
+    @property
+    def conn(self):
+        if self._conn is None:
+            if libvirt is None:
+                raise RuntimeError("libvirt-python not installed")
+            self._conn = libvirt.open(self.conn_uri)
+        return self._conn
+
+    def create(
+        self,
+        vm_name: str,
+        name: str,
+        description: Optional[str] = None,
+        snapshot_type: SnapshotType = SnapshotType.DISK_ONLY,
+        tags: Optional[List[str]] = None,
+        auto_policy: Optional[str] = None,
+        expires_in_days: Optional[int] = None,
+    ) -> Snapshot:
+        """Create a new snapshot.
+
+        Args:
+            vm_name: Name of VM to snapshot
+            name: Snapshot name
+            description: Optional description
+            snapshot_type: Type of snapshot (disk, full, external)
+            tags: Optional tags for categorization
+            auto_policy: If auto-created, the policy name
+            expires_in_days: Auto-expire after N days
+        """
+        domain = self.conn.lookupByName(vm_name)
+
+        # Generate snapshot XML
+        snapshot_xml = self._generate_snapshot_xml(
+            name=name,
+            description=description,
+            snapshot_type=snapshot_type,
+        )
+
+        # Create snapshot
+        flags = 0
+        if snapshot_type == SnapshotType.DISK_ONLY:
+            flags = libvirt.VIR_DOMAIN_SNAPSHOT_CREATE_DISK_ONLY
+        elif snapshot_type == SnapshotType.FULL:
+            flags = libvirt.VIR_DOMAIN_SNAPSHOT_CREATE_ATOMIC
+
+        try:
+            snap = domain.snapshotCreateXML(snapshot_xml, flags)
+        except libvirt.libvirtError as e:
+            raise RuntimeError(f"Failed to create snapshot: {e}")
+
+        # Build snapshot object
+        snapshot = Snapshot(
+            name=name,
+            vm_name=vm_name,
+            snapshot_type=snapshot_type,
+            state=SnapshotState.READY,
+            created_at=datetime.now(),
+            description=description,
+            tags=tags or [],
+            auto_created=auto_policy is not None,
+            auto_policy=auto_policy,
+            expires_at=(
+                datetime.now() + timedelta(days=expires_in_days)
+                if expires_in_days
+                else None
+            ),
+        )
+
+        # Save metadata
+        self._save_snapshot_metadata(snapshot)
+
+        return snapshot
+
+    def restore(
+        self,
+        vm_name: str,
+        name: str,
+        force: bool = False,
+    ) -> bool:
+        """Restore VM to a snapshot.
+
+        Args:
+            vm_name: Name of VM
+            name: Snapshot name to restore
+            force: Force restore even if VM is running
+        """
+        domain = self.conn.lookupByName(vm_name)
+
+        # Check if VM is running
+        if domain.isActive() and not force:
+            raise RuntimeError(
+                f"VM '{vm_name}' is running. Stop it first or use --force"
+            )
+
+        try:
+            snap = domain.snapshotLookupByName(name)
+        except libvirt.libvirtError:
+            raise RuntimeError(f"Snapshot '{name}' not found for VM '{vm_name}'")
+
+        # Revert to snapshot
+        flags = libvirt.VIR_DOMAIN_SNAPSHOT_REVERT_FORCE if force else 0
+        try:
+            domain.revertToSnapshot(snap, flags)
+        except libvirt.libvirtError as e:
+            raise RuntimeError(f"Failed to restore snapshot: {e}")
+
+        return True
+
+    def delete(
+        self,
+        vm_name: str,
+        name: str,
+        delete_children: bool = False,
+    ) -> bool:
+        """Delete a snapshot.
+
+        Args:
+            vm_name: Name of VM
+            name: Snapshot name to delete
+            delete_children: Also delete child snapshots
+        """
+        domain = self.conn.lookupByName(vm_name)
+
+        try:
+            snap = domain.snapshotLookupByName(name)
+        except libvirt.libvirtError:
+            raise RuntimeError(f"Snapshot '{name}' not found for VM '{vm_name}'")
+
+        flags = 0
+        if delete_children:
+            flags = libvirt.VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN
+
+        try:
+            snap.delete(flags)
+        except libvirt.libvirtError as e:
+            raise RuntimeError(f"Failed to delete snapshot: {e}")
+
+        # Remove metadata
+        self._delete_snapshot_metadata(vm_name, name)
+
+        return True
+
+    def list(self, vm_name: str) -> List[Snapshot]:
+        """List all snapshots for a VM."""
+        domain = self.conn.lookupByName(vm_name)
+        snapshots = []
+
+        try:
+            snap_names = domain.snapshotListNames()
+        except libvirt.libvirtError:
+            return []
+
+        for snap_name in snap_names:
+            try:
+                snap = domain.snapshotLookupByName(snap_name)
+                snap_xml = snap.getXMLDesc()
+
+                # Parse XML for details
+                import xml.etree.ElementTree as ET
+
+                root = ET.fromstring(snap_xml)
+
+                name = root.findtext("name", snap_name)
+                description = root.findtext("description", "")
+                creation_time = root.findtext("creationTime", "0")
+
+                # Check for saved metadata
+                metadata = self._load_snapshot_metadata(vm_name, name)
+
+                snapshot = Snapshot(
+                    name=name,
+                    vm_name=vm_name,
+                    snapshot_type=SnapshotType(
+                        metadata.get("type", "disk") if metadata else "disk"
+                    ),
+                    state=SnapshotState.READY,
+                    created_at=(
+                        datetime.fromtimestamp(int(creation_time))
+                        if creation_time != "0"
+                        else datetime.now()
+                    ),
+                    description=description or None,
+                    tags=metadata.get("tags", []) if metadata else [],
+                    auto_created=metadata.get("auto_created", False) if metadata else False,
+                    auto_policy=metadata.get("auto_policy") if metadata else None,
+                    expires_at=(
+                        datetime.fromisoformat(metadata["expires_at"])
+                        if metadata and metadata.get("expires_at")
+                        else None
+                    ),
+                )
+                snapshots.append(snapshot)
+
+            except Exception:
+                continue
+
+        return sorted(snapshots, key=lambda s: s.created_at, reverse=True)
+
+    def get(self, vm_name: str, name: str) -> Optional[Snapshot]:
+        """Get a specific snapshot."""
+        snapshots = self.list(vm_name)
+        for snap in snapshots:
+            if snap.name == name:
+                return snap
+        return None
+
+    def cleanup_expired(self, vm_name: str) -> List[str]:
+        """Delete expired snapshots for a VM."""
+        deleted = []
+        for snapshot in self.list(vm_name):
+            if snapshot.is_expired:
+                try:
+                    self.delete(vm_name, snapshot.name)
+                    deleted.append(snapshot.name)
+                except Exception:
+                    pass
+        return deleted
+
+    def apply_policy(self, vm_name: str, policy: SnapshotPolicy) -> List[str]:
+        """Apply retention policy to VM snapshots."""
+        if not policy.auto_cleanup:
+            return []
+
+        snapshots = self.list(vm_name)
+        auto_snapshots = [s for s in snapshots if s.auto_policy == policy.name]
+
+        deleted = []
+
+        # Sort by age (oldest first)
+        auto_snapshots.sort(key=lambda s: s.created_at)
+
+        # Delete if over max count
+        while len(auto_snapshots) > policy.max_snapshots:
+            if len(auto_snapshots) <= policy.min_snapshots:
+                break
+            oldest = auto_snapshots.pop(0)
+            try:
+                self.delete(vm_name, oldest.name)
+                deleted.append(oldest.name)
+            except Exception:
+                pass
+
+        # Delete if over max age
+        max_age = timedelta(days=policy.max_age_days)
+        for snap in auto_snapshots[:]:
+            if snap.age > max_age:
+                if len(auto_snapshots) <= policy.min_snapshots:
+                    break
+                try:
+                    self.delete(vm_name, snap.name)
+                    deleted.append(snap.name)
+                    auto_snapshots.remove(snap)
+                except Exception:
+                    pass
+
+        return deleted
+
+    def create_auto_snapshot(
+        self,
+        vm_name: str,
+        operation: str,
+        policy: Optional[SnapshotPolicy] = None,
+    ) -> Snapshot:
+        """Create automatic snapshot before operation."""
+        policy = policy or SnapshotPolicy(name="default")
+
+        name = policy.generate_snapshot_name(operation)
+
+        return self.create(
+            vm_name=vm_name,
+            name=name,
+            description=f"Auto-snapshot before {operation}",
+            snapshot_type=SnapshotType.DISK_ONLY,
+            auto_policy=policy.name,
+            expires_in_days=policy.max_age_days,
+        )
+
+    def _generate_snapshot_xml(
+        self,
+        name: str,
+        description: Optional[str],
+        snapshot_type: SnapshotType,
+    ) -> str:
+        """Generate libvirt snapshot XML."""
+        desc_xml = f"<description>{description}</description>" if description else ""
+
+        if snapshot_type == SnapshotType.DISK_ONLY:
+            disks_xml = "<disks><disk name='vda' snapshot='internal'/></disks>"
+        else:
+            disks_xml = ""
+
+        return f"""
+        <domainsnapshot>
+            <name>{name}</name>
+            {desc_xml}
+            {disks_xml}
+        </domainsnapshot>
+        """
+
+    def _save_snapshot_metadata(self, snapshot: Snapshot) -> None:
+        """Save snapshot metadata to disk."""
+        vm_dir = self._snapshots_dir / snapshot.vm_name
+        vm_dir.mkdir(parents=True, exist_ok=True)
+
+        meta_file = vm_dir / f"{snapshot.name}.json"
+        meta_file.write_text(json.dumps(snapshot.to_dict(), indent=2))
+
+    def _load_snapshot_metadata(
+        self, vm_name: str, name: str
+    ) -> Optional[Dict[str, Any]]:
+        """Load snapshot metadata from disk."""
+        meta_file = self._snapshots_dir / vm_name / f"{name}.json"
+        if meta_file.exists():
+            try:
+                return json.loads(meta_file.read_text())
+            except Exception:
+                return None
+        return None
+
+    def _delete_snapshot_metadata(self, vm_name: str, name: str) -> None:
+        """Delete snapshot metadata from disk."""
+        meta_file = self._snapshots_dir / vm_name / f"{name}.json"
+        if meta_file.exists():
+            meta_file.unlink()
+
+    def close(self) -> None:
+        if self._conn is not None:
+            self._conn.close()
+            self._conn = None

clonebox/snapshots/models.py

@@ -0,0 +1,187 @@
+#!/usr/bin/env python3
+"""Data models for snapshot management."""
+
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+from enum import Enum
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+class SnapshotType(Enum):
+    """Type of snapshot."""
+
+    DISK_ONLY = "disk"  # Only disk state (offline)
+    FULL = "full"  # Disk + memory + device state (online)
+    EXTERNAL = "external"  # External snapshot file
+
+
+class SnapshotState(Enum):
+    """State of snapshot operation."""
+
+    CREATING = "creating"
+    READY = "ready"
+    REVERTING = "reverting"
+    DELETING = "deleting"
+    FAILED = "failed"
+
+
+@dataclass
+class Snapshot:
+    """Represents a VM snapshot."""
+
+    name: str
+    vm_name: str
+    snapshot_type: SnapshotType
+    state: SnapshotState
+    created_at: datetime
+
+    description: Optional[str] = None
+
+    # Snapshot hierarchy
+    parent_name: Optional[str] = None
+    children: List[str] = field(default_factory=list)
+
+    # Storage info
+    disk_path: Optional[Path] = None
+    memory_path: Optional[Path] = None
+    size_bytes: int = 0
+
+    # Metadata
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    tags: List[str] = field(default_factory=list)
+
+    # Auto-snapshot info
+    auto_created: bool = False
+    auto_policy: Optional[str] = None
+    expires_at: Optional[datetime] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return {
+            "name": self.name,
+            "vm_name": self.vm_name,
+            "type": self.snapshot_type.value,
+            "state": self.state.value,
+            "created_at": self.created_at.isoformat(),
+            "description": self.description,
+            "parent_name": self.parent_name,
+            "children": self.children,
+            "disk_path": str(self.disk_path) if self.disk_path else None,
+            "memory_path": str(self.memory_path) if self.memory_path else None,
+            "size_bytes": self.size_bytes,
+            "metadata": self.metadata,
+            "tags": self.tags,
+            "auto_created": self.auto_created,
+            "auto_policy": self.auto_policy,
+            "expires_at": self.expires_at.isoformat() if self.expires_at else None,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Snapshot":
+        """Create from dictionary."""
+        return cls(
+            name=data["name"],
+            vm_name=data["vm_name"],
+            snapshot_type=SnapshotType(data["type"]),
+            state=SnapshotState(data["state"]),
+            created_at=datetime.fromisoformat(data["created_at"]),
+            description=data.get("description"),
+            parent_name=data.get("parent_name"),
+            children=data.get("children", []),
+            disk_path=Path(data["disk_path"]) if data.get("disk_path") else None,
+            memory_path=Path(data["memory_path"]) if data.get("memory_path") else None,
+            size_bytes=data.get("size_bytes", 0),
+            metadata=data.get("metadata", {}),
+            tags=data.get("tags", []),
+            auto_created=data.get("auto_created", False),
+            auto_policy=data.get("auto_policy"),
+            expires_at=(
+                datetime.fromisoformat(data["expires_at"])
+                if data.get("expires_at")
+                else None
+            ),
+        )
+
+    @property
+    def is_expired(self) -> bool:
+        """Check if snapshot has expired."""
+        if self.expires_at is None:
+            return False
+        return datetime.now() > self.expires_at
+
+    @property
+    def age(self) -> timedelta:
+        """Get snapshot age."""
+        return datetime.now() - self.created_at
+
+
+@dataclass
+class SnapshotPolicy:
+    """Policy for automatic snapshots."""
+
+    name: str
+    enabled: bool = True
+
+    # Retention settings
+    max_snapshots: int = 10
+    max_age_days: int = 30
+    min_snapshots: int = 1  # Keep at least N snapshots
+
+    # Auto-snapshot triggers
+    before_operations: List[str] = field(
+        default_factory=lambda: ["upgrade", "resize", "config-change"]
+    )
+    scheduled_interval_hours: Optional[int] = None  # e.g., 24 for daily
+
+    # Naming
+    name_prefix: str = "auto-"
+    include_timestamp: bool = True
+
+    # Cleanup
+    auto_cleanup: bool = True
+    cleanup_on_success: bool = False  # Remove pre-operation snapshot if op succeeds
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "name": self.name,
+            "enabled": self.enabled,
+            "max_snapshots": self.max_snapshots,
+            "max_age_days": self.max_age_days,
+            "min_snapshots": self.min_snapshots,
+            "before_operations": self.before_operations,
+            "scheduled_interval_hours": self.scheduled_interval_hours,
+            "name_prefix": self.name_prefix,
+            "include_timestamp": self.include_timestamp,
+            "auto_cleanup": self.auto_cleanup,
+            "cleanup_on_success": self.cleanup_on_success,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "SnapshotPolicy":
+        """Create from dictionary."""
+        return cls(
+            name=data["name"],
+            enabled=data.get("enabled", True),
+            max_snapshots=data.get("max_snapshots", 10),
+            max_age_days=data.get("max_age_days", 30),
+            min_snapshots=data.get("min_snapshots", 1),
+            before_operations=data.get(
+                "before_operations", ["upgrade", "resize", "config-change"]
+            ),
+            scheduled_interval_hours=data.get("scheduled_interval_hours"),
+            name_prefix=data.get("name_prefix", "auto-"),
+            include_timestamp=data.get("include_timestamp", True),
+            auto_cleanup=data.get("auto_cleanup", True),
+            cleanup_on_success=data.get("cleanup_on_success", False),
+        )
+
+    def generate_snapshot_name(self, operation: Optional[str] = None) -> str:
+        """Generate snapshot name based on policy."""
+        parts = [self.name_prefix]
+        if operation:
+            parts.append(operation)
+        if self.include_timestamp:
+            parts.append(datetime.now().strftime("%Y%m%d-%H%M%S"))
+        return "-".join(parts)

{clonebox-1.1.3.dist-info → clonebox-1.1.4.dist-info}/METADATA

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

@@ -1,6 +1,6 @@
 clonebox/__init__.py,sha256=CyfHVVq6KqBr4CNERBpXk_O6Q5B35q03YpdQbokVvvI,408
 clonebox/__main__.py,sha256=Fcoyzwwyz5-eC_sBlQk5a5RbKx8uodQz5sKJ190U0NU,135
-clonebox/cli.py,sha256=iPc2DWEDZaqBMXRJqpWKubmka9ZuJbAvs6mkMMEHAlw,122910
+clonebox/cli.py,sha256=MeW_Jnbmrp9QrfA72a2pydeeINCY_LNBqJEGaD2rxtE,128687
 clonebox/cloner.py,sha256=2YQO4SHCv0xOsU1hL9IqdgmxxJN-2j75X9pe-LpTpJE,82696
 clonebox/container.py,sha256=tiYK1ZB-DhdD6A2FuMA0h_sRNkUI7KfYcJ0tFOcdyeM,6105
 clonebox/dashboard.py,sha256=dMY6odvPq3j6FronhRRsX7aY3qdCwznB-aCWKEmHDNw,5768
@@ -8,14 +8,20 @@ clonebox/detector.py,sha256=vS65cvFNPmUBCX1Y_TMTnSRljw6r1Ae9dlVtACs5XFc,23075
 clonebox/exporter.py,sha256=WIzVvmA0z_jjrpyXxvnXoLp9oaW6fKS7k0PGwzx_PIM,5629
 clonebox/importer.py,sha256=Q9Uk1IOA41mgGhU4ynW2k-h9GEoGxRKI3c9wWE4uxcA,7097
 clonebox/models.py,sha256=zwejkNtEEO_aPy_Q5UzXG5tszU-c7lkqh9LQus9eWMo,8307
+clonebox/monitor.py,sha256=KQKi63mcz6KULi2SpD5oi1g05CKaFTC2dAyyRJtJX-E,9211
 clonebox/p2p.py,sha256=LPQQ7wNO84yDnpVrGkaRU-FDUzqmC4URdZXVeHsNOew,5889
 clonebox/profiles.py,sha256=UP37fX_rhrG_O9ehNFJBUcULPmUtN1A8KsJ6cM44oK0,1986
 clonebox/validator.py,sha256=CF4hMlY69-AGRH5HdG8HAA9_LNCwDKD4xPlYQPWJ9Rw,36647
+clonebox/health/__init__.py,sha256=hW6MB8qc3pE-Jub1Djnz2G1AGs4Tn4Y2FbuYur6m8aE,394
+clonebox/health/models.py,sha256=sPumwj8S-88KgzSGw1Kq9bBbPVRd2RR0R87Z8hKJ_28,6001
+clonebox/snapshots/__init__.py,sha256=ndlrIavPAiA8z4Ep3-D_EPhOcjNKYFnP3rIpEKaGdb8,273
+clonebox/snapshots/manager.py,sha256=FuJB_q9fUs7GScVdX5vePezBDI9m8zwIrG1BDFvjeNM,11469
+clonebox/snapshots/models.py,sha256=upJhlHLYFWBrMzCMI8Zzd1z66JRV69R2qLDCTrDtJUY,6268
 clonebox/templates/profiles/ml-dev.yaml,sha256=w07MToGh31xtxpjbeXTBk9BkpAN8A3gv8HeA3ESKG9M,461
 clonebox/templates/profiles/web-stack.yaml,sha256=EBnnGMzML5vAjXmIUbCpbTCwmRaNJiuWd3EcL43DOK8,485
-clonebox-1.1.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-clonebox-1.1.3.dist-info/METADATA,sha256=16ilGCqzzvMBvEXxLZ-JlTyNxaI0u6ws74zM121Sw5o,47947
-clonebox-1.1.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-clonebox-1.1.3.dist-info/entry_points.txt,sha256=FES95Vi3btfViLEEoHdb8nikNxTqzaooi9ehZw9ZfWI,47
-clonebox-1.1.3.dist-info/top_level.txt,sha256=LdMo2cvCrEcRGH2M8JgQNVsCoszLV0xug6kx1JnaRjo,9
-clonebox-1.1.3.dist-info/RECORD,,
+clonebox-1.1.4.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+clonebox-1.1.4.dist-info/METADATA,sha256=TfNWk7EAyhCtPtEoyERrJz2f2Xhn6Lg08DjfC6zuj0E,47947
+clonebox-1.1.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+clonebox-1.1.4.dist-info/entry_points.txt,sha256=FES95Vi3btfViLEEoHdb8nikNxTqzaooi9ehZw9ZfWI,47
+clonebox-1.1.4.dist-info/top_level.txt,sha256=LdMo2cvCrEcRGH2M8JgQNVsCoszLV0xug6kx1JnaRjo,9
+clonebox-1.1.4.dist-info/RECORD,,