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

clonebox/secrets.py

@@ -0,0 +1,331 @@
+"""
+Secrets management for CloneBox.
+Supports multiple backends: env, vault, sops, age.
+"""
+
+import json
+import os
+import secrets
+import string
+import subprocess
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+
+@dataclass
+class SecretValue:
+    """Represents a secret value with metadata."""
+
+    key: str
+    value: str
+    source: str  # 'env', 'vault', 'sops', 'generated'
+    expires_at: Optional[str] = None
+
+    def __repr__(self) -> str:
+        return f"SecretValue(key={self.key}, source={self.source}, value=***)"
+
+    def redacted(self) -> str:
+        """Return redacted version for logging."""
+        return f"{self.value[:2]}***{self.value[-2:]}" if len(self.value) > 4 else "***"
+
+
+class SecretsProvider(ABC):
+    """Abstract base class for secrets providers."""
+
+    @abstractmethod
+    def get_secret(self, key: str) -> Optional[SecretValue]:
+        """Retrieve a secret by key."""
+        pass
+
+    @abstractmethod
+    def list_secrets(self) -> List[str]:
+        """List available secret keys."""
+        pass
+
+    @abstractmethod
+    def is_available(self) -> bool:
+        """Check if this provider is configured and available."""
+        pass
+
+
+class EnvSecretsProvider(SecretsProvider):
+    """Load secrets from environment variables and .env files."""
+
+    def __init__(self, env_file: Optional[Path] = None):
+        self.env_file = env_file or Path(".env")
+        self._cache: Dict[str, str] = {}
+        self._load_env_file()
+
+    def _load_env_file(self) -> None:
+        if self.env_file.exists():
+            with open(self.env_file) as f:
+                for line in f:
+                    line = line.strip()
+                    if line and not line.startswith("#") and "=" in line:
+                        key, _, value = line.partition("=")
+                        self._cache[key.strip()] = value.strip().strip("'\"")
+
+    def get_secret(self, key: str) -> Optional[SecretValue]:
+        # Check environment first, then cache from file
+        value = os.environ.get(key) or self._cache.get(key)
+        if value:
+            return SecretValue(key=key, value=value, source="env")
+        return None
+
+    def list_secrets(self) -> List[str]:
+        return list(
+            set(
+                list(self._cache.keys())
+                + [
+                    k
+                    for k in os.environ.keys()
+                    if k.startswith("VM_") or k.startswith("CLONEBOX_")
+                ]
+            )
+        )
+
+    def is_available(self) -> bool:
+        return True
+
+
+class VaultSecretsProvider(SecretsProvider):
+    """Load secrets from HashiCorp Vault."""
+
+    def __init__(
+        self,
+        addr: Optional[str] = None,
+        token: Optional[str] = None,
+        path_prefix: str = "secret/clonebox",
+    ):
+        self.addr = addr or os.environ.get("VAULT_ADDR", "http://127.0.0.1:8200")
+        self.token = token or os.environ.get("VAULT_TOKEN")
+        self.path_prefix = path_prefix
+        self._client = None
+
+    def _get_client(self):
+        if self._client is None:
+            try:
+                import hvac
+
+                self._client = hvac.Client(url=self.addr, token=self.token)
+            except ImportError:
+                raise RuntimeError(
+                    "hvac package required for Vault support: pip install hvac"
+                )
+        return self._client
+
+    def get_secret(self, key: str) -> Optional[SecretValue]:
+        try:
+            client = self._get_client()
+            path = f"{self.path_prefix}/{key}"
+            response = client.secrets.kv.v2.read_secret_version(path=path)
+            value = response["data"]["data"].get("value")
+            if value:
+                return SecretValue(key=key, value=value, source="vault")
+        except Exception:
+            pass
+        return None
+
+    def list_secrets(self) -> List[str]:
+        try:
+            client = self._get_client()
+            response = client.secrets.kv.v2.list_secrets(path=self.path_prefix)
+            return response["data"]["keys"]
+        except Exception:
+            return []
+
+    def is_available(self) -> bool:
+        try:
+            client = self._get_client()
+            return client.is_authenticated()
+        except Exception:
+            return False
+
+
+class SOPSSecretsProvider(SecretsProvider):
+    """Load secrets from SOPS-encrypted files."""
+
+    def __init__(self, secrets_file: Optional[Path] = None):
+        self.secrets_file = secrets_file or Path(".clonebox.secrets.yaml")
+        self._cache: Optional[Dict[str, Any]] = None
+
+    def _decrypt(self) -> Dict[str, Any]:
+        if self._cache is not None:
+            return self._cache
+
+        if not self.secrets_file.exists():
+            self._cache = {}
+            return self._cache
+
+        try:
+            result = subprocess.run(
+                ["sops", "-d", str(self.secrets_file)],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            import yaml
+
+            self._cache = yaml.safe_load(result.stdout) or {}
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            self._cache = {}
+
+        return self._cache
+
+    def get_secret(self, key: str) -> Optional[SecretValue]:
+        data = self._decrypt()
+        # Support nested keys: "vm.password" -> data['vm']['password']
+        parts = key.split(".")
+        value = data
+        for part in parts:
+            if isinstance(value, dict) and part in value:
+                value = value[part]
+            else:
+                return None
+
+        if isinstance(value, str):
+            return SecretValue(key=key, value=value, source="sops")
+        return None
+
+    def list_secrets(self) -> List[str]:
+        data = self._decrypt()
+        return list(data.keys())
+
+    def is_available(self) -> bool:
+        try:
+            subprocess.run(["sops", "--version"], capture_output=True, check=True)
+            return self.secrets_file.exists()
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            return False
+
+
+class SecretsManager:
+    """
+    Unified secrets management with multiple provider fallback.
+
+    Usage:
+        secrets = SecretsManager()
+        password = secrets.get('VM_PASSWORD')
+
+        # Or with explicit provider
+        secrets = SecretsManager(provider='vault')
+    """
+
+    PROVIDERS = {
+        "env": EnvSecretsProvider,
+        "vault": VaultSecretsProvider,
+        "sops": SOPSSecretsProvider,
+    }
+
+    def __init__(self, provider: Optional[str] = None, **kwargs):
+        self._providers: List[SecretsProvider] = []
+
+        if provider:
+            # Use specific provider
+            if provider not in self.PROVIDERS:
+                raise ValueError(
+                    f"Unknown provider: {provider}. Available: {list(self.PROVIDERS.keys())}"
+                )
+            self._providers = [self.PROVIDERS[provider](**kwargs)]
+        else:
+            # Auto-detect and use all available providers
+            for name, cls in self.PROVIDERS.items():
+                try:
+                    instance = cls(**kwargs)
+                    if instance.is_available():
+                        self._providers.append(instance)
+                except Exception:
+                    pass
+
+            # Always have env as fallback
+            if not any(isinstance(p, EnvSecretsProvider) for p in self._providers):
+                self._providers.append(EnvSecretsProvider())
+
+    def get(self, key: str, default: Optional[str] = None) -> Optional[str]:
+        """Get a secret value, trying each provider in order."""
+        for provider in self._providers:
+            secret = provider.get_secret(key)
+            if secret:
+                return secret.value
+        return default
+
+    def get_secret(self, key: str) -> Optional[SecretValue]:
+        """Get a SecretValue with metadata."""
+        for provider in self._providers:
+            secret = provider.get_secret(key)
+            if secret:
+                return secret
+        return None
+
+    def require(self, key: str) -> str:
+        """Get a secret or raise an error if not found."""
+        value = self.get(key)
+        if value is None:
+            raise ValueError(f"Required secret '{key}' not found in any provider")
+        return value
+
+    @staticmethod
+    def generate_password(length: int = 24) -> str:
+        """Generate a secure random password."""
+        alphabet = string.ascii_letters + string.digits + "!@#$%^&*"
+        return "".join(secrets.choice(alphabet) for _ in range(length))
+
+    @staticmethod
+    def generate_one_time_password() -> Tuple[str, str]:
+        """
+        Generate a one-time password that expires on first login.
+        Returns (password, cloud-init chpasswd config)
+        """
+        password = SecretsManager.generate_password(16)
+        # Force password change on first login
+        chpasswd_config = f"""
+chpasswd:
+  expire: true
+  users:
+    - name: ubuntu
+      password: {password}
+      type: text
+"""
+        return password, chpasswd_config
+
+
+# SSH Key Management
+@dataclass
+class SSHKeyPair:
+    """SSH key pair for VM authentication."""
+
+    private_key: str
+    public_key: str
+    key_type: str = "ed25519"
+
+    @classmethod
+    def generate(cls, key_type: str = "ed25519") -> "SSHKeyPair":
+        """Generate a new SSH key pair."""
+        import tempfile
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            key_path = Path(tmpdir) / "key"
+            subprocess.run(
+                ["ssh-keygen", "-t", key_type, "-N", "", "-f", str(key_path), "-q"],
+                check=True,
+            )
+
+            private_key = key_path.read_text()
+            public_key = key_path.with_suffix(".pub").read_text()
+
+        return cls(private_key=private_key, public_key=public_key, key_type=key_type)
+
+    @classmethod
+    def from_file(cls, private_key_path: Path) -> "SSHKeyPair":
+        """Load existing SSH key pair."""
+        private_key = private_key_path.read_text()
+        public_key = private_key_path.with_suffix(".pub").read_text()
+        return cls(private_key=private_key, public_key=public_key)
+
+    def save(self, private_key_path: Path) -> None:
+        """Save key pair to files."""
+        private_key_path.write_text(self.private_key)
+        private_key_path.chmod(0o600)
+        private_key_path.with_suffix(".pub").write_text(self.public_key)

clonebox/snapshots/manager.py

@@ -86,9 +86,7 @@ class SnapshotManager:
             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
+                datetime.now() + timedelta(days=expires_in_days) if expires_in_days else None
             ),
         )
 
@@ -114,9 +112,7 @@ class SnapshotManager:
 
         # 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"
-            )
+            raise RuntimeError(f"VM '{vm_name}' is running. Stop it first or use --force")
 
         try:
             snap = domain.snapshotLookupByName(name)
@@ -331,9 +327,7 @@ class SnapshotManager:
         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]]:
+    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():

clonebox/snapshots/models.py

@@ -97,9 +97,7 @@ class Snapshot:
             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
+                datetime.fromisoformat(data["expires_at"]) if data.get("expires_at") else None
             ),
         )
 
@@ -167,9 +165,7 @@ class SnapshotPolicy:
             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"]
-            ),
+            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),

clonebox/validator.py

@@ -826,6 +826,26 @@ class VMValidator:
         self.console.print(table)
         return self.results["smoke"]
 
+    def _check_qga_ready(self) -> bool:
+        """Check if QEMU guest agent is responding."""
+        try:
+            result = subprocess.run(
+                [
+                    "virsh",
+                    "--connect",
+                    self.conn_uri,
+                    "qemu-agent-command",
+                    self.vm_name,
+                    '{"execute":"guest-ping"}',
+                ],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            return result.returncode == 0
+        except Exception:
+            return False
+
     def validate_all(self) -> Dict:
         """Run all validations and return comprehensive results."""
         self.console.print("[bold cyan]🔍 Running Full Validation...[/]")
@@ -850,6 +870,20 @@ class VMValidator:
             self.results["overall"] = "error"
             return self.results
 
+        # Check QEMU Guest Agent
+        if not self._check_qga_ready():
+            self.console.print("[red]❌ QEMU Guest Agent not responding[/]")
+            self.console.print("\n[bold]🔧 Troubleshooting QGA:[/]")
+            self.console.print("  1. The VM might still be booting. Wait 30-60 seconds.")
+            self.console.print("  2. Ensure the agent is installed and running inside the VM:")
+            self.console.print("     [dim]virsh console " + self.vm_name + "[/]")
+            self.console.print("     [dim]sudo systemctl status qemu-guest-agent[/]")
+            self.console.print("  3. If newly created, cloud-init might still be running.")
+            self.console.print("  4. Check VM logs: [dim]clonebox logs " + self.vm_name + "[/]")
+            self.console.print(f"\n[yellow]⚠️  Skipping deep validation as it requires a working Guest Agent.[/]")
+            self.results["overall"] = "qga_not_ready"
+            return self.results
+
         # Run all validations
         self.validate_mounts()
         self.validate_packages()

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clonebox
-Version: 1.1.4
+Version: 1.1.6
 Summary: Clone your workstation environment to an isolated VM with selective apps, paths and services
 Author: CloneBox Team
 License: Apache-2.0
@@ -32,6 +32,8 @@ Requires-Dist: psutil>=5.9.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: cryptography>=42.0.0
+Requires-Dist: structlog>=24.0.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
@@ -114,6 +116,8 @@ CloneBox excels in scenarios where developers need:
 | 🎛️ Profiles System (`ml-dev`, `web-stack`) | ✅ Stable |
 | 🔍 Auto-detection (services, apps, paths) | ✅ Stable |
 | 🔒 P2P Secure Transfer (AES-256) | ✅ **NEW** |
+| 📸 Snapshot Management | ✅ **NEW** |
+| 🏥 Health Check System | ✅ **NEW** |
 | 🧪 95%+ Test Coverage | ✅ |
 
 ### P2P Secure VM Sharing
@@ -141,9 +145,55 @@ clonebox sync-key user@hostB  # Sync encryption key
 clonebox list-remote user@hostB  # List remote VMs
 ```
 
+### Snapshot Management
+
+Save and restore VM states:
+
+```bash
+# Create snapshot before risky operation
+clonebox snapshot create my-vm --name "before-upgrade" --user
+
+# List all snapshots
+clonebox snapshot list my-vm --user
+
+# Restore to previous state
+clonebox snapshot restore my-vm --name "before-upgrade" --user
+
+# Delete old snapshot
+clonebox snapshot delete my-vm --name "before-upgrade" --user
+```
+
+### Health Checks
+
+Configure health probes in `.clonebox.yaml`:
+
+```yaml
+health_checks:
+  - name: nginx
+    type: http
+    url: http://localhost:80/health
+    expected_status: 200
+    
+  - name: postgres
+    type: tcp
+    host: localhost
+    port: 5432
+    
+  - name: redis
+    type: command
+    exec: "redis-cli ping"
+    expected_output: "PONG"
+```
+
+Run health checks:
+
+```bash
+clonebox health my-vm --user
+```
+
 ### Roadmap
 
-- **v1.2.0**: `clonebox exec` command, VM snapshots, snapshot restore
+- **v1.2.0**: Resource limits, progress bars, secrets isolation
 - **v1.3.0**: Multi-VM orchestration, cluster mode
 - **v2.0.0**: Cloud provider support (AWS, GCP, Azure), Windows WSL2 support
 

clonebox-1.1.6.dist-info/RECORD

@@ -0,0 +1,42 @@
+clonebox/__init__.py,sha256=CyfHVVq6KqBr4CNERBpXk_O6Q5B35q03YpdQbokVvvI,408
+clonebox/__main__.py,sha256=Fcoyzwwyz5-eC_sBlQk5a5RbKx8uodQz5sKJ190U0NU,135
+clonebox/cli.py,sha256=uVACDtbGh0bNcZY3p2s5W90aU6NQHzuTnTLelWCOlss,136330
+clonebox/cloner.py,sha256=aH7BwmLgPITHzyHn_n_AKqtEADDm_aUXiRG-nB2rxMQ,90063
+clonebox/container.py,sha256=tiYK1ZB-DhdD6A2FuMA0h_sRNkUI7KfYcJ0tFOcdyeM,6105
+clonebox/dashboard.py,sha256=dMY6odvPq3j6FronhRRsX7aY3qdCwznB-aCWKEmHDNw,5768
+clonebox/detector.py,sha256=vS65cvFNPmUBCX1Y_TMTnSRljw6r1Ae9dlVtACs5XFc,23075
+clonebox/di.py,sha256=feFMXP5ff-7gwrIqgnoCpk1ivaiZA_lv2wcpkCSKiew,5648
+clonebox/exporter.py,sha256=WIzVvmA0z_jjrpyXxvnXoLp9oaW6fKS7k0PGwzx_PIM,5629
+clonebox/importer.py,sha256=Q9Uk1IOA41mgGhU4ynW2k-h9GEoGxRKI3c9wWE4uxcA,7097
+clonebox/logging.py,sha256=jD_WgkHmt_h99EmX82QWK7D0OKWyxqcLwgT4UDQFp2g,3675
+clonebox/models.py,sha256=l9e5U4ZEEcgCTt2c47GpqFwppwVeifoCoNFi57lFGFo,8307
+clonebox/monitor.py,sha256=zlIarNf8w_i34XI8hZGxxrg5PVZK_Yxm6FQnkhLavRI,9181
+clonebox/p2p.py,sha256=6o0JnscKqF9-BftQhW5fF1W6YY1wXshY9LEklNcHGJc,5913
+clonebox/profiles.py,sha256=UP37fX_rhrG_O9ehNFJBUcULPmUtN1A8KsJ6cM44oK0,1986
+clonebox/resource_monitor.py,sha256=lDR9KyPbVtImeeOkOBPPVP-5yCgoL5hsVFPZ_UqsY0w,5286
+clonebox/resources.py,sha256=IkuM4OdSDV4qhyc0eIynwbAHBTv0aVSxxW-gghsnCAs,6815
+clonebox/rollback.py,sha256=hpwO-8Ehe1pW0wHuZvJkC_qxZ6yEo9otCJRhGIUArCo,5711
+clonebox/secrets.py,sha256=QtGMIjhTKq14qQRGy-pX0TU3vKLiZt7CMloAlF2GmzQ,10515
+clonebox/validator.py,sha256=2yQXDaL5bzHmxKkEP0fGJ85HV7Ax3iQl7KzSlBVLZkc,38220
+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
+clonebox/health/__init__.py,sha256=aKJJPQwJLnoCY728QuKUxYx1TZyooGEnyUVOegZ58Ok,422
+clonebox/health/manager.py,sha256=6nn0a8QtxeEuuafDbn5ZBqHQdaJ2qg7yTstyAGPJWP0,9987
+clonebox/health/models.py,sha256=sPumwj8S-88KgzSGw1Kq9bBbPVRd2RR0R87Z8hKJ_28,6001
+clonebox/health/probes.py,sha256=CkiGcayqRRysqaBJst-YpSrvUzMdwsqD4TiQSluLt3Y,11305
+clonebox/interfaces/disk.py,sha256=F7Xzj2dq5UTZ2KGCuThDM8bwTps6chFbquOUmfLREjI,985
+clonebox/interfaces/hypervisor.py,sha256=8ms4kZLA-5Ba1e_n68mCucwP_K9mufbmTBlo7XzURn4,1991
+clonebox/interfaces/network.py,sha256=YPIquxEB7sZHczbpuopcZpffTjWYI6cKmAu3wAEFllk,853
+clonebox/interfaces/process.py,sha256=njvAIZw_TCjw01KpyVQKIDoRvhTwl0FfVGbQ6mxTROk,1024
+clonebox/snapshots/__init__.py,sha256=ndlrIavPAiA8z4Ep3-D_EPhOcjNKYFnP3rIpEKaGdb8,273
+clonebox/snapshots/manager.py,sha256=hGzM8V6ZJPXjTqj47c4Kr8idlE-c1Q3gPUvuw1HvS1A,11393
+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.6.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+clonebox-1.1.6.dist-info/METADATA,sha256=36_PJreaPh-6Ot5Irm6NSdFjzwGkAGZGHBs4TYcB9lQ,48915
+clonebox-1.1.6.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+clonebox-1.1.6.dist-info/entry_points.txt,sha256=FES95Vi3btfViLEEoHdb8nikNxTqzaooi9ehZw9ZfWI,47
+clonebox-1.1.6.dist-info/top_level.txt,sha256=LdMo2cvCrEcRGH2M8JgQNVsCoszLV0xug6kx1JnaRjo,9
+clonebox-1.1.6.dist-info/RECORD,,

clonebox-1.1.4.dist-info/RECORD

@@ -1,27 +0,0 @@
-clonebox/__init__.py,sha256=CyfHVVq6KqBr4CNERBpXk_O6Q5B35q03YpdQbokVvvI,408
-clonebox/__main__.py,sha256=Fcoyzwwyz5-eC_sBlQk5a5RbKx8uodQz5sKJ190U0NU,135
-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
-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.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,,