xenfra-sdk 0.2.6__py3-none-any.whl → 0.2.8__py3-none-any.whl

xenfra_sdk/discovery.py

@@ -0,0 +1,110 @@
+"""
+Xenfra Discovery Engine - Recursive Scanner and Infrastructure Inferrer.
+Follows XENFRA_PROTOCOL.md Stage 2 (The Harness/Discovery).
+"""
+
+import os
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+import re
+
+from xenfra_sdk.manifest import ServiceDefinition, InfrastructureService, XenfraConfig
+from xenfra_sdk.constants import DEFAULT_PORT_RANGE_START
+from xenfra_sdk.railpack_detector import get_railpack_detector
+
+
+class RecursiveScanner:
+    """
+    Scans a directory tree to find microservices and infrastructure dependencies.
+    Uses RailpackDetector for framework identification.
+    """
+
+    def __init__(self, root_path: str):
+        self.root_path = Path(root_path).resolve()
+        self.services: List[ServiceDefinition] = []
+        self.infrastructure: List[InfrastructureService] = []
+        self._port_counter = DEFAULT_PORT_RANGE_START
+        self.detector = get_railpack_detector()
+
+    def scan(self) -> XenfraConfig:
+        """
+        Recursively scans the root path for projects.
+        """
+        for root, dirs, files in os.walk(self.root_path):
+            # Skip hidden directories and virtual envs
+            dirs[:] = [d for d in dirs if not d.startswith(".") and d not in ["venv", "node_modules", "__pycache__"]]
+            
+            root_p = Path(root)
+            
+            # Create manifest for Railpack detection
+            manifest = []
+            for f in files:
+                f_path = root_p / f
+                # Only read content of relevant files to speed up scanning
+                content = ""
+                if f in ["package.json", "requirements.txt", "pyproject.toml", "go.mod", "Cargo.toml", "Gemfile", "composer.json", "pom.xml", "build.gradle"]:
+                    content = f_path.read_text(errors="ignore")
+                
+                manifest.append({
+                    "path": f,
+                    "content": content
+                })
+            
+            # 1. Detect Framework via Railpack Logic
+            result = self.detector.detect_from_manifest(manifest)
+            
+            if result.framework != "unknown":
+                # Sanitize Name
+                rel_path = root_p.relative_to(self.root_path)
+                name = rel_path.name.lower().replace("_", "-").replace(" ", "-")
+                if name == "." or not name:
+                    name = self.root_path.name.lower().replace("_", "-")
+                
+                # Assign Port
+                port = self._port_counter
+                self._port_counter += 1
+                
+                # Register Service
+                service = ServiceDefinition(
+                    name=name,
+                    path=str(rel_path),
+                    port=port,
+                    framework=result.framework,
+                    # Railpack gives us extra details we can optionally use
+                )
+                self.services.append(service)
+                
+                # 2. Infer Infrastructure (Post-Process)
+                # Railpack doesn't explicitly output "needs redis", so we keep our robust heuristic
+                infra_deps = set()
+                
+                # Check known files for db drivers
+                for item in manifest:
+                    content = item.get("content", "").lower()
+                    if not content: continue
+                    
+                    if "redis" in content: infra_deps.add("redis")
+                    if "kafka" in content or "confluent-kafka" in content: infra_deps.add("kafka")
+                    
+                    # Postgres
+                    if any(x in content for x in ["psycopg2", "asyncpg", "pg", "postgres"]):
+                        infra_deps.add("postgres")
+                        
+                    # MongoDB
+                    if any(x in content for x in ["pymongo", "mongoose", "mongodb"]):
+                        infra_deps.add("mongodb")
+
+                # Add infrastructure
+                for inf in infra_deps:
+                    if not any(i.type == inf for i in self.infrastructure):
+                        self.infrastructure.append(InfrastructureService(
+                            name=f"shared-{inf}",
+                            type=inf,
+                            port=6379 if inf == "redis" else 5432 if inf == "postgres" else 27017
+                        ))
+
+        return XenfraConfig(
+            name=self.root_path.name.lower().replace("_", "-"),
+            services=self.services,
+            infrastructure=self.infrastructure
+        )

xenfra_sdk/engine.py

@@ -18,6 +18,7 @@ from sqlmodel import Session, select
 
 # Xenfra modules
 from . import dockerizer, privacy, constants
+from xenfra_sdk.patching import PatchManager
 from .db.models import Project
 from .db.session import get_session
 from .events import EventEmitter, DeploymentPhase, EventStatus
@@ -25,7 +26,7 @@ from .exceptions import DeploymentError
 from .governance import get_polling_interval, get_resource_limits
 from .models.context import DeploymentContext
 from .blueprints.factory import render_blueprint
-# from .devbox import DevboxHarness  # Removed
+from .client import XenfraClient
 
 class InfraEngine:
     """
@@ -58,6 +59,8 @@ class InfraEngine:
             logger=self.context.get("logger"),
             event_callback=self.context.get("event_callback")
         )
+        # Initialize internal client for API access (Intelligence/Sandbox)
+        self.client = XenfraClient(token=self.token)
 
     def _get_connection(self, ip_address: str):
         """Establishes a Fabric connection to the server."""
@@ -492,6 +495,7 @@ class InfraEngine:
         droplet = None
         session = db_session or self.db_session
         framework = kwargs.get("framework")
+        mode = kwargs.get("mode", "monolithic")
         tier = kwargs.get("tier", "FREE")  # Default to FREE tier
         
         # ZEN GAP FIX: Resource Governance - Set tier-based polling interval
@@ -597,7 +601,7 @@ class InfraEngine:
             
             # === 0b. MICROSERVICES DELEGATION ===
             # If services are provided but no pre-generated assets, delegate to Orchestrator
-            if services and not (multi_service_compose or multi_service_caddy):
+            if services and mode != "monolithic" and not (multi_service_compose or multi_service_caddy):
                 logger("\n[bold magenta]MICROSERVICES DETECTED - Delegating to ServiceOrchestrator[/bold magenta]")
                 from .orchestrator import ServiceOrchestrator, load_services_from_xenfra_yaml
                 from .manifest import create_services_from_detected
@@ -738,6 +742,7 @@ class InfraEngine:
                     file_manifest = enhanced_manifest
             
             
+            # Protocol Compliance: Build Type-Safe DeploymentContext
             # Protocol Compliance: Build Type-Safe DeploymentContext
             ctx = DeploymentContext(
                 project_name=name,
@@ -859,20 +864,104 @@ class InfraEngine:
                     }
                 }
 
-            # === ZEN MODE: PRE-MITOSIS (E2B GATE) ===
-            # Replaced by Secure Ralph Loop (server-side Firecracker verification)
-            # Enforce "No Compromise" - Verify before Deploy
-            if verify_local and not dry_run:
-                 logger("\n[bold yellow]🛡️ E2B GATE: Verifying build in Cloud Sandbox...[/bold yellow]")
-                 # Call Intelligence Service to verify
-                 try:
-                     # This presumes we have access to the intelligence client
-                     # For now, we simulate the "No Compromise" check or call via HTTP
-                     # In a real run, we would POST to /intelligence/verify with the assets
-                     pass
-                     logger("   - [Verified] E2B Sandbox check passed.")
-                 except Exception as e:
-                     raise DeploymentError(f"E2B Verification Failed: {e}", stage="Pre-Mitosis")
+            # === ZEN MODE: PRE-MITOSIS (THE RALPH LOOP) ===
+            # Replaces the static E2B gate with an autonomous repair loop
+            if not dry_run:
+                max_retries = 2
+                attempt = 0
+                
+                while attempt <= max_retries:
+                    attempt += 1
+                    logger(f"\n[bold yellow]🛡️ E2B GATE (Attempt {attempt}/{max_retries + 1}): Verifying build...[/bold yellow]")
+                    
+                    try:
+                         # 1. Verify
+                         result = self.client.intelligence.verify(
+                            logs="PRE-DEPLOYMENT AUDIT", 
+                            code_snippets=[{"path": k, "content": v} for k, v in ctx_dict.get("file_manifest", [])]
+                         )
+                         
+                         if result.get("status") == "failed":
+                             raise Exception(f"Sandbox verification failed: {result.get('error')}")
+                             
+                         logger("   - [Verified] E2B Sandbox check passed.")
+                         break # Success! Exit loop.
+                         
+                    except Exception as e:
+                        if attempt > max_retries:
+                            raise DeploymentError(f"E2B Verification Failed after {attempt} attempts: {e}", stage="Pre-Mitosis")
+                        
+                        logger(f"   - [Diagnostics] Verification failed. Asking Ralph for a fix...")
+                        
+                        # 2. Diagnose & Fix
+                        try:
+                            # Diagnose using the error logs/message
+                            diagnosis = self.client.intelligence.diagnose(
+                                logs=str(e),
+                                services=services 
+                            )
+                            
+                            # Check if diagnosis suggested a patch
+                            # Note: DiagnosisResponse model structure assumed based on intelligence.py
+                            if hasattr(diagnosis, "patch") and diagnosis.patch and diagnosis.patch.target_file:
+                                logger(f"   - [Ralph] Found fix: {diagnosis.suggestion}")
+                                logger(f"   - [Patching] Applying fix to {diagnosis.patch.target_file}...")
+                                
+                                # Apply patch to local temp clone or CWD (if CLI mode)
+                                base_dir = Path(temp_repo_path) if temp_repo_path else Path(os.getcwd())
+                                
+                                # Use PatchManager
+                                patcher = PatchManager(base_dir)
+                                filename = getattr(diagnosis.patch, "target_file", None) or diagnosis.patch.file
+                                
+                                if not filename:
+                                     logger("   [red]Patch missing filename. Skipping.[/red]")
+                                     continue
+
+                                # Extract params from Pydantic or Dict
+                                operation = getattr(diagnosis.patch, "operation", "append")
+                                search_content = getattr(diagnosis.patch, "search_content", None)
+                                replacement_content = getattr(diagnosis.patch, "content", None) or diagnosis.patch.value
+                                json_path = getattr(diagnosis.patch, "path", None)
+
+                                if not replacement_content and operation != "create": 
+                                     # create might imply empty file? Usually needs content.
+                                     logger("   [red]Patch missing content. Skipping.[/red]")
+                                     continue
+                                
+                                # Apply
+                                p_result = patcher.apply_patch(
+                                    filename=filename,
+                                    operation=operation,
+                                    content=replacement_content,
+                                    search_content=search_content,
+                                    value=replacement_content, # Pass as value too for json/yaml
+                                    path=json_path
+                                )
+                                
+                                if p_result.success:
+                                     logger(f"   [green]- [Ralph] {p_result.message}[/green]")
+                                else:
+                                     logger(f"   [red]- [Patch Failed] {p_result.message}[/red]")
+
+                                    
+                                # Refresh context manifest for the next verification attempt
+                                for f_entry in ctx_dict.get("file_manifest", []):
+                                     if f_entry["path"] == diagnosis.patch.target_file:
+                                          with open(target_path, "r", encoding="utf-8") as f:
+                                              f_entry["content"] = f.read()
+                                
+                                # Re-render assets with new content
+                                logger("   - [Regenerating] Re-rendering deployment assets...")
+                                rendered_assets = render_blueprint(ctx_dict)
+                                
+                            else:
+                                logger("   - [Ralph] No auto-fix available.")
+                                raise e
+                                
+                        except Exception as diagnosis_error:
+                             logger(f"   - [Ralph] Auto-fix failed: {diagnosis_error}")
+                             raise e
 
             # === 4. DROPLET CREATION STAGE ===
             self.emitter.start_phase(DeploymentPhase.CELL_BIRTH, "Submitting DNA to provider (Creating Droplet)")

xenfra_sdk/models/__init__.py

@@ -144,9 +144,10 @@ class PatchObject(BaseModel):
     file: str | None = Field(
         None, description="The name of the file to be patched (e.g., 'requirements.txt')"
     )
-    operation: str | None = Field(None, description="The patch operation (e.g., 'add', 'replace')")
+    operation: str | None = Field(None, description="The patch operation (e.g., 'add', 'replace', 'replace_block')")
     path: str | None = Field(None, description="A JSON-like path to the field to be changed")
     value: str | None = Field(None, description="The new value to apply")
+    search_content: str | None = Field(None, description="Exact string to search for and replace")
 
 
 class DiagnosisResponse(BaseModel):

xenfra_sdk/patching.py

@@ -0,0 +1,230 @@
+
+import json
+import logging
+import os
+import re
+from pathlib import Path
+from typing import Any, Dict, Optional, Union
+import yaml
+
+# Try importing tomllib (Python 3.11+)
+try:
+    import tomllib
+except ImportError:
+    # Fallback/Mock for older python if needed, but project is >=3.13
+    tomllib = None
+
+from pydantic import BaseModel
+
+logger = logging.getLogger(__name__)
+
+class PatchResult(BaseModel):
+    success: bool
+    message: str
+    diff: Optional[str] = None
+
+class PatchManager:
+    """
+    Handles safe, structured patching of files based on their type.
+    Prevents corruption of JSON/YAML/TOML by using parsers instead of text appending.
+    """
+
+    def __init__(self, base_dir: Path):
+        self.base_dir = base_dir.resolve()
+
+    def apply_patch(self, 
+                    filename: str, 
+                    operation: str, 
+                    content: Optional[str] = None, 
+                    search_content: Optional[str] = None, 
+                    value: Optional[str] = None,
+                    path: Optional[str] = None) -> PatchResult:
+        """
+        Dispatches the patch to the correct strategy based on file extension.
+        """
+        target_path = self.base_dir / filename
+        
+        # Security check: prevent directory traversal
+        try:
+            target_path.resolve().relative_to(self.base_dir)
+        except ValueError:
+            return PatchResult(success=False, message=f"Access denied: {filename} is outside project root.")
+
+        if not target_path.exists() and operation != "create":
+             # If operation is overwrite, we might allow creating
+             if operation == "overwrite":
+                 pass
+             else:
+                 return PatchResult(success=False, message=f"File not found: {filename}")
+
+        # Determine Strategy
+        ext = target_path.suffix.lower()
+        
+        try:
+            if ext == ".json":
+                return self._patch_json(target_path, operation, path, value or content)
+            elif ext in [".yaml", ".yml"]:
+                return self._patch_yaml(target_path, operation, path, value or content)
+            elif ext == ".toml":
+                # TOML Strategy: We lack a writer, so we use Smart Block Replacement but Validate syntax
+                return self._patch_toml_smart(target_path, operation, content, search_content)
+            else:
+                return self._patch_text_smart(target_path, operation, content, search_content)
+        except Exception as e:
+            return PatchResult(success=False, message=f"Patching failed: {str(e)}")
+
+    def _patch_json(self, file_path: Path, operation: str, json_path: Optional[str], value: Any) -> PatchResult:
+        """Safe JSON Manipulation."""
+        try:
+            # Load
+            if file_path.exists():
+                text = file_path.read_text(encoding="utf-8")
+                data = json.loads(text)
+            else:
+                data = {}
+
+            # Parse input value if it looks like JSON/Dict
+            new_val = value
+            if isinstance(value, str):
+                try:
+                    new_val = json.loads(value)
+                except json.JSONDecodeError:
+                    pass # Keep as string
+
+            # Apply
+            if operation == "merge_key" and json_path:
+                # Simple logic for top-level keys for now (e.g. "dependencies")
+                # A full JSONPath impl would be complex.
+                # Supporting "dependencies.requests" -> nested set
+                keys = json_path.split(".")
+                current = data
+                for k in keys[:-1]:
+                    current = current.setdefault(k, {})
+                
+                # Merge logic
+                last_key = keys[-1]
+                if isinstance(current.get(last_key), dict) and isinstance(new_val, dict):
+                    current[last_key].update(new_val)
+                else:
+                    current[last_key] = new_val
+
+            elif operation == "overwrite":
+                 data = new_val
+
+            else:
+                # Default for JSON: "Add/Update root key" if path missing?
+                # Or if operation="replace_block", we can't do that easily in JSON.
+                # Fallback to Text strategy if operation is unknown for JSON?
+                pass
+
+            # Dump
+            with open(file_path, "w", encoding="utf-8") as f:
+                json.dump(data, f, indent=2)
+            
+            return PatchResult(success=True, message=f"Updated JSON {file_path.name}")
+
+        except json.JSONDecodeError:
+            return PatchResult(success=False, message=f"Invalid JSON in file {file_path.name}")
+
+    def _patch_yaml(self, file_path: Path, operation: str, yaml_path: Optional[str], value: Any) -> PatchResult:
+        """Safe YAML Manipulation."""
+        try:
+            if file_path.exists():
+                data = yaml.safe_load(file_path.read_text(encoding="utf-8")) or {}
+            else:
+                data = {}
+
+             # Parse value
+            new_val = value
+            if isinstance(value, str):
+                try: 
+                    new_val = yaml.safe_load(value)
+                except:
+                    pass
+
+            if operation == "merge_key" and yaml_path:
+                keys = yaml_path.split(".")
+                current = data
+                for k in keys[:-1]:
+                    current = current.setdefault(k, {})
+                
+                last_key = keys[-1]
+                if isinstance(current.get(last_key), dict) and isinstance(new_val, dict):
+                    current[last_key].update(new_val)
+                else:
+                    current[last_key] = new_val
+
+            elif operation == "overwrite":
+                data = new_val
+            
+            with open(file_path, "w", encoding="utf-8") as f:
+                yaml.dump(data, f, default_flow_style=False)
+            
+            return PatchResult(success=True, message=f"Updated YAML {file_path.name}")
+
+        except yaml.YAMLError as e:
+            return PatchResult(success=False, message=f"YAML Error: {e}")
+
+    def _patch_toml_smart(self, file_path: Path, operation: str, content: str, search_content: Optional[str]) -> PatchResult:
+        """
+        Smart Text Patching for TOML, but validates the result is valid TOML.
+        """
+        # 1. Apply Text Patch
+        res = self._patch_text_smart(file_path, operation, content, search_content)
+        if not res.success:
+            return res
+
+        # 2. Verify Syntax (Safety Check)
+        if tomllib:
+            try:
+                new_text = file_path.read_text(encoding="utf-8")
+                tomllib.loads(new_text)
+            except tomllib.TOMLDecodeError as e:
+                # Revert!
+                # Note: A real robust implementation needs a backup step.
+                # For now, we warn.
+                return PatchResult(success=False, message=f"Patch applied but resulted in INVALID TOML: {e}. (Recommend Revert)")
+        return res
+
+    def _patch_text_smart(self, file_path: Path, operation: str, content: str, search_content: Optional[str]) -> PatchResult:
+        """
+        Robust Text/Code Patching.
+        Supports:
+        - overwrite: Replaces entire file.
+        - replace_block: Replaces exact block (safe).
+        - replace_fuzzy: (TODO) Normalized whitespace replacement.
+        - append_safe: Appends to end (legacy).
+        """
+        if not content:
+            return PatchResult(success=False, message="No content provided for patch.")
+
+        current_text = ""
+        if file_path.exists():
+            current_text = file_path.read_text(encoding="utf-8")
+
+        if operation == "overwrite":
+            file_path.write_text(content, encoding="utf-8")
+            return PatchResult(success=True, message="File overwritten")
+
+        elif operation == "replace_block":
+            if not search_content:
+                return PatchResult(success=False, message="Missing 'search_content' for block replacement.")
+            
+            if search_content in current_text:
+                new_text = current_text.replace(search_content, content)
+                file_path.write_text(new_text, encoding="utf-8")
+                return PatchResult(success=True, message="Block replaced successfully")
+            else:
+                 # TODO: Try Fuzzy Match here?
+                 return PatchResult(success=False, message="Search block not found exactly in file.")
+
+        elif operation == "append":
+             # Safe Append check: Ensure newline
+             with open(file_path, "a", encoding="utf-8") as f:
+                 if current_text and not current_text.endswith("\n"):
+                     f.write("\n")
+                 f.write(content)
+             return PatchResult(success=True, message="Content appended")
+
+        else:
+             return PatchResult(success=False, message=f"Unknown operation: {operation}")

xenfra_sdk/resources/sandbox.py

@@ -0,0 +1,7 @@
+from .base import BaseManager
+
+class SandboxManager(BaseManager):
+    """
+    Manager for E2B Sandbox operations.
+    """
+    pass

{xenfra_sdk-0.2.6.dist-info → xenfra_sdk-0.2.8.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.3
 Name: xenfra-sdk
-Version: 0.2.6
+Version: 0.2.8
 Summary: Xenfra SDK: Core engine and utilities for the Xenfra platform.
 Author: xenfra-cloud
-Author-email: xenfra-cloud <xenfracloud@gmail.com>
+Author-email: xenfra-cloud <support@xenfra.com>
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent

{xenfra_sdk-0.2.6.dist-info → xenfra_sdk-0.2.8.dist-info}/RECORD

@@ -16,16 +16,18 @@ xenfra_sdk/db/models.py,sha256=nbnlNiFShUo9uxrcVLHUezlNtF_NATS85pPYTKBriIE,714
 xenfra_sdk/db/session.py,sha256=Cryt02u01Lq_olwOji3X9a5pI7lE5p0O0mKX3na9h6M,879
 xenfra_sdk/dependencies.py,sha256=WHGfIrEYkss5yuBd_uOFrB6lPBWM2X0mEuG26ILAjXI,1211
 xenfra_sdk/detection.py,sha256=7DDfwOAfmZYF5tzJAcbUsME8alfsqS0HQgrI4eTfwTA,18913
+xenfra_sdk/discovery.py,sha256=42JawKgOUIY9Al4znpf5n4dL-rXKhAnhOdM3L8yT0VM,4565
 xenfra_sdk/dockerizer.py,sha256=iSn-HZ2-07zgM-C2aQkJH-MBtPrkEimurKLY9hth34Y,5191
-xenfra_sdk/engine.py,sha256=nmrjFKaYsouHvfFThYo4gXTuoCr0Xr2zgFy35XcfIKo,67310
+xenfra_sdk/engine.py,sha256=BueUHy_ofIEERiXTGADXRaWHSfu0XSM_hY1zVHiBrKM,72615
 xenfra_sdk/events.py,sha256=7BgtTc4a-bw6ybicQblQ-Y0CGbUpgR_Cx4YNaJi_SsU,8013
 xenfra_sdk/exceptions.py,sha256=rNUpuk6NXsigqBUNMqzit48DjvZev5Try87zVT8ethE,753
 xenfra_sdk/governance.py,sha256=g9bN174HeoA13Cv-8o6hoVK_dRcrnHOBVRdKkZE9pWY,3784
 xenfra_sdk/manifest.py,sha256=ymAvih83VzKcrMxIpNGnffg0TtxCowiPUgvYx4qks6E,6210
 xenfra_sdk/mcp_client.py,sha256=QTKu-gkm0oeYOyCyXweZgxEXA3DvBLwQxEaNMevBBzw,5869
-xenfra_sdk/models/__init__.py,sha256=Ek5AT--i6oIKUjQJJGNQiLLwkLieMm4w9do4h7XwoGc,8174
+xenfra_sdk/models/__init__.py,sha256=5VGfCk25wNigzgwztluT5I_39acWHesaWVm4Y38IQdg,8290
 xenfra_sdk/models/context.py,sha256=ByQofUAKqDRqJ7HZoiVLXnfuw6X0cWhsuMlUrV9Bix0,2341
 xenfra_sdk/orchestrator.py,sha256=2vd1YCQX6pVsa1wtdhRD4Xo4Nscmxt2_1_sjKw39CGw,34006
+xenfra_sdk/patching.py,sha256=Yb-j9Ua_s_3-uoAbYfAaR9xw-FH_lZwDqhLfxhpEC6M,9005
 xenfra_sdk/patterns.json,sha256=xHxbc0ogHDwysMczi30_hW1Ylfdsf-nsQdAom7RZ4KI,446
 xenfra_sdk/privacy.py,sha256=YpV8roCX2C2oLY_6TMXSDISuzNb192RuUPriwORKzNQ,5800
 xenfra_sdk/protocol.py,sha256=nVamJTzEAKk71v-MUR_5yvkxMkMzR5Crmp9ecbqLVhI,1210
@@ -41,9 +43,10 @@ xenfra_sdk/resources/deployments.py,sha256=VjTUn0TZyGUEvEsgy7TUa4T4VZH_IPr7IV4-s
 xenfra_sdk/resources/files.py,sha256=opdxZt6GWMU-qu5ltfWfv2hm8TscdaK-r9o4k743Irs,3087
 xenfra_sdk/resources/intelligence.py,sha256=oD8DxyLxivvTrD-Xvv1pDJtKsZkiTOOwIMenZAssbzI,4397
 xenfra_sdk/resources/projects.py,sha256=EsCVXmqkhWl_Guz_8WDQDi3kAm1Wyg1rjXcyAigPD6E,3712
+xenfra_sdk/resources/sandbox.py,sha256=4OjMCSVnVTxuMo6765ioBdryS9G_0PhXwQPXyVzJFJI,131
 xenfra_sdk/security.py,sha256=6vMZpbglhkRGBVVj4RCTu45-MCnQ15wt94-996zmaT8,1199
 xenfra_sdk/security_scanner.py,sha256=US9QdMjHdTUkqObrGPHvDPxMP0QXCxmwK5e28d8KT2E,12957
 xenfra_sdk/utils.py,sha256=d8eCjjV32QwqoJa759CEcETnnsjG5qVKDLQ84yYtlus,3898
-xenfra_sdk-0.2.6.dist-info/WHEEL,sha256=5DEXXimM34_d4Gx1AuF9ysMr1_maoEtGKjaILM3s4w4,80
-xenfra_sdk-0.2.6.dist-info/METADATA,sha256=PsSEAuYqDKMuXabOgzvPOY_E80jdsDFjSyw_3JdNIRo,3889
-xenfra_sdk-0.2.6.dist-info/RECORD,,
+xenfra_sdk-0.2.8.dist-info/WHEEL,sha256=iHtWm8nRfs0VRdCYVXocAWFW8ppjHL-uTJkAdZJKOBM,80
+xenfra_sdk-0.2.8.dist-info/METADATA,sha256=RT0ly-geSY8yYW74fuA0cr4c8kRFl2VNvPyjSt27ffU,3886
+xenfra_sdk-0.2.8.dist-info/RECORD,,

{xenfra_sdk-0.2.6.dist-info → xenfra_sdk-0.2.8.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.9.29
+Generator: uv 0.9.30
 Root-Is-Purelib: true
 Tag: py3-none-any