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

clonebox/cli.py

@@ -28,6 +28,10 @@ from clonebox.container import ContainerCloner
 from clonebox.detector import SystemDetector
 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
 custom_style = Style(
@@ -2635,6 +2639,239 @@ 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()
+    console.print(f"[green]🔑 Encryption key generated: {key_path}[/]")
+    console.print("[dim]Share this key with team members for encrypted transfers.[/]")
+
+
+def cmd_export_encrypted(args) -> None:
+    """Export VM with AES-256 encryption."""
+    vm_name, config_file = _resolve_vm_name_and_config_file(args.name)
+    conn_uri = "qemu:///session" if getattr(args, "user", False) else "qemu:///system"
+    output = Path(args.output) if args.output else Path(f"{vm_name}.enc")
+
+    console.print(f"[cyan]🔒 Exporting encrypted: {vm_name} → {output}[/]")
+
+    try:
+        exporter = SecureExporter(conn_uri)
+        exporter.export_encrypted(
+            vm_name=vm_name,
+            output_path=output,
+            include_user_data=getattr(args, "user_data", False),
+            include_app_data=getattr(args, "include_data", False),
+        )
+        console.print(f"[green]✅ Encrypted export complete: {output}[/]")
+    except FileNotFoundError as e:
+        console.print(f"[red]❌ {e}[/]")
+        console.print("[yellow]Run: clonebox keygen[/]")
+    finally:
+        exporter.close()
+
+
+def cmd_import_encrypted(args) -> None:
+    """Import VM with AES-256 decryption."""
+    archive = Path(args.archive)
+    conn_uri = "qemu:///session" if getattr(args, "user", False) else "qemu:///system"
+
+    console.print(f"[cyan]🔓 Importing encrypted: {archive}[/]")
+
+    try:
+        importer = SecureImporter(conn_uri)
+        vm_name = importer.import_decrypted(
+            encrypted_path=archive,
+            import_user_data=getattr(args, "user_data", False),
+            import_app_data=getattr(args, "include_data", False),
+            new_name=getattr(args, "name", None),
+        )
+        console.print(f"[green]✅ Import complete: {vm_name}[/]")
+    except FileNotFoundError as e:
+        console.print(f"[red]❌ {e}[/]")
+    finally:
+        importer.close()
+
+
+def cmd_export_remote(args) -> None:
+    """Export VM from remote host."""
+    p2p = P2PManager()
+
+    console.print(f"[cyan]📤 Remote export: {args.host}:{args.vm_name}[/]")
+
+    try:
+        output = Path(args.output)
+        p2p.export_remote(
+            host=args.host,
+            vm_name=args.vm_name,
+            output=output,
+            encrypted=getattr(args, "encrypted", False),
+            include_user_data=getattr(args, "user_data", False),
+            include_app_data=getattr(args, "include_data", False),
+        )
+        console.print(f"[green]✅ Remote export complete: {output}[/]")
+    except RuntimeError as e:
+        console.print(f"[red]❌ {e}[/]")
+
+
+def cmd_import_remote(args) -> None:
+    """Import VM to remote host."""
+    p2p = P2PManager()
+    archive = Path(args.archive)
+
+    console.print(f"[cyan]📥 Remote import: {archive} → {args.host}[/]")
+
+    try:
+        p2p.import_remote(
+            host=args.host,
+            archive_path=archive,
+            encrypted=getattr(args, "encrypted", False),
+            import_user_data=getattr(args, "user_data", False),
+            new_name=getattr(args, "name", None),
+        )
+        console.print(f"[green]✅ Remote import complete[/]")
+    except RuntimeError as e:
+        console.print(f"[red]❌ {e}[/]")
+
+
+def cmd_sync_key(args) -> None:
+    """Sync encryption key to remote host."""
+    p2p = P2PManager()
+
+    console.print(f"[cyan]🔑 Syncing key to: {args.host}[/]")
+
+    try:
+        p2p.sync_key(args.host)
+        console.print(f"[green]✅ Key synced to {args.host}[/]")
+    except (FileNotFoundError, RuntimeError) as e:
+        console.print(f"[red]❌ {e}[/]")
+
+
+def cmd_list_remote(args) -> None:
+    """List VMs on remote host."""
+    p2p = P2PManager()
+
+    console.print(f"[cyan]🔍 Listing VMs on: {args.host}[/]")
+
+    vms = p2p.list_remote_vms(args.host)
+    if vms:
+        for vm in vms:
+            console.print(f"  • {vm}")
+    else:
+        console.print("[yellow]No VMs found on remote host.[/]")
+
+
 def main():
     """Main entry point."""
     parser = argparse.ArgumentParser(
@@ -3074,6 +3311,128 @@ 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
+    keygen_parser = subparsers.add_parser("keygen", help="Generate encryption key for secure transfers")
+    keygen_parser.set_defaults(func=cmd_keygen)
+
+    # Export-encrypted command
+    export_enc_parser = subparsers.add_parser(
+        "export-encrypted", help="Export VM with AES-256 encryption"
+    )
+    export_enc_parser.add_argument(
+        "name", nargs="?", default=None, help="VM name or '.' to use .clonebox.yaml"
+    )
+    export_enc_parser.add_argument(
+        "-u", "--user", action="store_true", help="Use user session (qemu:///session)"
+    )
+    export_enc_parser.add_argument(
+        "-o", "--output", help="Output file (default: <vmname>.enc)"
+    )
+    export_enc_parser.add_argument(
+        "--user-data", action="store_true", help="Include user data (SSH keys, configs)"
+    )
+    export_enc_parser.add_argument(
+        "--include-data", "-d", action="store_true", help="Include app data"
+    )
+    export_enc_parser.set_defaults(func=cmd_export_encrypted)
+
+    # Import-encrypted command
+    import_enc_parser = subparsers.add_parser(
+        "import-encrypted", help="Import VM with AES-256 decryption"
+    )
+    import_enc_parser.add_argument("archive", help="Path to encrypted archive (.enc)")
+    import_enc_parser.add_argument(
+        "-u", "--user", action="store_true", help="Use user session (qemu:///session)"
+    )
+    import_enc_parser.add_argument("--name", "-n", help="New name for imported VM")
+    import_enc_parser.add_argument(
+        "--user-data", action="store_true", help="Import user data"
+    )
+    import_enc_parser.add_argument(
+        "--include-data", "-d", action="store_true", help="Import app data"
+    )
+    import_enc_parser.set_defaults(func=cmd_import_encrypted)
+
+    # Export-remote command
+    export_remote_parser = subparsers.add_parser(
+        "export-remote", help="Export VM from remote host via SSH"
+    )
+    export_remote_parser.add_argument("host", help="Remote host (user@hostname)")
+    export_remote_parser.add_argument("vm_name", help="VM name on remote host")
+    export_remote_parser.add_argument(
+        "-o", "--output", required=True, help="Local output file"
+    )
+    export_remote_parser.add_argument(
+        "--encrypted", "-e", action="store_true", help="Use encrypted export"
+    )
+    export_remote_parser.add_argument(
+        "--user-data", action="store_true", help="Include user data"
+    )
+    export_remote_parser.add_argument(
+        "--include-data", "-d", action="store_true", help="Include app data"
+    )
+    export_remote_parser.set_defaults(func=cmd_export_remote)
+
+    # Import-remote command
+    import_remote_parser = subparsers.add_parser(
+        "import-remote", help="Import VM to remote host via SSH"
+    )
+    import_remote_parser.add_argument("archive", help="Local archive to upload")
+    import_remote_parser.add_argument("host", help="Remote host (user@hostname)")
+    import_remote_parser.add_argument("--name", "-n", help="New name for VM on remote")
+    import_remote_parser.add_argument(
+        "--encrypted", "-e", action="store_true", help="Use encrypted import"
+    )
+    import_remote_parser.add_argument(
+        "--user-data", action="store_true", help="Import user data"
+    )
+    import_remote_parser.set_defaults(func=cmd_import_remote)
+
+    # Sync-key command
+    sync_key_parser = subparsers.add_parser(
+        "sync-key", help="Sync encryption key to remote host"
+    )
+    sync_key_parser.add_argument("host", help="Remote host (user@hostname)")
+    sync_key_parser.set_defaults(func=cmd_sync_key)
+
+    # List-remote command
+    list_remote_parser = subparsers.add_parser(
+        "list-remote", help="List VMs on remote host"
+    )
+    list_remote_parser.add_argument("host", help="Remote host (user@hostname)")
+    list_remote_parser.set_defaults(func=cmd_list_remote)
+
     args = parser.parse_args()
 
     if hasattr(args, "func"):

clonebox/exporter.py

@@ -0,0 +1,189 @@
+#!/usr/bin/env python3
+"""
+VM Exporter - Export VM with all data and optional AES-256 encryption.
+"""
+
+import os
+import tarfile
+import tempfile
+import xml.etree.ElementTree as ET
+from pathlib import Path
+from typing import List, Optional
+
+from cryptography.fernet import Fernet
+
+try:
+    import libvirt
+except ImportError:
+    libvirt = None
+
+
+class VMExporter:
+    """Export VM with disks, app data, and user data."""
+
+    def __init__(self, conn_uri: str = "qemu:///system"):
+        self.conn_uri = conn_uri
+        self._conn = None
+
+    @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 export_vm(
+        self,
+        vm_name: str,
+        output_path: Path,
+        include_user_data: bool = False,
+        include_app_data: bool = False,
+    ) -> Path:
+        """Full export of VM with disks and optional data."""
+        vm = self.conn.lookupByName(vm_name)
+        vm_xml = vm.XMLDesc()
+        root = ET.fromstring(vm_xml)
+
+        # Find all disk files
+        disks: List[Path] = []
+        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():
+                    disks.append(disk_path)
+
+        # Create archive
+        with tarfile.open(output_path, "w:gz") as tar:
+            # Add XML config
+            xml_tmp = Path(tempfile.gettempdir()) / f"{vm_name}.xml"
+            xml_tmp.write_text(vm_xml)
+            tar.add(xml_tmp, arcname=f"{vm_name}.xml")
+            xml_tmp.unlink()
+
+            # Add disks
+            for disk in disks:
+                arcname = f"disks/{disk.name}"
+                tar.add(disk, arcname=arcname)
+                print(f"   💾 Added disk: {disk}")
+
+            # Add app data
+            if include_app_data:
+                self._export_app_data(tar)
+
+            # Add user data
+            if include_user_data:
+                self._export_user_data(tar)
+
+        return output_path
+
+    def _export_app_data(self, tar: tarfile.TarFile) -> None:
+        """Export common application data paths."""
+        common_paths = [
+            Path.home() / "projects",
+            Path.home() / ".docker",
+            Path("/opt/myapp"),
+            Path("/var/www"),
+            Path("/srv/docker"),
+        ]
+
+        for path in common_paths:
+            if path.exists():
+                arcname = f"app-data/{path.name}"
+                try:
+                    tar.add(path, arcname=arcname, recursive=True)
+                    print(f"   📁 App data: {path}")
+                except PermissionError:
+                    print(f"   ⚠️ Permission denied: {path}")
+
+    def _export_user_data(self, tar: tarfile.TarFile) -> None:
+        """Export user data (home, SSH keys)."""
+        user_paths = [
+            Path.home() / ".ssh",
+            Path.home() / ".gitconfig",
+            Path.home() / ".bashrc",
+            Path.home() / ".zshrc",
+        ]
+
+        for path in user_paths:
+            if path.exists():
+                arcname = f"user-data/{path.name}"
+                try:
+                    tar.add(path, arcname=arcname, recursive=True)
+                    print(f"   👤 User data: {path}")
+                except PermissionError:
+                    print(f"   ⚠️ Permission denied: {path}")
+
+    def close(self) -> None:
+        if self._conn is not None:
+            self._conn.close()
+            self._conn = None
+
+
+class SecureExporter:
+    """AES-256 encrypted VM export."""
+
+    KEY_PATH = Path.home() / ".clonebox.key"
+
+    def __init__(self, conn_uri: str = "qemu:///system"):
+        self.exporter = VMExporter(conn_uri)
+
+    @classmethod
+    def generate_key(cls) -> Path:
+        """Generate and save team encryption key."""
+        key = Fernet.generate_key()
+        cls.KEY_PATH.write_bytes(key)
+        os.chmod(str(cls.KEY_PATH), 0o600)
+        return cls.KEY_PATH
+
+    @classmethod
+    def load_key(cls) -> Optional[bytes]:
+        """Load encryption key from file."""
+        if cls.KEY_PATH.exists():
+            return cls.KEY_PATH.read_bytes()
+        return None
+
+    def export_encrypted(
+        self,
+        vm_name: str,
+        output_path: Path,
+        include_user_data: bool = False,
+        include_app_data: bool = False,
+    ) -> Path:
+        """Export VM with AES-256 encryption."""
+        key = self.load_key()
+        if key is None:
+            raise FileNotFoundError(
+                f"No encryption key found at {self.KEY_PATH}. Run: clonebox keygen"
+            )
+
+        fernet = Fernet(key)
+
+        # Create temporary unencrypted archive
+        with tempfile.NamedTemporaryFile(suffix=".tar.gz", delete=False) as tmp:
+            tmp_path = Path(tmp.name)
+
+        try:
+            # Export to temp file
+            self.exporter.export_vm(
+                vm_name=vm_name,
+                output_path=tmp_path,
+                include_user_data=include_user_data,
+                include_app_data=include_app_data,
+            )
+
+            # Encrypt
+            data = tmp_path.read_bytes()
+            encrypted = fernet.encrypt(data)
+            output_path.write_bytes(encrypted)
+
+        finally:
+            # Cleanup temp file
+            if tmp_path.exists():
+                tmp_path.unlink()
+
+        return output_path
+
+    def close(self) -> None:
+        self.exporter.close()

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",
+]