xenfra-sdk 0.2.1__tar.gz → 0.2.2__tar.gz

{xenfra_sdk-0.2.1 → xenfra_sdk-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: xenfra-sdk
-Version: 0.2.1
+Version: 0.2.2
 Summary: Xenfra SDK: Core engine and utilities for the Xenfra platform.
 Author: xenfra-cloud
 Author-email: xenfra-cloud <xenfracloud@gmail.com>

{xenfra_sdk-0.2.1 → xenfra_sdk-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "xenfra-sdk"
-version = "0.2.1"
+version = "0.2.2"
 description = "Xenfra SDK: Core engine and utilities for the Xenfra platform."
 readme = "README.md"
 authors = [

{xenfra_sdk-0.2.1 → xenfra_sdk-0.2.2}/src/xenfra_sdk/client.py

@@ -1,87 +1,90 @@
-import os
-
-import httpx
-
-from .exceptions import AuthenticationError, XenfraAPIError, XenfraError
-from .resources.deployments import DeploymentsManager
-from .resources.intelligence import IntelligenceManager
-from .resources.projects import ProjectsManager
-
-
-class XenfraClient:
-    def __init__(self, token: str = None, api_url: str = None):
-        # Use provided URL, or fall back to env var, or default to production
-        if api_url is None:
-            api_url = os.getenv("XENFRA_API_URL", "https://api.xenfra.tech")
-
-        self.api_url = api_url
-        self._token = token or os.getenv("XENFRA_TOKEN")
-        if not self._token:
-            raise AuthenticationError(
-                "No API token provided. Pass it to the client or set XENFRA_TOKEN."
-            )
-
-        self._http_client = httpx.Client(
-            base_url=self.api_url,
-            headers={"Authorization": f"Bearer {self._token}", "Content-Type": "application/json"},
-            timeout=30.0,  # Add a reasonable timeout
-        )
-
-        # Track if client is closed
-        self._closed = False
-
-        # Initialize resource managers
-        self.projects = ProjectsManager(self)
-        self.deployments = DeploymentsManager(self)
-        self.intelligence = IntelligenceManager(self)
-
-    def _request(self, method: str, path: str, json: dict = None) -> httpx.Response:
-        """Internal method to handle all HTTP requests."""
-        if self._closed:
-            raise XenfraError("Client is closed. Create a new client or use context manager.")
-
-        try:
-            response = self._http_client.request(method, path, json=json)
-            response.raise_for_status()  # Raise HTTPStatusError for 4xx/5xx
-            return response
-        except httpx.HTTPStatusError as e:
-            # Convert httpx error to our custom SDK error
-            # Safe JSON parsing with fallback
-            try:
-                content_type = e.response.headers.get("content-type", "")
-                if "application/json" in content_type:
-                    try:
-                        error_data = e.response.json()
-                        detail = error_data.get(
-                            "detail", e.response.text[:500] if e.response.text else "Unknown error"
-                        )
-                    except (ValueError, TypeError):
-                        detail = e.response.text[:500] if e.response.text else "Unknown error"
-                else:
-                    detail = e.response.text[:500] if e.response.text else "Unknown error"
-            except Exception:
-                detail = "Unknown error"
-            raise XenfraAPIError(status_code=e.response.status_code, detail=detail) from e
-        except httpx.RequestError as e:
-            # Handle connection errors, timeouts, etc.
-            raise XenfraError(f"HTTP request failed: {e}")
-
-    def close(self):
-        """Close the HTTP client and cleanup resources."""
-        if not self._closed:
-            self._http_client.close()
-            self._closed = True
-
-    def __enter__(self):
-        """Context manager entry - allows 'with XenfraClient() as client:' usage."""
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        """Context manager exit - ensures cleanup."""
-        self.close()
-        return False  # Don't suppress exceptions
-
-    def __del__(self):
-        """Destructor - cleanup if not already closed."""
-        if hasattr(self, "_closed") and not self._closed:
-            self.close()
+import os
+
+import httpx
+
+from .exceptions import AuthenticationError, XenfraAPIError, XenfraError
+from .resources.deployments import DeploymentsManager
+from .resources.files import FilesManager
+from .resources.intelligence import IntelligenceManager
+from .resources.projects import ProjectsManager
+
+
+class XenfraClient:
+    def __init__(self, token: str = None, api_url: str = None):
+        # Use provided URL, or fall back to env var, or default to production
+        if api_url is None:
+            api_url = os.getenv("XENFRA_API_URL", "https://api.xenfra.tech")
+
+        self.api_url = api_url
+        self._token = token or os.getenv("XENFRA_TOKEN")
+        if not self._token:
+            raise AuthenticationError(
+                "No API token provided. Pass it to the client or set XENFRA_TOKEN."
+            )
+
+        self._http_client = httpx.Client(
+            base_url=self.api_url,
+            headers={"Authorization": f"Bearer {self._token}", "Content-Type": "application/json"},
+            timeout=30.0,  # Add a reasonable timeout
+        )
+
+        # Track if client is closed
+        self._closed = False
+
+        # Initialize resource managers
+        self.projects = ProjectsManager(self)
+        self.deployments = DeploymentsManager(self)
+        self.intelligence = IntelligenceManager(self)
+        self.files = FilesManager(self)
+
+
+    def _request(self, method: str, path: str, json: dict = None) -> httpx.Response:
+        """Internal method to handle all HTTP requests."""
+        if self._closed:
+            raise XenfraError("Client is closed. Create a new client or use context manager.")
+
+        try:
+            response = self._http_client.request(method, path, json=json)
+            response.raise_for_status()  # Raise HTTPStatusError for 4xx/5xx
+            return response
+        except httpx.HTTPStatusError as e:
+            # Convert httpx error to our custom SDK error
+            # Safe JSON parsing with fallback
+            try:
+                content_type = e.response.headers.get("content-type", "")
+                if "application/json" in content_type:
+                    try:
+                        error_data = e.response.json()
+                        detail = error_data.get(
+                            "detail", e.response.text[:500] if e.response.text else "Unknown error"
+                        )
+                    except (ValueError, TypeError):
+                        detail = e.response.text[:500] if e.response.text else "Unknown error"
+                else:
+                    detail = e.response.text[:500] if e.response.text else "Unknown error"
+            except Exception:
+                detail = "Unknown error"
+            raise XenfraAPIError(status_code=e.response.status_code, detail=detail) from e
+        except httpx.RequestError as e:
+            # Handle connection errors, timeouts, etc.
+            raise XenfraError(f"HTTP request failed: {e}")
+
+    def close(self):
+        """Close the HTTP client and cleanup resources."""
+        if not self._closed:
+            self._http_client.close()
+            self._closed = True
+
+    def __enter__(self):
+        """Context manager entry - allows 'with XenfraClient() as client:' usage."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit - ensures cleanup."""
+        self.close()
+        return False  # Don't suppress exceptions
+
+    def __del__(self):
+        """Destructor - cleanup if not already closed."""
+        if hasattr(self, "_closed") and not self._closed:
+            self.close()

xenfra_sdk-0.2.2/src/xenfra_sdk/dockerizer.py

@@ -0,0 +1,194 @@
+"""
+Xenfra Dockerizer - Generates deployment assets as strings.
+
+This module renders Dockerfile and docker-compose.yml templates
+to strings (in-memory) so they can be written to the target droplet via SSH.
+"""
+
+from pathlib import Path
+from typing import Dict, Optional
+import re
+
+from jinja2 import Environment, FileSystemLoader
+
+
+def detect_python_version(file_manifest: list = None) -> str:
+    """
+    Detect Python version from project files.
+    
+    Checks in order:
+    1. .python-version file (e.g., "3.13")
+    2. pyproject.toml requires-python field (e.g., ">=3.13")
+    
+    Args:
+        file_manifest: List of file info dicts with 'path' and optionally 'content'
+                       If None, uses 3.11 as default.
+    
+    Returns:
+        Docker image version string (e.g., "python:3.13-slim")
+    """
+    default_version = "python:3.11-slim"
+    
+    if not file_manifest:
+        return default_version
+    
+    # Build a lookup dict for quick access
+    file_lookup = {f.get('path', ''): f for f in file_manifest}
+    
+    # Option 1: Check .python-version file
+    if '.python-version' in file_lookup:
+        file_info = file_lookup['.python-version']
+        content = file_info.get('content', '')
+        if content:
+            # Parse version like "3.13" or "3.13.1"
+            version = content.strip().split('\n')[0].strip()
+            if version:
+                # Extract major.minor (e.g., "3.13" from "3.13.1")
+                match = re.match(r'(\d+\.\d+)', version)
+                if match:
+                    return f"python:{match.group(1)}-slim"
+    
+    # Option 2: Check pyproject.toml requires-python
+    if 'pyproject.toml' in file_lookup:
+        file_info = file_lookup['pyproject.toml']
+        content = file_info.get('content', '')
+        if content:
+            # Parse requires-python = ">=3.13" or "^3.13"
+            match = re.search(r'requires-python\s*=\s*["\']([^"\']+)["\']', content)
+            if match:
+                version_spec = match.group(1)
+                # Extract version number (e.g., "3.13" from ">=3.13")
+                version_match = re.search(r'(\d+\.\d+)', version_spec)
+                if version_match:
+                    return f"python:{version_match.group(1)}-slim"
+    
+    return default_version
+
+
+def render_deployment_assets(context: dict) -> Dict[str, str]:
+    """
+    Renders deployment assets (Dockerfile, docker-compose.yml) using Jinja2 templates.
+    
+    IMPORTANT: This function returns strings, NOT files. The caller is responsible
+    for writing these to the correct location (e.g., via SSH to a remote droplet).
+
+    Args:
+        context: A dictionary containing information for rendering templates.
+                 Required keys:
+                   - framework: str (fastapi, flask, django)
+                   - port: int (default 8000)
+                 Optional keys:
+                   - command: str (start command, auto-generated if not provided)
+                   - database: str (postgres, mysql, etc.)
+                   - package_manager: str (pip, uv)
+                   - dependency_file: str (requirements.txt, pyproject.toml)
+                   - python_version: str (default python:3.11-slim)
+
+    Returns:
+        Dict with keys "Dockerfile" and "docker-compose.yml", values are rendered content strings.
+        Returns empty dict if no framework is provided.
+    """
+    # Path to the templates directory
+    template_dir = Path(__file__).parent / "templates"
+    env = Environment(loader=FileSystemLoader(template_dir))
+
+    # Get framework from context (MUST be provided by caller, no auto-detection)
+    framework = context.get("framework")
+    if not framework:
+        # Framework is required - caller should have validated this
+        return {}
+
+    # Get port with default
+    port = context.get("port") or 8000
+
+    # Generate default command based on framework if not provided
+    command = context.get("command")
+    if not command:
+        if framework == "fastapi":
+            command = f"uvicorn main:app --host 0.0.0.0 --port {port}"
+        elif framework == "flask":
+            command = f"gunicorn app:app -b 0.0.0.0:{port}"
+        elif framework == "django":
+            command = f"gunicorn app.wsgi:application --bind 0.0.0.0:{port}"
+        else:
+            command = f"uvicorn main:app --host 0.0.0.0 --port {port}"
+
+    # Build render context with all values
+    render_context = {
+        "framework": framework,
+        "port": port,
+        "command": command,
+        "database": context.get("database"),
+        "package_manager": context.get("package_manager", "pip"),
+        "dependency_file": context.get("dependency_file", "requirements.txt"),
+        "python_version": context.get("python_version", "python:3.11-slim"),
+        # Pass through any additional context
+        **context,
+    }
+
+    result = {}
+
+    # --- 1. Render Dockerfile ---
+    dockerfile_template = env.get_template("Dockerfile.j2")
+    result["Dockerfile"] = dockerfile_template.render(render_context)
+
+    # --- 2. Render docker-compose.yml ---
+    compose_template = env.get_template("docker-compose.yml.j2")
+    result["docker-compose.yml"] = compose_template.render(render_context)
+
+    return result
+
+
+# Keep detect_framework for potential local CLI use (not used in remote deployment)
+def detect_framework(path: str = ".") -> tuple:
+    """
+    Scans common Python project structures to guess the framework and entrypoint.
+    
+    NOTE: This is only useful when running LOCALLY on the user's machine.
+    It should NOT be called when the engine runs on a remote server.
+    
+    Returns: (framework_name, default_port, start_command) or (None, None, None)
+    """
+    project_root = Path(path).resolve()
+
+    # Check for Django first (common pattern: manage.py in root)
+    if (project_root / "manage.py").is_file():
+        project_name = project_root.name
+        return "django", 8000, f"gunicorn {project_name}.wsgi:application --bind 0.0.0.0:8000"
+
+    candidate_files = []
+    
+    # Check directly in project root
+    for name in ["main.py", "app.py"]:
+        if (project_root / name).is_file():
+            candidate_files.append(project_root / name)
+
+    # Check in src/*/ (standard package layout)
+    for src_dir in project_root.glob("src/*"):
+        if src_dir.is_dir():
+            for name in ["main.py", "app.py"]:
+                if (src_dir / name).is_file():
+                    candidate_files.append(src_dir / name)
+
+    import os
+    for file_path in candidate_files:
+        try:
+            with open(file_path, "r") as f:
+                content = f.read()
+        except Exception:
+            continue
+            
+        try:
+            module_name = str(file_path.relative_to(project_root)).replace(os.sep, '.')[:-3]
+            if module_name.startswith("src."):
+                module_name = module_name[4:]
+        except ValueError:
+            module_name = file_path.stem
+
+        if "FastAPI" in content:
+            return "fastapi", 8000, f"uvicorn {module_name}:app --host 0.0.0.0 --port 8000"
+        
+        if "Flask" in content:
+            return "flask", 5000, f"gunicorn {module_name}:app -b 0.0.0.0:5000"
+    
+    return None, None, None

{xenfra_sdk-0.2.1 → xenfra_sdk-0.2.2}/src/xenfra_sdk/engine.py

@@ -246,31 +246,77 @@ class InfraEngine:
         db_session: Session = None,
         port: int = 8000,
         command: str = None,
+        entrypoint: str = None,  # e.g., "todo.main:app"
         database: str = None,
+        package_manager: str = None,
+        dependency_file: str = None,
+        file_manifest: list = None,  # Delta upload: [{path, sha, size}, ...]
+        get_file_content: callable = None,  # Function to get file content by SHA
         **kwargs,
     ):
         """A stateful, blocking orchestrator for deploying a new server."""
         droplet = None
         session = db_session or self.db_session
+        branch = kwargs.get("branch", "main")  # Extract branch from kwargs
+        framework = kwargs.get("framework")  # Extract framework from kwargs
+        
         try:
+            # === 0. EARLY VALIDATION ===
+            # Check code source BEFORE creating droplet
+            has_code_source = repo_url or (file_manifest and get_file_content)
+            if os.getenv("XENFRA_SERVICE_MODE") == "true" and not has_code_source:
+                raise DeploymentError(
+                    "No code source provided. Use git_repo URL or upload files first. "
+                    "Local folder deployment is not supported via the cloud API.",
+                    stage="Validation",
+                )
+            
             # === 1. SETUP STAGE ===
             logger("\n[bold blue]PHASE 1: SETUP[/bold blue]")
             ssh_key = self._ensure_ssh_key(logger)
 
             # === 2. ASSET GENERATION STAGE ===
             logger("\n[bold blue]PHASE 2: GENERATING DEPLOYMENT ASSETS[/bold blue]")
+            
+            # Detect Python version from project files if using delta upload
+            python_version = "python:3.11-slim"  # Default
+            if file_manifest and get_file_content:
+                # Build file info with content for version detection
+                version_files = []
+                for finfo in file_manifest:
+                    path = finfo.get('path', '')
+                    if path in ['.python-version', 'pyproject.toml']:
+                        content = get_file_content(finfo.get('sha', ''))
+                        if content:
+                            version_files.append({
+                                'path': path,
+                                'content': content.decode('utf-8', errors='ignore')
+                            })
+                
+                if version_files:
+                    python_version = dockerizer.detect_python_version(version_files)
+                    logger(f"   - Detected Python version: {python_version}")
+            
             context = {
                 "email": email,
                 "domain": domain,
                 "repo_url": repo_url,
-                "port": port,
+                "port": port or 8000,
                 "command": command,
+                "entrypoint": entrypoint,  # Pass entrypoint to templates (e.g., "todo.main:app")
                 "database": database,
+                "package_manager": package_manager or "pip",
+                "dependency_file": dependency_file or "requirements.txt",
+                "framework": framework,  # Explicitly include framework
+                "python_version": python_version,  # Auto-detected or default
                 **kwargs,  # Pass any additional config
             }
-            files = dockerizer.generate_templated_assets(context)
-            for file in files:
-                logger(f"   - Generated {file}")
+            # Render templates to strings (NOT written to disk)
+            rendered_assets = dockerizer.render_deployment_assets(context)
+            if not rendered_assets:
+                raise DeploymentError("Failed to render deployment assets. Is framework specified?", stage="Asset Generation")
+            for filename in rendered_assets:
+                logger(f"   - Rendered {filename} ({len(rendered_assets[filename])} bytes)")
 
             # === 3. CLOUD-INIT STAGE ===
             logger("\n[bold blue]PHASE 3: CREATING SERVER SETUP SCRIPT[/bold blue]")
@@ -282,20 +328,31 @@ class InfraEngine:
 
             # === 4. DROPLET CREATION STAGE ===
             logger("\n[bold blue]PHASE 4: PROVISIONING SERVER[/bold blue]")
-            droplet = digitalocean.Droplet(
-                token=self.token,
-                name=name,
-                region=region,
-                image=image,
-                size_slug=size,
-                ssh_keys=[ssh_key.id],
-                user_data=cloud_init_script,
-                tags=["xenfra"],
-            )
-            droplet.create()
-            logger(
-                f"   - Droplet '{name}' creation initiated (ID: {droplet.id}). Waiting for it to become active..."
-            )
+            
+            # Machine Reuse: Look for existing droplet with same name and 'xenfra' tag
+            existing_droplets = digitalocean.Manager(token=self.token).get_all_droplets(tag_name="xenfra")
+            droplet = next((d for d in existing_droplets if d.name == name), None)
+            
+            if droplet and droplet.status == "active":
+                logger(f"   - Found existing active droplet '{name}' (ID: {droplet.id}). Reusing machine...")
+            else:
+                if droplet:
+                    logger(f"   - Found existing droplet '{name}' but it's not active ({droplet.status}). Creating new one...")
+                
+                droplet = digitalocean.Droplet(
+                    token=self.token,
+                    name=name,
+                    region=region,
+                    image=image,
+                    size_slug=size,
+                    ssh_keys=[ssh_key.id],
+                    user_data=cloud_init_script,
+                    tags=["xenfra"],
+                )
+                droplet.create()
+                logger(
+                    f"   - Droplet '{name}' creation initiated (ID: {droplet.id}). Waiting for it to become active..."
+                )
 
             # === 5. POLLING STAGE ===
             logger("\n[bold blue]PHASE 5: WAITING FOR SERVER SETUP[/bold blue]")
@@ -370,20 +427,77 @@ class InfraEngine:
             # === 6. CODE UPLOAD STAGE ===
             logger("\n[bold blue]PHASE 6: UPLOADING APPLICATION CODE[/bold blue]")
             with self._get_connection(ip_address) as conn:
-                # If repo_url is provided, clone it instead of uploading local code
+                # Option 1: Git clone (if repo_url provided)
                 if repo_url:
-                    logger(f"   - Cloning repository from {repo_url}...")
-                    conn.run(f"git clone {repo_url} /root/app")
-                else:
-                    # Safety check: Prevent accidental deployment of Xenfra service code
-                    if os.getenv("XENFRA_SERVICE_MODE") == "true":
-                        raise DeploymentError(
-                            "Local folder deployment is not yet supported via the cloud API. "
-                            "Please provide a git_repo URL in your xenfra.yaml or CLI command.",
-                            stage="Code Upload",
+                    logger(f"   - Cloning repository from {repo_url} (branch: {branch})...")
+                    # Use --branch to checkout specific branch, --single-branch for efficiency
+                    clone_cmd = f"git clone --branch {branch} --single-branch {repo_url} /root/app"
+                    result = conn.run(clone_cmd, warn=True, hide=True)
+                    if result.failed:
+                        # Try without --single-branch in case branch doesn't exist
+                        # Clean up any partial clone first
+                        logger(f"   - Branch '{branch}' clone failed, trying default branch...")
+                        conn.run("rm -rf /root/app", warn=True, hide=True)
+                        conn.run(f"git clone {repo_url} /root/app")
+                
+                # Option 2: Delta upload (if file_manifest provided)
+                elif file_manifest and get_file_content:
+                    logger(f"   - Syncing {len(file_manifest)} files via delta upload...")
+                    
+                    # Ensure /root/app exists
+                    conn.run("mkdir -p /root/app", hide=True)
+                    
+                    for i, file_info in enumerate(file_manifest):
+                        path = file_info['path']
+                        sha = file_info['sha']
+                        size = file_info.get('size', 0)
+                        
+                        # Build Safety: Placeholder for 0-byte critical files
+                        # (Hatchling/Pip fail if README.md or __init__.py are mentioned but empty)
+                        is_critical_empty = (
+                            size == 0 and 
+                            (path.lower() == 'readme.md' or path.endswith('__init__.py'))
                         )
+                        
+                        # Smart Incremental Sync: Check if file exists and has same SHA
+                        remote_path = f"/root/app/{path}"
+                        check_sha_cmd = f"sha256sum {remote_path}"
+                        result = conn.run(check_sha_cmd, warn=True, hide=True)
+                        
+                        if result.ok:
+                            remote_sha = result.stdout.split()[0]
+                            if remote_sha == sha and not is_critical_empty:
+                                # File already exists and matches, skip upload
+                                continue
+
+                        # Get file content from storage
+                        content = get_file_content(sha)
+                        if content is None:
+                            raise DeploymentError(f"File not found in storage: {path} (sha: {sha})", stage="Code Upload")
+                        
+                        # Apply placeholder if critical and empty
+                        if is_critical_empty:
+                            content = b"# xenfra placeholder\n"
+                            logger(f"   - [Zen Mode] Injected placeholder into empty {path}")
+
+                        # Create directory if needed
+                        dir_path = os.path.dirname(path)
+                        if dir_path:
+                            conn.run(f"mkdir -p /root/app/{dir_path}", warn=True, hide=True)
+                        
+                        # Use SFTP for file transfer (handles large files)
+                        from io import BytesIO
+                        conn.put(BytesIO(content), remote_path)
+                        
+                        # Progress update every 10 files
+                        if (i + 1) % 10 == 0 or i == len(file_manifest) - 1:
+                            logger(f"   - Synced {i + 1}/{len(file_manifest)} files...")
                     
-                    # Use rsync for efficient local folder upload
+                    logger(f"   - All {len(file_manifest)} files synced.")
+                
+                # Option 3: Local rsync (only works locally, not in service mode)
+                else:
+                    # Note: Early validation in Phase 0 should have caught this for service mode
                     private_key_path = str(Path.home() / ".ssh" / "id_rsa")
                     rsync_cmd = f'rsync -avz --exclude=".git" --exclude=".venv" --exclude="__pycache__" -e "ssh -i {private_key_path} -o StrictHostKeyChecking=no" . root@{ip_address}:/root/app/'
                     logger(f"   - Uploading local code via rsync...")
@@ -392,14 +506,34 @@ class InfraEngine:
                         raise DeploymentError(f"rsync failed: {result.stderr}", stage="Code Upload")
             logger("   - Code upload complete.")
 
+            
+            # === 6.5. WRITE DEPLOYMENT ASSETS TO DROPLET ===
+            logger("\n[bold blue]PHASE 6.5: WRITING DEPLOYMENT ASSETS[/bold blue]")
+            with self._get_connection(ip_address) as conn:
+                for filename, content in rendered_assets.items():
+                    # Use heredoc with unique delimiter to write file content
+                    # Single-quoted delimiter prevents shell variable expansion
+                    logger(f"   - Writing {filename}...")
+                    try:
+                        # Use base64 encoding to safely transfer file content
+                        # Use printf to avoid issues with special characters
+                        import base64
+                        encoded_content = base64.b64encode(content.encode()).decode()
+                        # Use printf with %s to handle any special characters in base64
+                        conn.run(f"printf '%s' '{encoded_content}' | base64 -d > /root/app/{filename}")
+                    except Exception as e:
+                        raise DeploymentError(f"Failed to write {filename}: {e}", stage="Asset Write")
+            logger("   - Deployment assets written.")
+
             # === 7. FINAL DEPLOY STAGE ===
             if is_dockerized:
                 logger("\n[bold blue]PHASE 7: BUILDING AND DEPLOYING CONTAINERS[/bold blue]")
                 with self._get_connection(ip_address) as conn:
-                    result = conn.run("cd /root/app && docker compose up -d --build", hide=True)
+                    # Force --no-cache to ensure updated files (like README.md placeholders) are used
+                    result = conn.run("cd /root/app && docker compose build --no-cache && docker compose up -d", hide=True)
                     if result.failed:
                         raise DeploymentError(f"docker-compose failed: {result.stderr}", stage="Deploy")
-                logger("   - Docker containers are building in the background...")
+                logger("   - Docker build complete, containers starting...")
             else:
                 logger("\n[bold blue]PHASE 7: STARTING HOST-BASED APPLICATION[/bold blue]")
                 start_command = context.get("command", f"uvicorn main:app --port {context.get('port', 8000)}")
@@ -411,6 +545,10 @@ class InfraEngine:
 
             # === 8. VERIFICATION STAGE ===
             logger("\n[bold blue]PHASE 8: VERIFYING DEPLOYMENT[/bold blue]")
+            
+            # Give container a moment to initialize before first health check
+            time.sleep(5)
+            
             app_port = context.get("port", 8000)
             for i in range(24):  # 2-minute timeout for health checks
                 logger(f"   - Health check attempt {i + 1}/24...")
@@ -418,7 +556,12 @@ class InfraEngine:
                     # Check if running
                     if is_dockerized:
                         ps_result = conn.run("cd /root/app && docker compose ps", hide=True)
-                        running = "running" in ps_result.stdout
+                        ps_output = ps_result.stdout.lower()
+                        # Docker Compose V1 shows "running", V2 shows "Up" in status
+                        running = "running" in ps_output or " up " in ps_output
+                        if "restarting" in ps_output:
+                            logs = conn.run("cd /root/app && docker compose logs --tail 20", hide=True).stdout
+                            raise DeploymentError(f"Application is crash-looping (restarting). Logs:\n{logs}", stage="Verification")
                     else:
                         ps_result = conn.run("ps aux | grep -v grep | grep python", hide=True)
                         running = ps_result.ok and len(ps_result.stdout.strip()) > 0
@@ -427,11 +570,19 @@ class InfraEngine:
                         time.sleep(5)
                         continue
 
-                    # Check if application is responsive
-                    curl_result = conn.run(
-                        f"curl -s --fail http://localhost:{app_port}/", warn=True
+                    # Check if application is responsive (port is listening)
+                    # Accept ANY HTTP response (including 404) - it means the app is running
+                    # Use curl with -w to get HTTP code, accept any response >= 100
+                    port_check = conn.run(
+                        f"curl -s -o /dev/null -w '%{{http_code}}' --connect-timeout 3 http://localhost:{app_port}/",
+                        warn=True, hide=True
                     )
-                    if curl_result.ok:
+                    # curl may exit non-zero for 404, but still outputs HTTP code
+                    http_code = port_check.stdout.strip()
+                    
+                    # Any HTTP response (200, 404, 500, etc.) means app is running
+                    if http_code.isdigit() and int(http_code) >= 100:
+
                         logger(
                             "[bold green]   - Health check passed! Application is live.[/bold green]"
                         )
@@ -454,13 +605,10 @@ class InfraEngine:
                         return droplet  # Return the full droplet object
                 time.sleep(5)
             else:
-                # On failure, get logs and destroy droplet
+                # Capture logs on timeout failure
                 with self._get_connection(ip_address) as conn:
-                    logs = conn.run("cd /root/app && docker compose logs", hide=True).stdout
-                raise DeploymentError(
-                    f"Application failed to become healthy in time. Logs:\n{logs}",
-                    stage="Verification",
-                )
+                    logs = conn.run("cd /root/app && docker compose logs --tail 50", hide=True, warn=True).stdout if is_dockerized else ""
+                raise DeploymentError(f"Application failed to become healthy in time. Logs:\n{logs}", stage="Verification")
 
         except Exception as e:
             if droplet:

{xenfra_sdk-0.2.1 → xenfra_sdk-0.2.2}/src/xenfra_sdk/models.py

@@ -158,6 +158,7 @@ class CodebaseAnalysisResponse(BaseModel):
     """
 
     framework: str = Field(..., description="Detected framework (fastapi, flask, django)")
+    entrypoint: str | None = Field(None, description="Application entrypoint (e.g., 'todo.main:app')")
     port: int = Field(..., description="Detected application port")
     database: str = Field(..., description="Detected database (postgresql, mysql, sqlite, none)")
     cache: str | None = Field(None, description="Detected cache (redis, memcached, none)")

{xenfra_sdk-0.2.1 → xenfra_sdk-0.2.2}/src/xenfra_sdk/resources/deployments.py

@@ -97,7 +97,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, database: 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) -> Iterator[dict]:
         """
         Creates a new deployment with real-time SSE log streaming.
 
@@ -105,7 +105,7 @@ class DeploymentsManager(BaseManager):
 
         Args:
             project_name: Name of the project
-            git_repo: Git repository URL
+            git_repo: Git repository URL (optional if file_manifest provided)
             branch: Git branch to deploy
             framework: Framework type (fastapi, flask, django)
             region: DigitalOcean region (optional)
@@ -113,7 +113,11 @@ class DeploymentsManager(BaseManager):
             is_dockerized: Whether to use Docker (optional)
             port: Application port (optional, default 8000)
             command: Start command (optional, auto-detected if not provided)
+            entrypoint: Application entrypoint (optional, e.g. 'todo.main:app')
             database: Database type (optional, e.g. 'postgres')
+            package_manager: Package manager (optional, e.g. 'pip', 'uv')
+            dependency_file: Dependency file (optional, e.g. 'requirements.txt')
+            file_manifest: List of files for delta upload [{path, sha, size}, ...]
 
         Yields:
             dict: SSE events with 'event' and 'data' fields
@@ -141,8 +145,17 @@ class DeploymentsManager(BaseManager):
             payload["port"] = port
         if command:
             payload["command"] = command
+        if entrypoint:
+            payload["entrypoint"] = entrypoint
         if database:
             payload["database"] = database
+        if package_manager:
+            payload["package_manager"] = package_manager
+        if dependency_file:
+            payload["dependency_file"] = dependency_file
+        if file_manifest:
+            payload["file_manifest"] = file_manifest
+
 
         try:
             # Use httpx to stream the SSE response

xenfra_sdk-0.2.2/src/xenfra_sdk/resources/files.py

@@ -0,0 +1,101 @@
+"""
+Files resource manager for delta uploads.
+
+Provides methods to check file cache status and upload files to the server.
+"""
+
+from typing import Dict, List
+
+
+class FilesManager:
+    """Manager for file upload operations."""
+    
+    def __init__(self, client):
+        """
+        Initialize the FilesManager.
+        
+        Args:
+            client: The XenfraClient instance.
+        """
+        self._client = client
+    
+    def check(self, files: List[Dict]) -> Dict:
+        """
+        Check which files are missing from server cache.
+        
+        Args:
+            files: List of file info dicts with keys: path, sha, size
+        
+        Returns:
+            Dict with keys:
+                - missing: List of SHA hashes that need to be uploaded
+                - cached: Number of files already cached on server
+        """
+        payload = {
+            "files": [
+                {"path": f["path"], "sha": f["sha"], "size": f["size"]}
+                for f in files
+            ]
+        }
+        
+        response = self._client._request("POST", "/files/check", json=payload)
+        return response.json()
+    
+    def upload(self, content: bytes, sha: str, path: str) -> Dict:
+        """
+        Upload a single file to the server.
+        
+        Args:
+            content: Raw file content as bytes
+            sha: SHA256 hash of the content
+            path: Relative file path
+        
+        Returns:
+            Dict with keys: sha, size, stored
+        """
+        import httpx
+        
+        headers = {
+            "Authorization": f"Bearer {self._client._token}",
+            "Content-Type": "application/octet-stream",
+            "X-Xenfra-Sha": sha,
+            "X-Xenfra-Path": path,
+        }
+        
+        response = httpx.post(
+            f"{self._client.api_url}/files/upload",
+            content=content,
+            headers=headers,
+            timeout=120.0,  # 2 minutes for large files
+        )
+        response.raise_for_status()
+        return response.json()
+    
+    def upload_files(self, files: List[Dict], missing_shas: List[str], progress_callback=None) -> int:
+        """
+        Upload multiple files that are missing from the server.
+        
+        Args:
+            files: List of file info dicts with keys: path, sha, size, abs_path
+            missing_shas: List of SHA hashes that need to be uploaded
+            progress_callback: Optional callback(uploaded_count, total_count)
+        
+        Returns:
+            Number of files uploaded
+        """
+        missing_set = set(missing_shas)
+        files_to_upload = [f for f in files if f["sha"] in missing_set]
+        total = len(files_to_upload)
+        uploaded = 0
+        
+        for file_info in files_to_upload:
+            with open(file_info["abs_path"], "rb") as f:
+                content = f.read()
+            
+            self.upload(content, file_info["sha"], file_info["path"])
+            uploaded += 1
+            
+            if progress_callback:
+                progress_callback(uploaded, total)
+        
+        return uploaded

xenfra_sdk-0.2.2/src/xenfra_sdk/templates/Dockerfile.j2

@@ -0,0 +1,38 @@
+# 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') }}
+{% else %}
+RUN uv pip install --system --no-cache -r {{ dependency_file | default('requirements.txt') }}
+{% 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-0.2.1 → xenfra_sdk-0.2.2}/src/xenfra_sdk/templates/docker-compose.yml.j2

@@ -1,12 +1,15 @@
 # docker-compose.yml template
-version: '3.8'
 
 services:
   app:
     build: .
     ports:
       - "{{ port | default(8000) }}:{{ port | default(8000) }}"
-    command: {{ command | default('uvicorn main:app --host 0.0.0.0 --port 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

xenfra_sdk-0.2.1/src/xenfra_sdk/dockerizer.py

@@ -1,104 +0,0 @@
-import os
-from pathlib import Path
-
-from jinja2 import Environment, FileSystemLoader
-
-
-def detect_framework(path="."):
-    """
-    Scans common Python project structures to guess the framework and entrypoint.
-    Returns: (framework_name, default_port, start_command) or (None, None, None)
-    """
-    project_root = Path(path).resolve()
-
-    # Check for Django first (common pattern: manage.py in root)
-    if (project_root / "manage.py").is_file():
-        # Assume the project name is the current directory name
-        project_name = project_root.name
-        return "django", 8000, f"gunicorn {project_name}.wsgi:application --bind 0.0.0.0:8000"
-
-    candidate_files = []
-    
-    # Check directly in project root
-    for name in ["main.py", "app.py"]:
-        if (project_root / name).is_file():
-            candidate_files.append(project_root / name)
-
-    # Check in src/*/ (standard package layout)
-    for src_dir in project_root.glob("src/*"):
-        if src_dir.is_dir():
-            for name in ["main.py", "app.py"]:
-                if (src_dir / name).is_file():
-                    candidate_files.append(src_dir / name)
-
-    for file_path in candidate_files:
-        with open(file_path, "r") as f:
-            content = f.read()
-            
-            try:
-                module_name = str(file_path.relative_to(project_root)).replace(os.sep, '.')[:-3]
-                # If path is like src/testdeploy/main.py, module_name becomes src.testdeploy.main
-                if module_name.startswith("src."):
-                    # Strip the "src." prefix for gunicorn/uvicorn
-                    module_name = module_name[4:]
-            except ValueError:
-                module_name = file_path.stem
-
-            if "FastAPI" in content:
-                # Use standard :app convention
-                return "fastapi", 8000, f"uvicorn {module_name}:app --host 0.0.0.0 --port 8000"
-            
-            if "Flask" in content:
-                return "flask", 5000, f"gunicorn {module_name}:app -b 0.0.0.0:5000"
-    
-    return None, None, None
-
-
-def generate_templated_assets(context: dict):
-    """
-    Generates deployment assets (Dockerfile, docker-compose.yml) using Jinja2 templates.
-
-    Args:
-        context: A dictionary containing information for rendering templates,
-                 e.g., {'database': 'postgres', 'python_version': 'python:3.11-slim'}
-    """
-    # Path to the templates directory
-    template_dir = Path(__file__).parent / "templates"
-    env = Environment(loader=FileSystemLoader(template_dir))
-
-    # Detect framework specifics (use context if available, otherwise fallback to manual)
-    detected_framework, detected_port, detected_command = detect_framework()
-    
-    framework = context.get("framework") or detected_framework
-    port = context.get("port") or detected_port
-    command = context.get("command") or detected_command
-
-    if not framework:
-        print("Warning: No recognizable web framework detected and no framework provided in context.")
-        return []
-
-    # Merge detected values with provided context (context takes precedence)
-    render_context = {
-        "framework": framework, 
-        "port": port, 
-        "command": command, 
-        **context
-    }
-
-    generated_files = []
-
-    # --- 1. Dockerfile ---
-    dockerfile_template = env.get_template("Dockerfile.j2")
-    dockerfile_content = dockerfile_template.render(render_context)
-    with open("Dockerfile", "w") as f:
-        f.write(dockerfile_content)
-    generated_files.append("Dockerfile")
-
-    # --- 2. docker-compose.yml ---
-    compose_template = env.get_template("docker-compose.yml.j2")
-    compose_content = compose_template.render(render_context)
-    with open("docker-compose.yml", "w") as f:
-        f.write(compose_content)
-    generated_files.append("docker-compose.yml")
-
-    return generated_files

xenfra_sdk-0.2.1/src/xenfra_sdk/templates/Dockerfile.j2

@@ -1,25 +0,0 @@
-# Dockerfile template for Python web applications
-FROM {{ python_version | default('python:3.11-slim') }}
-
-WORKDIR /app
-
-# Install uv, our preferred package manager
-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/*
-
-COPY requirements.txt .
-
-# Install dependencies
-RUN /root/.cargo/bin/uv pip install --system --no-cache -r requirements.txt
-
-COPY . .
-
-# Expose the application port
-EXPOSE {{ port | default(8000) }}
-
-# The command to run the application will be in docker-compose.yml
-# This allows for more flexibility
-