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

xenfra_sdk/resources/build.py

@@ -0,0 +1,157 @@
+"""
+Build resource manager for 3-tier dry-run validation.
+
+Provides methods for:
+- Tier 2: Build plan detection (Railpack)
+- Tier 3: Sandbox validation (E2B via Xenfra API)
+"""
+
+from typing import Dict, List, Optional
+
+
+class BuildManager:
+    """Manager for build operations and dry-run validation."""
+    
+    def __init__(self, client):
+        """
+        Initialize the BuildManager.
+        
+        Args:
+            client: The XenfraClient instance.
+        """
+        self._client = client
+    
+    def detect(self, file_manifest: List[Dict]) -> Dict:
+        """
+        Tier 2: Detect build plan from project files.
+        
+        Runs Railpack detection on the backend to determine
+        framework, language, and build configuration.
+        
+        Args:
+            file_manifest: List of file info dicts with keys: path, sha, size
+            
+        Returns:
+            Dict with build plan:
+                - framework: str (fastapi, flask, nextjs, etc.)
+                - language: str (python, node, go, rust)
+                - package_manager: str (pip, npm, go mod, etc.)
+                - dependency_file: str (requirements.txt, package.json)
+                - port: int
+                - build_command: Optional[str]
+                - start_command: Optional[str]
+                - dockerfile: Optional[str] (generated if applicable)
+        """
+        payload = {"files": file_manifest}
+        
+        response = self._client._request("POST", "/build/detect", json=payload)
+        return response.json()
+    
+    def validate(
+        self,
+        file_manifest: List[Dict],
+        build_plan: Dict,
+        timeout: int = 300
+    ) -> Dict:
+        """
+        Tier 3: Validate build in E2B sandbox.
+        
+        Runs full build validation in an isolated sandbox environment.
+        This ensures the project actually builds and runs before deployment.
+        
+        Args:
+            file_manifest: List of file info dicts with keys: path, sha, size
+            build_plan: Build plan dict from detect()
+            timeout: Maximum time to wait for validation (seconds)
+            
+        Returns:
+            Dict with validation result:
+                - success: bool
+                - output: str (build output logs)
+                - error: Optional[str] (error message if failed)
+                - build_time: float (seconds)
+                - verification_proof: str (SHA256 hash for compliance)
+        """
+        payload = {
+            "files": file_manifest,
+            "build_plan": build_plan,
+            "timeout": timeout
+        }
+        
+        response = self._client._request("POST", "/build/validate", json=payload)
+        return response.json()
+    
+    def validate_stream(
+        self,
+        file_manifest: List[Dict],
+        build_plan: Dict,
+        timeout: int = 300
+    ):
+        """
+        Tier 3: Validate build with streaming logs.
+        
+        Same as validate() but yields log lines in real-time.
+        
+        Args:
+            file_manifest: List of file info dicts
+            build_plan: Build plan dict from detect()
+            timeout: Maximum time to wait
+            
+        Yields:
+            Dict with:
+                - type: "log" | "complete" | "error"
+                - data: str (log line) or dict (result)
+        """
+        payload = {
+            "files": file_manifest,
+            "build_plan": build_plan,
+            "timeout": timeout,
+            "stream": True
+        }
+        
+        with self._client._request(
+            "POST",
+            "/build/validate",
+            json=payload,
+            stream=True
+        ) as response:
+            for line in response.iter_lines():
+                if line:
+                    import json
+                    yield json.loads(line)
+    
+    def dry_run(
+        self,
+        file_manifest: List[Dict],
+        skip_sandbox: bool = False,
+        force_sandbox: bool = False
+    ) -> Dict:
+        """
+        Run full 3-tier dry-run validation.
+        
+        This is a convenience method that runs all three tiers:
+        - Tier 1: Local validation (client-side)
+        - Tier 2: Build detection (API call)
+        - Tier 3: Sandbox validation (API call, if needed)
+        
+        Args:
+            file_manifest: List of file info dicts
+            skip_sandbox: Skip Tier 3 validation
+            force_sandbox: Force Tier 3 even if not needed
+            
+        Returns:
+            Dict with full validation results:
+                - tier1: Dict (local validation result)
+                - tier2: Dict (build plan)
+                - tier3: Optional[Dict] (sandbox result)
+                - tier3_ran: bool
+                - success: bool
+        """
+        payload = {
+            "files": file_manifest,
+            "skip_sandbox": skip_sandbox,
+            "force_sandbox": force_sandbox
+        }
+        
+        response = self._client._request("POST", "/build/dry-run", json=payload)
+        return response.json()

xenfra_sdk/resources/deployments.py

@@ -12,7 +12,7 @@ logger = logging.getLogger(__name__)
 
 
 class DeploymentsManager(BaseManager):
-    def create(self, project_name: str, git_repo: str, branch: str, framework: str, region: str = None, size_slug: str = None, is_dockerized: bool = True, port: int = None, command: str = None, entrypoint: str = None, database: str = None, package_manager: str = None, dependency_file: str = None, file_manifest: list = None, cleanup_on_failure: bool = False, services: list = None, mode: str = None) -> dict:
+    def create(self, project_name: str, git_repo: str, branch: str, framework: str, region: str = None, size_slug: str = None, is_dockerized: bool = True, port: int = None, command: str = None, entrypoint: str = None, database: str = None, package_manager: str = None, dependency_file: str = None, file_manifest: list = None, cleanup_on_failure: bool = False, services: list = None, mode: str = None, verify_local: bool = True) -> dict:
         """Creates a new deployment."""
         try:
             payload = {
@@ -48,6 +48,8 @@ class DeploymentsManager(BaseManager):
                 payload["services"] = services
             if mode:
                 payload["mode"] = mode
+            if verify_local is not None:
+                payload["verify_local"] = verify_local
             
             response = self._client._request("POST", "/deployments", json=payload)
             # Safe JSON parsing
@@ -118,7 +120,7 @@ class DeploymentsManager(BaseManager):
         except Exception as e:
             raise XenfraError(f"Failed to get logs for deployment {deployment_id}: {e}")
 
-    def create_stream(self, project_name: str, git_repo: str, branch: str, framework: str, region: str = None, size_slug: str = None, is_dockerized: bool = True, port: int = None, command: str = None, entrypoint: str = None, database: str = None, package_manager: str = None, dependency_file: str = None, file_manifest: list = None, cleanup_on_failure: bool = False, services: list = None, mode: str = None) -> Iterator[dict]:
+    def create_stream(self, project_name: str, git_repo: str, branch: str, framework: str, region: str = None, size_slug: str = None, is_dockerized: bool = True, port: int = None, command: str = None, entrypoint: str = None, database: str = None, package_manager: str = None, dependency_file: str = None, file_manifest: list = None, cleanup_on_failure: bool = False, services: list = None, mode: str = None, verify_local: bool = True) -> Iterator[dict]:
         """
         Creates a new deployment with real-time SSE log streaming.
 
@@ -186,6 +188,8 @@ class DeploymentsManager(BaseManager):
             payload["services"] = services
         if mode:
             payload["mode"] = mode
+        if verify_local is not None:
+            payload["verify_local"] = verify_local
 
         try:
             # Use httpx to stream the SSE response
@@ -276,3 +280,19 @@ class DeploymentsManager(BaseManager):
             raise XenfraError(f"HTTP error during streaming deployment: {e}")
         except Exception as e:
             raise XenfraError(f"Failed to create streaming deployment: {e}")
+
+    def list(self) -> list[dict]:
+        """
+        Retrieves a list of all deployments for the current user.
+        """
+        try:
+            response = self._client._request("GET", "/deployments/list")
+            logger.debug(
+                f"DeploymentsManager.list response: status={response.status_code}"
+            )
+            # Safe JSON parsing
+            return safe_json_parse(response)
+        except XenfraAPIError:
+            raise
+        except Exception as e:
+            raise XenfraError(f"Failed to list deployments: {e}")

xenfra_sdk/resources/intelligence.py

@@ -69,6 +69,31 @@ class IntelligenceManager(BaseManager):
         except Exception as e:
             raise XenfraError(f"Failed to diagnose logs: {e}")
 
+    def verify(
+        self,
+        logs: str,
+        code_snippets: list[dict[str, str]] | None = None,
+    ) -> dict:
+        """
+        Trigger the Secure Ralph Loop to verify and fix a failure.
+        
+        Args:
+            logs: The deployment logs to analyze
+            code_snippets: Optional list of [{"path": "...", "content": "..."}] for context
+            
+        Returns:
+            Dictionary with status and final_fix if found
+        """
+        try:
+            payload = {"logs": logs}
+            if code_snippets:
+                payload["code_snippets"] = code_snippets
+
+            response = self._client._request("POST", "/intelligence/verify", json=payload)
+            return safe_json_parse(response)
+        except Exception as e:
+            raise XenfraError(f"Verification gate failure: {e}")
+
     def analyze_codebase(self, code_snippets: dict[str, str]) -> CodebaseAnalysisResponse:
         """
         Analyze codebase to detect framework, dependencies, and deployment config.

xenfra_sdk-0.2.6.dist-info/METADATA

@@ -0,0 +1,118 @@
+Metadata-Version: 2.3
+Name: xenfra-sdk
+Version: 0.2.6
+Summary: Xenfra SDK: Core engine and utilities for the Xenfra platform.
+Author: xenfra-cloud
+Author-email: xenfra-cloud <xenfracloud@gmail.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: System :: Systems Administration
+Requires-Dist: fabric>=3.2.2
+Requires-Dist: python-digitalocean>=1.17.0
+Requires-Dist: python-dotenv>=1.2.1
+Requires-Dist: rich>=14.2.0
+Requires-Dist: sqlmodel>=0.0.16
+Requires-Dist: pyyaml>=6.0.1
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: jinja2>=3.1.3
+Requires-Dist: python-jose[cryptography]>=3.3.0
+Requires-Dist: passlib>=1.7.4
+Requires-Dist: cryptography>=41.0.0
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+
+# Xenfra Python SDK
+
+The official, open-source Python SDK for interacting with the Xenfra API.
+
+This SDK provides a simple and Pythonic interface for developers and AI Agents to programmatically manage infrastructure, deployments, and other platform resources.
+
+## Installation
+
+```bash
+pip install xenfra-sdk
+```
+
+## Basic Usage
+
+Initialize the client with your API token (or ensure the `XENFRA_TOKEN` environment variable is set).
+
+```python
+import os
+from xenfra_sdk import XenfraClient
+from xenfra_sdk.exceptions import XenfraAPIError
+
+client = XenfraClient(token=os.getenv("XENFRA_TOKEN"))
+
+try:
+    projects = client.projects.list()
+    for p in projects:
+        print(f"Found project: {p.name} (Status: {p.status})")
+except XenfraAPIError as e:
+    print(f"API Error: {e.detail}")
+```
+
+## Usage for Agentic Workflows
+
+The Xenfra SDK is designed to be used as a "tool" by AI Agents (e.g., OpenAI Assistants). The Pydantic models are compatible with function-calling schemas, allowing an agent to easily call these methods.
+
+Here is a conceptual example of how an agent might use the SDK to fulfill a user's request.
+
+```python
+# This is a conceptual representation of an agent's internal logic.
+# The agent would be configured with functions that call these SDK methods.
+
+def list_all_projects():
+    """Lists all available projects in the Xenfra account."""
+    return client.projects.list()
+
+def create_new_deployment(project_name: str, git_repo: str, branch: str = "main"):
+    """
+    Creates a new deployment for a project.
+    
+    Args:
+        project_name: The name for the new deployment.
+        git_repo: The URL of the git repository to deploy.
+        branch: The branch to deploy (defaults to 'main').
+    """
+    return client.deployments.create(
+        project_name=project_name,
+        git_repo=git_repo,
+        branch=branch,
+        framework="fastapi" # Framework detection would be part of a more complex agent
+    )
+
+# --- Agent Execution Flow ---
+
+# User prompt: "Deploy my new app from github.com/user/my-app"
+
+# 1. Agent decides which tool to use: `create_new_deployment`
+# 2. Agent extracts parameters:
+#    - project_name = "my-app" (inferred)
+#    - git_repo = "https://github.com/user/my-app"
+# 3. Agent calls the tool:
+#    create_new_deployment(
+#        project_name="my-app",
+#        git_repo="https://github.com/user/my-app"
+#    )
+```
+
+## Error Handling
+
+The SDK uses custom exceptions for clear error handling. All API-related errors will raise a `XenfraAPIError`, which contains the `status_code` and a `detail` message from the API response.
+
+```python
+from xenfra_sdk.exceptions import XenfraAPIError, AuthenticationError
+
+try:
+    # Make an API call
+    ...
+except AuthenticationError as e:
+    print("Authentication failed. Please check your token.")
+except XenfraAPIError as e:
+    print(f"An API error occurred with status {e.status_code}: {e.detail}")
+```

xenfra_sdk-0.2.6.dist-info/RECORD

@@ -0,0 +1,49 @@
+xenfra_sdk/__init__.py,sha256=GGdls_QuRYtRlI3O2p0gGjfA93C4X7NpjvSEdhPIDas,2451
+xenfra_sdk/blueprints/base.py,sha256=AChTct80KC6LoYwsY6DcGLIWbTY14VDaNVtOmpjr_Zs,5742
+xenfra_sdk/blueprints/factory.py,sha256=BGyl9DUoHuB8Y5dU_syAg9a6kwWyzYHDdd7rKi6EHo8,4197
+xenfra_sdk/blueprints/node.py,sha256=kS2AxeET_-qokJmCR_lvCn3gu0dI3ck7ymdC6HOZHlY,8108
+xenfra_sdk/blueprints/python.py,sha256=9HrNXhQkRqEa_BlsMlm8cf3qP4-4DCNtaqHKWGsYIFo,2416
+xenfra_sdk/blueprints/railpack.py,sha256=JfIfkWEw4U5Yid4BNCFELGZm82jfCyTjaL8hcSn6T0I,3518
+xenfra_sdk/blueprints/schema.py,sha256=DuJlCTaGNIRA789_V8r98TbMU4cq53FY89QrSdcA4Fs,3154
+xenfra_sdk/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xenfra_sdk/cli/main.py,sha256=UqYz1Ai9aVc8goqtjUtMtffeENPvjH_KAj_q_nHBuRI,13690
+xenfra_sdk/client.py,sha256=9QqFXwtrk4cpIQLQ6IIshAG3LM4LFQMgV-T6Ub3aIy0,3890
+xenfra_sdk/client_with_hooks.py,sha256=iN-xTGdeSPizktM6UG-aZEsuwQc5OgosNYUf1_Tq4Dc,10046
+xenfra_sdk/config.py,sha256=gaT4k5iJgW9guNVmlnYkCFGDSU1_er4LRZA2CgfKmJ0,588
+xenfra_sdk/constants.py,sha256=NFZXuZUl-ANMYfBfKnDpPJOJtRHbDo-VDN0k0MKNjfs,873
+xenfra_sdk/db/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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/dockerizer.py,sha256=iSn-HZ2-07zgM-C2aQkJH-MBtPrkEimurKLY9hth34Y,5191
+xenfra_sdk/engine.py,sha256=nmrjFKaYsouHvfFThYo4gXTuoCr0Xr2zgFy35XcfIKo,67310
+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/context.py,sha256=ByQofUAKqDRqJ7HZoiVLXnfuw6X0cWhsuMlUrV9Bix0,2341
+xenfra_sdk/orchestrator.py,sha256=2vd1YCQX6pVsa1wtdhRD4Xo4Nscmxt2_1_sjKw39CGw,34006
+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
+xenfra_sdk/railpack_adapter.py,sha256=whS5KmFioLOkciRNst6L76tccuDPRIIEpZ-saeC0q-Y,14799
+xenfra_sdk/railpack_detector.py,sha256=Z8lMuwDpvne1VviKHdLu0VgLCNJ45bFXk4w1-tYRD6c,21540
+xenfra_sdk/railpack_manager.py,sha256=PVVwAxVaQtiMRAafCx4s3sEqMdSgRUuYe2gUm-x21VI,11335
+xenfra_sdk/recipes.py,sha256=RA1R8fUb5ZiEStcO8451P8fiQ4zaKZWO_ianTl1X1Zk,6608
+xenfra_sdk/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xenfra_sdk/resources/activity.py,sha256=Xpopc6bcJMyae6Bcq813GxiA4laVUF-gHDPq-F4acHE,1709
+xenfra_sdk/resources/base.py,sha256=5n-HTKAnIX2lTgXwio0xtwoaBn-nksjdm8qRTpe3iDk,81
+xenfra_sdk/resources/build.py,sha256=s7_VHeMIWrn1JhDQAeTq1kLeB0gFagHm9JVroTHpUqM,5024
+xenfra_sdk/resources/deployments.py,sha256=VjTUn0TZyGUEvEsgy7TUa4T4VZH_IPr7IV4-seDfg6w,12736
+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/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.5.dist-info → xenfra_sdk-0.2.6.dist-info}/WHEEL

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

xenfra_sdk/templates/Caddyfile.j2

@@ -1,14 +0,0 @@
-# Caddyfile template for multi-service routing
-# Generated by Xenfra for microservices deployments
-
-:80 {
-{% for service in services %}
-    route /{{ service.name }}* {
-        reverse_proxy localhost:{{ service.port }}
-    }
-{% endfor %}
-
-    route / {
-        respond "Xenfra Gateway - {{ project_name }}" 200
-    }
-}

xenfra_sdk/templates/Dockerfile.j2

@@ -1,41 +0,0 @@
-# Dockerfile template for Python web applications
-FROM {{ python_version | default('python:3.11-slim') }}
-
-WORKDIR /app
-
-{% if package_manager != 'pip' %}
-# Install uv package manager and add to PATH
-RUN apt-get update && apt-get install -y curl && \
-    curl -LsSf https://astral.sh/uv/install.sh | sh && \
-    apt-get remove -y curl && \
-    apt-get clean && \
-    rm -rf /var/lib/apt/lists/*
-ENV PATH="/root/.local/bin:/root/.cargo/bin:$PATH"
-{% endif %}
-
-{% if dependency_file == 'pyproject.toml' %}
-# For pyproject.toml, copy all files first (hatchling needs README.md etc.)
-COPY . .
-
-# Install dependencies
-RUN uv pip install --system --no-cache .
-{% else %}
-COPY {{ dependency_file | default('requirements.txt') }} .
-
-# Install dependencies
-{% if package_manager == 'pip' %}
-RUN pip install --no-cache-dir -r {{ dependency_file | default('requirements.txt') }}
-{% endif %}
-
-{% if missing_deps %}
-# Auto-heal missing dependencies (Zen Mode)
-RUN pip install --no-cache-dir {{ missing_deps | join(' ') }}
-{% endif %}
-
-COPY . .
-{% endif %}
-
-# Expose the application port
-EXPOSE {{ port | default(8000) }}
-
-# The command to run the application will be in docker-compose.yml

xenfra_sdk/templates/cloud-init.sh.j2

@@ -1,90 +0,0 @@
-#!/bin/bash
-export DEBIAN_FRONTEND=noninteractive
-LOG="/root/setup.log"
-touch $LOG
-
-echo "--------------------------------" >> $LOG
-echo "🧘 XENFRA: Context-Aware Boot" >> $LOG
-echo "--------------------------------" >> $LOG
-
-# Create App Directory
-mkdir -p /root/app
-cd /root/app
-
-# --- MERCILESS FIX: TERMINATE BACKGROUND PROCESSES ---
-echo "⚔️  [0/6] Mercilessly Terminating Background Processes..." >> $LOG
-
-kill_apt_processes() {
-  echo "🎯 Killing processes holding apt/dpkg locks..." >> $LOG
-  fuser -k /var/lib/dpkg/lock >/dev/null 2>&1
-  fuser -k /var/lib/apt/lists/lock >/dev/null 2>&1
-  fuser -k /var/lib/dpkg/lock-frontends >/dev/null 2>&1
-}
-
-# Explicitly stop and disable services that cause locks
-systemctl stop unattended-upgrades.service || true
-systemctl disable unattended-upgrades.service || true
-systemctl stop apt-daily.service || true
-systemctl disable apt-daily.service || true
-systemctl stop apt-daily-upgrade.service || true
-systemctl disable apt-daily-upgrade.service || true
-
-# Forcefully kill any remaining lock holders
-kill_apt_processes
-
-# Force remove locks if they still exist (The Nuclear Option)
-rm -f /var/lib/dpkg/lock*
-rm -f /var/lib/apt/lists/lock*
-rm -f /var/cache/apt/archives/lock
-dpkg --configure -a || true
-# -----------------------------------------------
-
-# 1. System Updates
-echo "🔄 [1/5] Refreshing Package Lists..." >> $LOG
-apt-get update
-apt-get install -y python3-pip git curl
-
-# 2. Setup Environment
-{% if is_dockerized %}
-echo "🐳 [2/5] Installing Docker..." >> $LOG
-apt-get install -y docker.io || (curl -fsSL https://get.docker.com | sh)
-echo "🎶 [3/5] Installing Docker Compose..." >> $LOG
-apt-get install -y docker-compose-v2
-{% else %}
-echo "🐍 [2/5] Setting up host-based Python environment..." >> $LOG
-apt-get install -y python3-venv python3-dev build-essential
-{% endif %}
-
-# 3. Setup Reverse Proxy
-{% if is_dockerized or install_caddy %}
-echo "📦 [3/5] Installing Caddy..." >> $LOG
-apt-get install -y debian-keyring debian-archive-keyring apt-transport-https
-curl -LsSf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
-curl -LsSf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | tee /etc/apt/sources.list.d/caddy-stable.list
-apt-get update
-apt-get install -y caddy
-{% else %}
-echo "🛡️ [3/5] Skipping Caddy for host deployment (setup manual reverse proxy if needed)." >> $LOG
-{% endif %}
-
-{% if domain %}
-# Dynamically generate Caddyfile content
-echo "🔒 Writing Caddyfile for {{ domain }}..." >> $LOG
-cat << EOF > /etc/caddy/Caddyfile
-{{ domain }}:80, {{ domain }}:443 {
-    reverse_proxy localhost:{{ port | default(8000) }}
-    tls {{ email }}
-}
-EOF
-{% endif %}
-
-{% if domain %}
-echo "🚀 [5/5] Starting Caddy..." >> $LOG
-systemctl restart caddy
-{% else %}
-echo "✅ [5/5] Skipping Caddy start (no domain specified)." >> $LOG
-{% endif %}
-
-# Finish
-echo "✅ SETUP SCRIPT COMPLETE" >> $LOG
-touch /root/setup_complete

xenfra_sdk/templates/docker-compose-multi.yml.j2

@@ -1,29 +0,0 @@
-# docker-compose.yml template for multi-service deployments
-# Generated by Xenfra for microservices
-
-services:
-{% for service in services %}
-  {{ service.name }}:
-    build: {{ service.path }}
-    ports:
-      - "{{ service.port }}:{{ service.port }}"
-{% if service.command %}
-    command: {{ service.command }}
-{% elif service.entrypoint %}
-{% if service.framework == 'fastapi' %}
-    command: uvicorn {{ service.entrypoint }} --host 0.0.0.0 --port {{ service.port }}
-{% elif service.framework == 'flask' %}
-    command: gunicorn {{ service.entrypoint }} -b 0.0.0.0:{{ service.port }}
-{% elif service.framework == 'django' %}
-    command: gunicorn {{ service.entrypoint }} --bind 0.0.0.0:{{ service.port }}
-{% endif %}
-{% endif %}
-{% if service.env %}
-    environment:
-{% for key, value in service.env.items() %}
-      - {{ key }}={{ value }}
-{% endfor %}
-{% endif %}
-    restart: unless-stopped
-
-{% endfor %}

xenfra_sdk/templates/docker-compose.yml.j2

@@ -1,30 +0,0 @@
-# docker-compose.yml template
-
-services:
-  app:
-    build: .
-    ports:
-      - "{{ port | default(8000) }}:{{ port | default(8000) }}"
-{% if command and command != 'None' %}
-    command: {{ command }}
-{% else %}
-    command: ["uvicorn", "{{ entrypoint | default('src.main:app') }}", "--host", "0.0.0.0", "--port", "{{ port | default(8000) }}"]
-{% endif %}
-{% if database == 'postgres' or database == 'postgresql' %}
-    depends_on:
-      - db
-    environment:
-      - DATABASE_URL=postgresql://{{ db_user | default('user') }}:{{ db_password | default('password') }}@db:5432/{{ db_name | default('appdb') }}
-
-  db:
-    image: postgres:15-alpine
-    volumes:
-      - postgres_data:/var/lib/postgresql/data/
-    environment:
-      - POSTGRES_USER={{ db_user | default('user') }}
-      - POSTGRES_PASSWORD={{ db_password | default('password') }}
-      - POSTGRES_DB={{ db_name | default('appdb') }}
-
-volumes:
-  postgres_data:
-{% endif %}