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

xenfra_sdk/blueprints/railpack.py

@@ -0,0 +1,99 @@
+"""
+Railpack Blueprint - Auto-detects and builds any language using Railpack.
+
+Railpack is Railway's open-source buildpack that replaces manual Dockerfile
+templates with intelligent language detection.
+"""
+
+import os
+import tempfile
+from typing import Optional
+
+from xenfra_sdk.blueprints.base import BaseBlueprint
+from xenfra_sdk.blueprints.schema import DeploymentBlueprintManifest
+from xenfra_sdk.railpack_manager import get_railpack_manager
+from xenfra_sdk.railpack_adapter import RailpackAdapter
+
+
+class RailpackBlueprint(BaseBlueprint):
+    """
+    The Universal Blueprint: Uses Railpack for language-agnostic builds.
+    
+    Railpack auto-detects the project type (Python, Node, Go, Rust, etc.)
+    and generates optimized container configurations.
+    """
+
+    def generate_manifest(self) -> DeploymentBlueprintManifest:
+        """
+        Generate deployment manifest using Railpack.
+        
+        1. Run Railpack prepare on source code
+        2. Convert Railpack plan to Xenfra manifest
+        3. Return standardized assets
+        
+        Raises:
+            RuntimeError: If Railpack fails to generate valid plan
+        """
+        source_path = self._get_source_path()
+        
+        # Get Railpack manager (auto-downloads if needed)
+        railpack = get_railpack_manager()
+        
+        # Create temporary plan file
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
+            plan_path = f.name
+        
+        try:
+            # Run Railpack prepare
+            result = railpack.run(
+                'prepare', source_path,
+                '--plan-out', plan_path,
+                cwd=source_path, # CRITICAL: Railpack needs CWD to be project root for proper detection
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            
+            # Load the plan
+            import json
+            with open(plan_path) as f:
+                plan = json.load(f)
+            
+            # DEBUG: Log the full plan for transparency
+            print(f"[RailpackBlueprint] Full JSON Plan:\n{json.dumps(plan, indent=2)}")
+            
+            # Convert to Xenfra manifest
+            adapter = RailpackAdapter(plan, context=self.context)
+            manifest = adapter.convert()
+            
+            # Store detected language in context for later use
+            detected_lang = adapter.get_detected_language()
+            if detected_lang:
+                self.context['detected_language'] = detected_lang
+            
+            return manifest
+            
+        except Exception as e:
+            raise RuntimeError(f"Railpack failed to generate manifest: {e}")
+        finally:
+            # Cleanup temp file
+            if os.path.exists(plan_path):
+                os.unlink(plan_path)
+    
+    def _get_source_path(self) -> str:
+        """Get source code path from context."""
+        # Try explicit source path or repo path
+        source_path = self.context.get('source_path') or self.context.get('repo_path')
+        if source_path:
+            return source_path
+        
+        # Try file manifest to infer path
+        file_manifest = self.context.get('file_manifest', [])
+        if file_manifest:
+            # Assume first file's directory is project root
+            first_file = file_manifest[0].get('path', '')
+            if first_file:
+                return os.path.dirname(first_file) or '.'
+        
+        # Default to current directory
+        return '.'

xenfra_sdk/blueprints/schema.py

@@ -0,0 +1,70 @@
+from typing import List, Dict, Optional, Union, Any
+from pydantic import BaseModel, Field
+
+
+# --- ZEN GAP FIX: Resource Governance Models ---
+class ResourceLimitsModel(BaseModel):
+    """Docker cgroups resource limits (deterministic, no AI)."""
+    memory: str = "512m"
+    cpus: Union[str, float] = "0.5"
+
+
+class ResourceReservationsModel(BaseModel):
+    """Docker resource reservations."""
+    memory: str = "128m"
+    cpus: Union[str, float] = "0.25"
+
+
+class DeployResourcesModel(BaseModel):
+    """Docker Compose deploy.resources configuration."""
+    limits: ResourceLimitsModel = Field(default_factory=ResourceLimitsModel)
+    reservations: ResourceReservationsModel = Field(default_factory=ResourceReservationsModel)
+
+
+class DeployModel(BaseModel):
+    """Docker Compose deploy configuration for resource governance."""
+    resources: DeployResourcesModel = Field(default_factory=DeployResourcesModel)
+
+
+class DockerfileModel(BaseModel):
+    """Structured representation of a Dockerfile."""
+    base_image: str = Field(..., description="The base image (e.g., python:3.11-slim)")
+    env_vars: Dict[str, str] = Field(default_factory=dict, description="Environment variables for the build")
+    workdir: str = "/app"
+    system_packages: List[str] = Field(default_factory=list, description="APT packages to install")
+    copy_dirs: List[str] = Field(default_factory=list, description="Directories to copy into the image")
+    run_commands: List[str] = Field(default_factory=list, description="Custom RUN commands")
+    args: List[str] = Field(default_factory=list, description="ARG instructions for build-time variables")
+    expose_port: Optional[int] = None
+    entrypoint: Optional[Union[str, List[str]]] = None
+    command: Optional[Union[str, List[str]]] = None
+
+class ServiceDetail(BaseModel):
+    """Detail for a single docker-compose service."""
+    image: Optional[str] = None
+    build_context: Optional[Union[str, Dict[str, Any]]] = Field(None, alias="build")
+    ports: List[str] = Field(default_factory=list)
+    environment: Dict[str, str] = Field(default_factory=dict)
+    env_file: List[str] = Field(default_factory=list)
+    restart: str = "unless-stopped"
+    depends_on: List[str] = Field(default_factory=list)
+    volumes: List[str] = Field(default_factory=list)
+    command: Optional[Union[str, List[str]]] = None
+    # --- ZEN GAP FIX: Resource Governance ---
+    deploy: Optional[DeployModel] = Field(default_factory=DeployModel)
+    oom_kill_disable: bool = False  # Let OOM killer work to protect host
+
+class ComposeModel(BaseModel):
+    """Structured representation of a docker-compose.yml file."""
+    version: str = "3.8"
+    services: Dict[str, ServiceDetail]
+    volumes: Dict[str, dict] = Field(default_factory=dict)
+    networks: Dict[str, dict] = Field(default_factory=dict)
+
+class DeploymentBlueprintManifest(BaseModel):
+    """The complete set of manifests generated by a blueprint."""
+    dockerfile: DockerfileModel
+    compose: ComposeModel
+    env_file: Dict[str, str] = Field(default_factory=dict)
+    caddyfile: Optional[str] = None
+    railpack_plan: Optional[str] = None  # Raw JSON plan from Railpack CLI

xenfra_sdk/cli/main.py

@@ -2,9 +2,12 @@ import click
 import yaml
 from rich.console import Console
 from rich.table import Table
+from rich.panel import Panel
+from rich.tree import Tree
 from xenfra_sdk import dockerizer
 from xenfra_sdk.db.session import create_db_and_tables
 from xenfra_sdk.engine import DeploymentError, InfraEngine
+from xenfra_sdk.manifest import XenfraConfig, InfrastructureService, load_xenfra_config
 
 console = Console()
 
@@ -31,88 +34,211 @@ def main(ctx):
 @click.pass_context
 def init(ctx):
     """Initializes a project by creating a xenfra.yaml configuration file."""
-    console.print("\n[bold blue]🔎 INITIALIZING PROJECT[/bold blue]")
-
-    framework, _, _ = dockerizer.detect_framework()
-    if not framework:
-        console.print("[yellow]   Warning: No recognizable web framework detected.[/yellow]")
-
-    console.print(f"   - Detected [cyan]{framework or 'unknown'}[/cyan] project.")
+    console.print("\n[bold blue]🔎 INITIALIZING PROJECT (UNIFIED BRAIN)[/bold blue]")
+
+    from xenfra_sdk.detection import auto_detect_services
+    
+    with console.status("[bold green]Analyzing project with Unified Brain...[/bold green]"):
+        detected = auto_detect_services(".")
+    
+    if not detected:
+        console.print("[yellow]   Warning: No services detected in this repository.[/yellow]")
+        if not click.confirm("   Do you want to continue with a blank configuration?"):
+            return
+        services = []
+        infrastructure = []
+    else:
+        # Construct config from detected services
+        from xenfra_sdk.manifest import create_services_from_detected
+        services = create_services_from_detected(detected)
+        
+        # Simple infrastructure inference (Migrated from discovery.py logic)
+        infrastructure = []
+        found_infra = set()
+        for svc in detected:
+            if svc.get("is_infrastructure"):
+                found_infra.add(svc["framework"]) # Basic mapping
+        
+        # Display detected services
+        table = Table(title="Detected Services", show_header=True, header_style="bold cyan")
+        table.add_column("Service Name", style="bold")
+        table.add_column("Tier", style="dim")
+        table.add_column("Framework", style="green")
+        table.add_column("Port", style="magenta")
+        
+        for svc in services:
+            table.add_row(svc.name, svc.tier, svc.framework, str(svc.port))
+        
+        console.print(table)
 
-    use_db = click.confirm(
-        "\n   Would you like to add a PostgreSQL database to your deployment?", default=False
+    # Project Name
+    config_name = Path(".").resolve().name
+    project_name = click.prompt("\n   Project Name", default=config_name)
+    
+    config = XenfraConfig(
+        name=project_name,
+        services=services,
+        infrastructure=infrastructure
     )
 
-    config = {
-        "name": "xenfra-app",
-        "digitalocean": {"region": "nyc3", "size": "s-1vcpu-1gb", "image": "ubuntu-22-04-x64"},
-        "app": {"framework": framework},
-    }
-
-    if use_db:
-        config["database"] = {
-            "type": "postgres",
-            "user": "db_user",
-            "password": "db_password",  # In a real scenario, this should be handled more securely
-            "name": "app_db",
-        }
-        console.print("   - Added [bold green]PostgreSQL[/bold green] to the configuration.")
-
-    with open("xenfra.yaml", "w") as f:
-        yaml.dump(config, f, default_flow_style=False, sort_keys=False)
+    # Commit to file
+    config.to_yaml(Path("xenfra.yaml"))
 
     console.print("\n[bold green]✅ SUCCESS![/bold green]")
-    console.print("   - Created [cyan]xenfra.yaml[/cyan].")
+    console.print("   - Created [cyan]xenfra.yaml[/cyan] with Unified Brain discovery.")
     console.print("\n   Next step: Review the configuration and run 'xenfra deploy'!")
 
 
 @main.command()
+@click.option("--json", "output_json", is_flag=True, help="Output as JSON for scripting.")
+def detect(output_json):
+    """Detects the framework and configuration of the current project."""
+    console.print("\n[bold blue]🔍 ANALYZING PROJECT[/bold blue]")
+    
+    detector = get_railpack_detector()
+    
+    with console.status("[bold green]Running Railpack detection...[/bold green]"):
+        result = detector.detect_from_path(".")
+    
+    if output_json:
+        import json
+        click.echo(json.dumps({
+            "framework": result.framework,
+            "confidence": result.confidence,
+            "detected_from": result.detected_from,
+            "package_manager": result.package_manager,
+            "runtime_version": result.runtime_version,
+            "start_command": result.start_command,
+            "detected_port": result.detected_port,
+            "runtime_name": result.runtime_name,
+            "build_commands": result.build_commands
+        }, indent=2))
+    else:
+        if result.framework == "unknown":
+            console.print("[yellow]⚠️  Could not detect framework.[/yellow]")
+            console.print("[dim]   Try running from a project root with recognizable files.[/dim]")
+        else:
+            tree = Tree(f"[bold green]{result.framework.upper()}[/bold green]")
+            
+            if result.runtime_name:
+                tree.add(f"[blue]Runtime:[/blue] {result.runtime_name}")
+            if result.runtime_version:
+                tree.add(f"[blue]Version:[/blue] {result.runtime_version}")
+            if result.package_manager:
+                tree.add(f"[magenta]Package Manager:[/magenta] {result.package_manager}")
+            if result.detected_port:
+                tree.add(f"[yellow]Port:[/yellow] {result.detected_port}")
+            if result.start_command:
+                tree.add(f"[cyan]Start Command:[/cyan] {result.start_command}")
+            if result.build_commands:
+                build_tree = tree.add("[dim]Build Steps:[/dim]")
+                for cmd in result.build_commands:
+                    build_tree.add(f"[dim]→ {cmd}[/dim]")
+            
+            tree.add(f"[dim]Confidence:[/dim] {result.confidence}")
+            tree.add(f"[dim]Detected From:[/dim] {result.detected_from}")
+            
+            console.print(tree)
+            
+            console.print("\n[dim]Tip: Run 'xenfra init --railpack' to create config from this detection.[/dim]")
+
+
+@main.command()
+@click.option("--skip-local", is_flag=True, help="Skip the mandatory local mirroring check (Not recommended for Free Tier).")
+@click.option("--dry-run", is_flag=True, help="Generate assets without deploying.")
+@click.option("--env-file", type=click.Path(exists=True), help="Path to .env file to load environment variables.")
 @click.pass_context
-def deploy(ctx):
+def deploy(ctx, skip_local, dry_run, env_file):
     """Deploys the project based on the xenfra.yaml configuration."""
     console.print("\n[bold green]🚀 INITIATING DEPLOYMENT FROM CONFIGURATION[/bold green]")
 
-    try:
-        with open("xenfra.yaml", "r") as f:
-            config = yaml.safe_load(f)
-    except FileNotFoundError:
+    config = load_xenfra_config(".")
+    if not config:
         raise click.ClickException(
             "No 'xenfra.yaml' found. Run 'xenfra init' to create a configuration file."
         )
 
     engine = ctx.obj["engine"]
 
-    # Extract config values
-    name = config.get("name", "xenfra-app")
-    do_config = config.get("digitalocean", {})
-    region = do_config.get("region", "nyc3")
-    size = do_config.get("size", "s-1vcpu-1gb")
-    image = do_config.get("image", "ubuntu-22-04-x64")
-
-    # Build context for templates
+    # Extract config values from Pydantic model
+    name = config.name
+    do_config = config.digitalocean
+    region = do_config.region
+    size = do_config.size
+    image = do_config.image
+
+    # Load environment variables from file if provided
+    env_vars = {}
+    if env_file:
+        from xenfra_sdk.railpack_detector import RailpackDetector
+        detector = RailpackDetector()
+        with open(env_file) as f:
+            content = f.read()
+        parsed = detector.parse_env_content(content)
+        env_vars = {v.key: v.value for v in parsed}
+        console.print(f"   - Loaded [cyan]{len(env_vars)}[/cyan] variables from [cyan]{env_file}[/cyan]")
+
+    # Build context for templates (handle infrastructure)
+    # Note: Modern engine uses InfrastructureService models
     template_context = {
-        "database": config.get("database", {}).get("type"),
-        "db_user": config.get("database", {}).get("user"),
-        "db_password": config.get("database", {}).get("password"),
-        "db_name": config.get("database", {}).get("name"),
         "email": ctx.obj["engine"].get_user_info().email,
+        "mode": config.mode,
+        "env_vars": env_vars
     }
+    
+    # Map infrastructure for templates
+    for infra in config.infrastructure:
+        template_context[f"include_{infra.type}"] = True
+        # For backwards compatibility with original simple logic
+        if infra.type == "postgres":
+            template_context["database"] = "postgres"
+            template_context["db_user"] = infra.env_vars.get("user", "db_user")
+            template_context["db_password"] = infra.env_vars.get("password", "db_password")
+            template_context["db_name"] = infra.env_vars.get("name", "app_db")
+
+    # Handle services (microservices or single)
+    if config.services:
+        template_context["services"] = config.services
+        # Use first service framework as primary
+        primary_service = config.services[0]
+        template_context["framework"] = primary_service.framework
+        template_context["port"] = primary_service.port
+        console.print(f"   - Framework: [cyan]{primary_service.framework}[/cyan]")
 
     console.print(f"   - App Name: [cyan]{name}[/cyan]")
     console.print(f"   - Region: [cyan]{region}[/cyan], Size: [cyan]{size}[/cyan]")
-    if template_context.get("database"):
-        console.print(f"   - Including Database: [cyan]{template_context['database']}[/cyan]")
+    if config.infrastructure:
+        infra_names = [i.type for i in config.infrastructure]
+        console.print(f"   - Including Infrastructure: [cyan]{', '.join(infra_names)}[/cyan]")
 
+    if dry_run:
+        console.print("\n[bold yellow]🧪 DRY RUN MODE - Generating assets only[/bold yellow]")
+    
     if not click.confirm(f"\n   Ready to deploy '{name}' from 'xenfra.yaml'?"):
         return
 
     with console.status("[bold green]Deployment in progress...[/bold green]"):
         result = engine.deploy_server(
-            name=name, region=region, size=size, image=image, logger=console.log, **template_context
+            name=name, 
+            region=region, 
+            size=size, 
+            image=image, 
+            logger=console.log, 
+            verify_local=not skip_local,
+            dry_run=dry_run,
+            **template_context
         )
 
-    console.print("\n[bold green]✅ DEPLOYMENT COMPLETE![/bold green]")
-    console.print(result)
+    if dry_run:
+        console.print("\n[bold yellow]🧪 DRY RUN COMPLETE[/bold yellow]")
+        if isinstance(result, dict) and "assets" in result:
+            console.print("\n[bold cyan]Generated Assets:[/bold cyan]")
+            for filename, content in result["assets"].items():
+                console.print(f"\n[bold]{filename}:[/bold]")
+                console.print(f"[dim]{content[:500]}{'...' if len(content) > 500 else ''}[/dim]")
+    else:
+        console.print("\n[bold green]✅ DEPLOYMENT COMPLETE![/bold green]")
+        console.print(result)
 
 
 @main.command(name="list")

xenfra_sdk/client.py

@@ -3,11 +3,13 @@ import os
 import httpx
 
 from .exceptions import AuthenticationError, XenfraAPIError, XenfraError
+from .resources.activity import ActivityManager
+from .resources.build import BuildManager
 from .resources.deployments import DeploymentsManager
 from .resources.files import FilesManager
 from .resources.intelligence import IntelligenceManager
 from .resources.projects import ProjectsManager
-
+from .resources.sandbox import SandboxManager
 
 class XenfraClient:
     def __init__(self, token: str = None, api_url: str = None):
@@ -36,7 +38,9 @@ class XenfraClient:
         self.deployments = DeploymentsManager(self)
         self.intelligence = IntelligenceManager(self)
         self.files = FilesManager(self)
-
+        self.activity = ActivityManager(self)
+        self.build = BuildManager(self)  # 3-tier dry-run validation
+        self.sandbox = SandboxManager(self)
 
     def _request(self, method: str, path: str, json: dict = None) -> httpx.Response:
         """Internal method to handle all HTTP requests."""

xenfra_sdk/constants.py

@@ -0,0 +1,26 @@
+"""
+Centralized registry for Xenfra SDK defaults and constants.
+Follows XENFRA_PROTOCOL.md by eliminating hardcoded strings in logic.
+"""
+
+from typing import Final
+
+# Infrastructure Defaults
+DEFAULT_REGION: Final[str] = "nyc3"
+DEFAULT_SIZE: Final[str] = "s-1vcpu-1gb"
+DEFAULT_OS: Final[str] = "ubuntu-22-04-x64"
+DEFAULT_SSH_KEY_PATH: Final[str] = "~/.ssh/id_rsa"
+DEFAULT_SSH_PUB_KEY_PATH: Final[str] = "~/.ssh/id_rsa.pub"
+
+# Tiered Droplet Sizing (Microservice Orchestration)
+SIZE_LIGHT: Final[str] = "s-1vcpu-2gb"      # 1-2 services
+SIZE_MEDIUM: Final[str] = "s-2vcpu-4gb"     # 3-5 services
+SIZE_HEAVY: Final[str] = "s-4vcpu-8gb"      # 6+ services
+
+# Framework Defaults
+DEFAULT_PYTHON_VERSION: Final[str] = "3.11-slim"
+DEFAULT_NODE_VERSION: Final[str] = "18-slim"
+
+# Protocol Limits
+MAX_SERVICES_PER_PROJECT: Final[int] = 20
+DEFAULT_PORT_RANGE_START: Final[int] = 8000

xenfra_sdk/db/session.py

@@ -3,11 +3,11 @@
 import os
 from pathlib import Path
 
+import click
 from sqlmodel import Session, SQLModel, create_engine
 
 # Get the app directory for the current user
-# Use ~/.xenfra for cross-platform simplicity and to avoid 'click' dependency in SDK
-app_dir = Path.home() / ".xenfra"
+app_dir = Path(click.get_app_dir("xenfra"))
 app_dir.mkdir(parents=True, exist_ok=True)
 db_path = app_dir / "xenfra.db"
 
@@ -18,7 +18,12 @@ DATABASE_URL = os.getenv("DATABASE_URL", f"sqlite:///{db_path}")
 # Only echo SQL in development (set SQL_ECHO=1 to enable)
 SQL_ECHO = os.getenv("SQL_ECHO", "0") == "1"
 
-engine = create_engine(DATABASE_URL, echo=SQL_ECHO)
+engine = create_engine(
+    DATABASE_URL,
+    echo=SQL_ECHO,
+    pool_pre_ping=True,
+    pool_recycle=300
+)
 
 
 def create_db_and_tables():