xenfra 0.4.4__py3-none-any.whl → 0.4.5__py3-none-any.whl

xenfra/blueprints/e2b.py

@@ -0,0 +1,101 @@
+"""
+Tier 3: E2B Sandbox integration via Xenfra API.
+
+The sandbox runs on Xenfra's servers, not locally. Users don't need:
+- E2B package installed
+- E2B_API_KEY set
+- Any E2B configuration
+
+They just need a Xenfra account. We handle E2B on our backend.
+"""
+
+from pathlib import Path
+from typing import Optional
+from dataclasses import dataclass
+
+from .base import BuildPlan
+
+
+@dataclass
+class SandboxResult:
+    """Result of sandbox build validation."""
+    success: bool
+    build_output: str = ""
+    error_message: Optional[str] = None
+    build_time_seconds: float = 0.0
+    
+    def __bool__(self):
+        return self.success
+
+
+class E2BSandbox:
+    """
+    E2B Sandbox client - calls Xenfra API to run sandbox.
+    
+    The actual sandbox runs on Xenfra's servers using E2B.
+    This class just makes API calls to our backend via SDK.
+    """
+    
+    def __init__(self, api_client=None):
+        self.api_client = api_client
+    
+    @property
+    def is_available(self) -> bool:
+        """Check if sandbox is available (has API client)."""
+        return self.api_client is not None
+    
+    def validate_build(
+        self, 
+        project_path: Path, 
+        plan: BuildPlan,
+        file_manifest: list,
+        timeout: int = 300
+    ) -> SandboxResult:
+        """
+        Validate a build via Xenfra API sandbox.
+        
+        Args:
+            project_path: Path to the project directory (for reference)
+            plan: BuildPlan with build information
+            file_manifest: List of file info dicts for the project
+            timeout: Maximum time to wait
+            
+        Returns:
+            SandboxResult with build status
+        """
+        if not self.api_client:
+            return SandboxResult(
+                success=False,
+                error_message="Not authenticated. Run 'xenfra auth login' first."
+            )
+        
+        try:
+            # Use SDK's build.validate method
+            result = self.api_client.build.validate(
+                file_manifest=file_manifest,
+                build_plan=plan.to_dict(),
+                timeout=timeout
+            )
+            
+            return SandboxResult(
+                success=result.get("success", False),
+                build_output=result.get("output", ""),
+                error_message=result.get("error"),
+                build_time_seconds=result.get("build_time", 0.0)
+            )
+            
+        except Exception as e:
+            return SandboxResult(
+                success=False,
+                error_message=f"Sandbox validation failed: {e}"
+            )
+
+
+def get_sandbox(api_client=None) -> E2BSandbox:
+    """Get E2B sandbox client."""
+    return E2BSandbox(api_client)
+
+
+def is_sandbox_available(api_client=None) -> bool:
+    """Check if sandbox is available."""
+    return get_sandbox(api_client).is_available

xenfra/blueprints/factory.py

@@ -0,0 +1,113 @@
+"""
+Blueprint factory - Railpack-first routing with E2B dry-run support.
+
+Architecture:
+- Railpack-first: Use Railway's buildpack for all project detection
+- E2B sandbox: Optional dry-run builds in isolated environments
+- Fallback chain: Railpack → Error (no other blueprints needed)
+
+Environment Variables:
+- E2B_API_KEY: API key for E2B sandbox (optional, for --dry-run)
+"""
+
+import os
+from pathlib import Path
+from typing import Optional
+
+from .base import Blueprint, BuildPlan
+from .railpack import RailpackBlueprint
+
+
+class BlueprintFactory:
+    """
+    Factory for creating and selecting blueprints.
+    
+    Implements Railpack-first routing:
+    1. RailpackBlueprint - Universal detection for all frameworks
+    2. No fallbacks needed - Railpack handles everything
+    """
+    
+    def __init__(self):
+        # Single blueprint - Railpack handles all cases
+        self._blueprint = RailpackBlueprint()
+    
+    def detect_framework(self, project_path: Path) -> tuple[str, BuildPlan]:
+        """
+        Detect framework and generate build plan for a project.
+        
+        Args:
+            project_path: Path to the project directory
+            
+        Returns:
+            Tuple of (framework_name, build_plan)
+            
+        Raises:
+            RuntimeError: If detection fails
+        """
+        plan = self._blueprint.generate_plan(project_path)
+        return plan.framework, plan
+    
+    def get_build_plan(self, project_path: Path) -> BuildPlan:
+        """
+        Get the build plan for a project.
+        
+        Args:
+            project_path: Path to the project directory
+            
+        Returns:
+            BuildPlan with all build/deployment information
+        """
+        return self._blueprint.generate_plan(project_path)
+    
+    def generate_dockerfile(self, project_path: Path) -> str:
+        """
+        Generate a Dockerfile for the project.
+        
+        Args:
+            project_path: Path to the project directory
+            
+        Returns:
+            Generated Dockerfile content
+        """
+        return self._blueprint.generate_dockerfile(project_path)
+
+
+# Global factory instance
+_factory: Optional[BlueprintFactory] = None
+
+
+def get_factory() -> BlueprintFactory:
+    """Get the global blueprint factory instance."""
+    global _factory
+    if _factory is None:
+        _factory = BlueprintFactory()
+    return _factory
+
+
+def get_blueprint_for_framework(framework: str) -> Blueprint:
+    """
+    Get the appropriate blueprint for a framework.
+    
+    Note: Since we use Railpack-first, this always returns RailpackBlueprint.
+    The framework parameter is kept for API compatibility.
+    
+    Args:
+        framework: Framework name (for compatibility, not used)
+        
+    Returns:
+        RailpackBlueprint instance
+    """
+    return RailpackBlueprint()
+
+
+def detect_project(project_path: Path) -> tuple[str, BuildPlan]:
+    """
+    Convenience function to detect framework and get build plan.
+    
+    Args:
+        project_path: Path to the project directory
+        
+    Returns:
+        Tuple of (framework_name, build_plan)
+    """
+    return get_factory().detect_framework(project_path)

xenfra/blueprints/railpack.py

@@ -0,0 +1,319 @@
+"""
+Railpack blueprint - Railway's buildpack for universal project detection.
+
+Downloads and runs the Railpack binary to analyze projects and generate
+Dockerfile-based build plans.
+"""
+
+import json
+import os
+import platform
+import subprocess
+import sys
+from pathlib import Path
+from typing import Optional
+
+from .base import Blueprint, BuildPlan
+
+
+class RailpackBlueprint(Blueprint):
+    """
+    Railpack-based blueprint using Railway's buildpack.
+    
+    Railpack is a universal buildpack that can detect and build:
+    - Python (FastAPI, Flask, Django, etc.)
+    - Node.js (Next.js, Express, NestJS, etc.)
+    - Go (Gin, Echo, etc.)
+    - Rust (Actix, Axum, etc.)
+    - Ruby, PHP, Java, and more
+    
+    Download URL: https://github.com/railwayapp/railpack/releases
+    """
+    
+    name = "railpack"
+    languages = ["python", "node", "go", "rust", "ruby", "php", "java", "dotnet"]
+    
+    # Version to download
+    RAILPACK_VERSION = "0.0.70"
+    
+    def __init__(self):
+        self._binary_path: Optional[Path] = None
+        self._cache_dir = Path.home() / ".xenfra" / "cache" / "railpack"
+    
+    def _get_binary_name(self) -> str:
+        """Get the appropriate binary name for the current platform."""
+        system = platform.system().lower()
+        machine = platform.machine().lower()
+        
+        # Map machine arch
+        if machine in ("amd64", "x86_64"):
+            arch = "amd64"
+        elif machine in ("arm64", "aarch64"):
+            arch = "arm64"
+        else:
+            arch = "amd64"  # fallback
+        
+        # Map system
+        if system == "darwin":
+            os_name = "darwin"
+        elif system == "linux":
+            os_name = "linux"
+        elif system == "windows":
+            os_name = "windows"
+        else:
+            os_name = "linux"  # fallback
+        
+        ext = ".exe" if os_name == "windows" else ""
+        return f"railpack_{self.RAILPACK_VERSION}_{os_name}_{arch}{ext}"
+    
+    def _get_download_url(self) -> str:
+        """Get the download URL for the current platform."""
+        binary_name = self._get_binary_name()
+        return (
+            f"https://github.com/railwayapp/railpack/releases/download/"
+            f"v{self.RAILPACK_VERSION}/{binary_name}"
+        )
+    
+    def _ensure_binary(self) -> Path:
+        """
+        Ensure the Railpack binary is available, download if needed.
+        
+        Returns:
+            Path to the railpack binary
+        """
+        if self._binary_path and self._binary_path.exists():
+            return self._binary_path
+        
+        # Create cache directory
+        self._cache_dir.mkdir(parents=True, exist_ok=True)
+        
+        binary_name = self._get_binary_name()
+        binary_path = self._cache_dir / "railpack"
+        
+        # Check if already cached
+        if binary_path.exists():
+            self._binary_path = binary_path
+            return binary_path
+        
+        # Download binary
+        import urllib.request
+        
+        url = self._get_download_url()
+        temp_path = self._cache_dir / binary_name
+        
+        print(f"Downloading Railpack v{self.RAILPACK_VERSION}...")
+        print(f"  URL: {url}")
+        
+        try:
+            urllib.request.urlretrieve(url, temp_path)
+            
+            # Make executable (not needed on Windows)
+            if platform.system() != "Windows":
+                os.chmod(temp_path, 0o755)
+            
+            # Rename to standard name
+            temp_path.rename(binary_path)
+            
+            print(f"  Saved to: {binary_path}")
+            
+            self._binary_path = binary_path
+            return binary_path
+            
+        except Exception as e:
+            raise RuntimeError(f"Failed to download Railpack: {e}")
+    
+    def detect(self, project_path: Path) -> bool:
+        """
+        Railpack can handle any project - it's universal.
+        
+        Args:
+            project_path: Path to the project directory
+            
+        Returns:
+            Always True (fallback blueprint)
+        """
+        return True
+    
+    def generate_plan(self, project_path: Path) -> BuildPlan:
+        """
+        Generate a build plan using Railpack analysis.
+        
+        Args:
+            project_path: Path to the project directory
+            
+        Returns:
+            BuildPlan from Railpack analysis
+            
+        Raises:
+            RuntimeError: If Railpack analysis fails
+        """
+        binary = self._ensure_binary()
+        
+        # Run railpack analyze
+        try:
+            result = subprocess.run(
+                [str(binary), "analyze", str(project_path)],
+                capture_output=True,
+                text=True,
+                timeout=60,
+            )
+            
+            if result.returncode != 0:
+                raise RuntimeError(f"Railpack analyze failed: {result.stderr}")
+            
+            # Parse the output as JSON
+            analysis = json.loads(result.stdout)
+            
+            # Extract information from Railpack output
+            metadata = analysis.get("metadata", {})
+            
+            # Detect framework from metadata
+            framework = self._detect_framework(metadata, project_path)
+            
+            # Get package manager
+            pkg_manager = metadata.get("package_manager", "unknown")
+            
+            # Get dependency file
+            dep_file = self._get_dependency_file(pkg_manager, project_path)
+            
+            # Get port (common defaults)
+            port = self._detect_port(metadata, framework)
+            
+            # Get start command from Railpack or infer
+            start_cmd = self._get_start_command(analysis, framework, port)
+            
+            return BuildPlan(
+                framework=framework,
+                language=metadata.get("language", "unknown"),
+                package_manager=pkg_manager,
+                dependency_file=dep_file,
+                build_command=None,  # Railpack handles this in the Dockerfile
+                start_command=start_cmd,
+                port=port,
+                dockerfile=None,  # Generated by Railpack
+                detected_from="railpack",
+            )
+            
+        except json.JSONDecodeError as e:
+            raise RuntimeError(f"Failed to parse Railpack output: {e}")
+        except subprocess.TimeoutExpired:
+            raise RuntimeError("Railpack analysis timed out")
+        except Exception as e:
+            raise RuntimeError(f"Railpack analysis failed: {e}")
+    
+    def generate_dockerfile(self, project_path: Path) -> str:
+        """
+        Generate a Dockerfile using Railpack.
+        
+        Args:
+            project_path: Path to the project directory
+            
+        Returns:
+            Generated Dockerfile content
+        """
+        binary = self._ensure_binary()
+        
+        try:
+            result = subprocess.run(
+                [str(binary), "build", str(project_path)],
+                capture_output=True,
+                text=True,
+                timeout=120,
+            )
+            
+            if result.returncode != 0:
+                raise RuntimeError(f"Railpack build failed: {result.stderr}")
+            
+            return result.stdout
+            
+        except subprocess.TimeoutExpired:
+            raise RuntimeError("Railpack build timed out")
+        except Exception as e:
+            raise RuntimeError(f"Railpack build failed: {e}")
+    
+    def _detect_framework(self, metadata: dict, project_path: Path) -> str:
+        """Detect framework from Railpack metadata and project files."""
+        # Check metadata hints
+        hints = metadata.get("hints", [])
+        
+        for hint in hints:
+            hint_lower = hint.lower()
+            if "fastapi" in hint_lower:
+                return "fastapi"
+            elif "flask" in hint_lower:
+                return "flask"
+            elif "django" in hint_lower:
+                return "django"
+            elif "next" in hint_lower:
+                return "nextjs"
+            elif "express" in hint_lower:
+                return "express"
+            elif "nest" in hint_lower:
+                return "nestjs"
+        
+        # Check for specific files
+        if (project_path / "next.config.js").exists() or (project_path / "next.config.ts").exists():
+            return "nextjs"
+        
+        # Default to language
+        lang = metadata.get("language", "unknown")
+        return lang if lang != "unknown" else "generic"
+    
+    def _get_dependency_file(self, package_manager: str, project_path: Path) -> str:
+        """Get the dependency file name based on package manager."""
+        mapping = {
+            "pip": "requirements.txt",
+            "poetry": "pyproject.toml",
+            "pipenv": "Pipfile",
+            "uv": "pyproject.toml",
+            "npm": "package.json",
+            "yarn": "package.json",
+            "pnpm": "package.json",
+            "bun": "package.json",
+            "go": "go.mod",
+            "cargo": "Cargo.toml",
+            "bundler": "Gemfile",
+            "composer": "composer.json",
+        }
+        return mapping.get(package_manager, "requirements.txt")
+    
+    def _detect_port(self, metadata: dict, framework: str) -> int:
+        """Detect the port based on framework and metadata."""
+        # Check if port is specified in environment
+        for env in metadata.get("env", []):
+            if "PORT" in env:
+                try:
+                    return int(env.split("=")[1])
+                except (IndexError, ValueError):
+                    pass
+        
+        # Framework defaults
+        framework_ports = {
+            "fastapi": 8000,
+            "flask": 5000,
+            "django": 8000,
+            "nextjs": 3000,
+            "express": 3000,
+            "nestjs": 3000,
+        }
+        
+        return framework_ports.get(framework, 8000)
+    
+    def _get_start_command(self, analysis: dict, framework: str, port: int) -> Optional[str]:
+        """Get the start command from Railpack analysis or infer it."""
+        # Check if Railpack provided a start command
+        commands = analysis.get("commands", {})
+        if "start" in commands:
+            return commands["start"]
+        
+        # Infer based on framework
+        cmds = {
+            "fastapi": f"uvicorn main:app --host 0.0.0.0 --port {port}",
+            "flask": f"flask run --host=0.0.0.0 --port={port}",
+            "django": f"python manage.py runserver 0.0.0.0:{port}",
+            "nextjs": "npm start",
+            "express": "node server.js",
+            "nestjs": "npm run start:prod",
+        }
+        
+        return cmds.get(framework)