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

xenfra_sdk/orchestrator.py

@@ -12,7 +12,18 @@ from typing import Callable, Dict, List, Optional
 import yaml
 
 from .manifest import ServiceDefinition, load_services_from_xenfra_yaml
-from . import dockerizer
+from . import constants
+from .governance import get_resource_limits
+from .blueprints.factory import render_blueprint
+from .blueprints.schema import (
+    ComposeModel, 
+    ServiceDetail, 
+    DeployModel,
+    DeployResourcesModel,
+    ResourceLimitsModel,
+    ResourceReservationsModel
+)
+from .models.context import DeploymentContext
 
 
 class ServiceOrchestrator:
@@ -24,7 +35,7 @@ class ServiceOrchestrator:
     - multi-droplet: Each service on separate droplets with private networking
     """
     
-    def __init__(self, engine, services: List[ServiceDefinition], project_name: str, mode: str = "single-droplet", file_manifest: List[dict] = None):
+    def __init__(self, engine, services: List[ServiceDefinition], project_name: str, mode: str = "single-droplet", file_manifest: List[dict] = None, tier: str = "FREE"):
         """
         Initialize the orchestrator.
         
@@ -34,6 +45,7 @@ class ServiceOrchestrator:
             project_name: Name of the project
             mode: Deployment mode (single-droplet or multi-droplet)
             file_manifest: List of files to be uploaded (delta upload)
+            tier: User tier for resource governance
         """
         self.engine = engine
         self.services = services
@@ -42,6 +54,7 @@ class ServiceOrchestrator:
         self.file_manifest = file_manifest or []
         self.token = engine.token
         self.manager = engine.manager
+        self.tier = tier
     
     def deploy(self, logger: Callable = print, **kwargs) -> Dict:
         """
@@ -89,7 +102,8 @@ class ServiceOrchestrator:
         logger(f"\n[dim]Recommended droplet size: {size}[/dim]")
         
         # Step 2: Generate multi-service docker-compose.yml
-        compose_content = self._generate_docker_compose()
+        global_env = kwargs.get("env_vars") or {}
+        compose_content = self._generate_docker_compose(global_env=global_env)
         logger(f"[dim]Generated docker-compose.yml ({len(compose_content)} bytes)[/dim]")
         
         # Step 3: Generate Caddyfile for path-based routing
@@ -117,7 +131,7 @@ class ServiceOrchestrator:
             explicit_args = [
                 "name", "size", "framework", "port", "is_dockerized", 
                 "entrypoint", "multi_service_compose", "multi_service_caddy", 
-                "services", "logger", "extra_assets"
+                "services", "logger", "extra_assets", "tier"
             ]
             for arg in explicit_args:
                 safe_kwargs.pop(arg, None)
@@ -155,7 +169,7 @@ class ServiceOrchestrator:
                     
                     # Find the file in manifest and get its content
                     existing_finfo = next(f for f in self.file_manifest if f.get("path") in [dockerfile_name, f"./{dockerfile_name}", f"{svc.path}/Dockerfile" if (svc.path and svc.path != ".") else "Dockerfile"])
-                    from .engine import DeploymentError
+                    from .exceptions import DeploymentError
                     if not self.engine.get_file_content:
                         raise DeploymentError("Cannot inject deps into existing Dockerfile: get_file_content not available", stage="Asset Generation")
                     
@@ -180,50 +194,118 @@ class ServiceOrchestrator:
                     extra_assets[dockerfile_name] = content
                     continue
 
-                # Determine command (same logic as _generate_docker_compose)
-                command = svc.command
-                if not command and svc.entrypoint:
-                    if svc.framework == "fastapi":
-                        command = f"uvicorn {svc.entrypoint} --host 0.0.0.0 --port {svc.port}"
-                    elif svc.framework == "flask":
-                        command = f"gunicorn {svc.entrypoint} -b 0.0.0.0:{svc.port}"
-                    elif svc.framework == "django":
-                        command = f"gunicorn {svc.entrypoint} --bind 0.0.0.0:{svc.port}"
+                # Filter file_manifest for this specific service path
+                service_manifest = []
+                if self.file_manifest:
+                    prefix = f"{svc.path}/" if (svc.path and svc.path != ".") else ""
+                    
+                    # Critical files that need content hydration for blueprint detection
+                    CRITICAL_CONFIGS = {
+                        "package.json", "package-lock.json",
+                        "next.config.js", "next.config.ts", "next.config.mjs",
+                        "nuxt.config.js", "nuxt.config.ts",
+                        "vite.config.js", "vite.config.ts",
+                        "requirements.txt", "pyproject.toml", "Pipfile",
+                        "go.mod", "Cargo.toml", "deno.json"
+                    }
+
+                    for f in self.file_manifest:
+                        fpath = f.get("path", "")
+                        if fpath.startswith(prefix):
+                            # Strip prefix for the blueprint logic
+                            new_f = f.copy()
+                            new_f["path"] = fpath[len(prefix):]
+                            
+                            # Hydrate content for critical config files
+                            # This allows RailpackBlueprint to inspect dependencies (e.g. detect "next" in package.json)
+                            if new_f["path"] in CRITICAL_CONFIGS and "content" not in new_f and self.engine.get_file_content:
+                                try:
+                                    logger(f"   - [Zen Mode] Hydrating manifest content for {new_f['path']}...")
+                                    content_bytes = self.engine.get_file_content(f.get("sha"))
+                                    if content_bytes:
+                                        new_f["content"] = content_bytes.decode("utf-8", errors="ignore")
+                                except Exception as e:
+                                    logger(f"   [yellow]Warning: Failed to hydrate {new_f['path']}: {e}[/yellow]")
+
+                            service_manifest.append(new_f)
+
+                # Protocol Compliance: Use Blueprint Factory instead of legacy dockerizer
+                # Build context for this specific service
+                # ZEN DEBUG: Log framework being used for Dockerfile generation
+                # Fix: Do not default to 'python'. Let factory.py resolve it (supports Railpack fallback)
+                framework_to_use = svc.framework 
+                logger(f"   - [Blueprint] Generating Dockerfile for {svc.name} (framework={framework_to_use})")
                 
-                # Render assets using dockerizer
-                ctx = {
-                    "framework": svc.framework,
-                    "port": svc.port,
-                    "command": command,
-                    "missing_deps": svc.missing_deps,
-                    # Pass through other potential context
-                    "database": None, 
-                }
-                assets = dockerizer.render_deployment_assets(ctx)
+                # Resolve source path for Railpack analysis
+                # Fixes "User Environment Leak" where Railpack defaults to CWD if no source_path is provided
+                source_path = None
+                local_root = self.engine.context.get('local_source_path')
+                if local_root:
+                    if svc.path and svc.path != ".":
+                         source_path = str(Path(local_root) / svc.path)
+                    else:
+                         source_path = local_root
+                
+                ctx = DeploymentContext(
+                    project_name=f"{self.project_name}-{svc.name}",
+                    email=self.engine.get_user_info().email,
+                    framework=framework_to_use,
+                    port=svc.port,
+                    entrypoint=svc.entrypoint,
+                    env_vars={**(svc.env or {}), **global_env},
+                    tier=self.tier,
+                    file_manifest=service_manifest,
+                    source_path=source_path  # Pass explicit source path
+                )
+                
+                assets = render_blueprint(ctx.model_dump())
                 if "Dockerfile" in assets:
                     extra_assets[dockerfile_name] = assets["Dockerfile"]
+
             
+            # Consolidate all environment variables into a single .env file
+            # This ensures they are available during 'docker build' for Next.js
+            master_env = {**(global_env or {})}
+            for svc in self.services:
+                if svc.env:
+                    master_env.update(svc.env)
+            
+            if master_env:
+                # Use double quotes for values to handle spaces and special chars safely
+                env_content = "\n".join([f'{k}="{v}"' for k, v in master_env.items()])
+                extra_assets[".env"] = env_content
+                logger(f"   - [Zen Mode] Consolidated {len(master_env)} variables into .env asset")
+
             if extra_assets:
-                logger(f"[dim]Generated {len(extra_assets)} service Dockerfiles[/dim]")
+                logger(f"[dim]Generated {len(extra_assets)} deployment assets[/dim]")
 
             deployment_result = self.engine.deploy_server(
                 name=self.project_name,
                 size=size,
                 framework=primary_service.framework,
-                port=80,  # Caddy listens on 80
+                port=80,  # Caddy always listens on 80 for the gateway
                 is_dockerized=True,
-                entrypoint=None,  # We'll use docker-compose
-                # Pass multi-service config
+                entrypoint=None,
                 multi_service_compose=compose_content,
                 multi_service_caddy=caddy_content,
-                extra_assets=extra_assets,  # Pass generated Dockerfiles
+                extra_assets=extra_assets,
                 services=self.services,
                 logger=logger,
+                tier=self.tier,
                 **safe_kwargs
             )
             
-            result["droplet"] = deployment_result.get("droplet")
-            result["url"] = f"http://{deployment_result.get('ip_address')}"
+            # ZEN MODE: Propagate Dry Run
+            if isinstance(deployment_result, dict) and deployment_result.get("status") == "DRY_RUN":
+                return deployment_result
+
+            if isinstance(deployment_result, dict):
+                result["droplet"] = deployment_result.get("droplet")
+                result["url"] = f"http://{deployment_result.get('ip_address')}"
+            else:
+                # DigitalOcean Droplet object
+                result["droplet"] = deployment_result
+                result["url"] = f"http://{deployment_result.ip_address}"
             
             # Step 5: Health check all services
             if result["droplet"]:
@@ -254,82 +336,107 @@ class ServiceOrchestrator:
     
     def _calculate_droplet_size(self) -> str:
         """
-        Recommend droplet size based on number of services.
-        
-        Guidelines:
-        - 1-2 services: s-1vcpu-2gb ($12/month)
-        - 3-5 services: s-2vcpu-4gb ($24/month)
-        - 6+ services: s-4vcpu-8gb ($48/month)
+        Recommend droplet size based on number of services using constants.
         """
+        from . import constants
         service_count = len(self.services)
         
         if service_count <= 2:
-            return "s-1vcpu-2gb"
+            return constants.SIZE_LIGHT
         elif service_count <= 5:
-            return "s-2vcpu-4gb"
+            return constants.SIZE_MEDIUM
         else:
-            return "s-4vcpu-8gb"
+            return constants.SIZE_HEAVY
     
-    def _generate_docker_compose(self) -> str:
+    def _generate_docker_compose(self, global_env: Dict[str, str] = None) -> str:
         """
-        Generate docker-compose.yml for all services.
-        
-        Each service gets:
-        - Its own container
-        - Port mapping
-        - Environment variables
-        - Restart policy
+        Generate docker-compose.yml using ComposeModel Pydantic schema.
         """
-        services_config = {}
+        services_map = {}
         
         for svc in self.services:
-            # Build command based on framework and entrypoint
+            # Resolve source path for Railpack analysis
+            source_path = None
+            local_root = self.engine.context.get('local_source_path')
+            if local_root:
+                if svc.path and svc.path != ".":
+                     source_path = str(Path(local_root) / svc.path)
+                else:
+                     source_path = local_root
+
+            # Build context for this service to get protocol-compliant command/limits
+            temp_ctx = DeploymentContext(
+                project_name=svc.name,
+                email="admin@xenfra.tech",
+                framework=svc.framework,
+                port=svc.port,
+                entrypoint=svc.entrypoint,
+                tier=self.tier,
+                source_path=source_path  # Pass explicit source path
+            )
+            
+            # Resolve command if not explicit (Zen Mode)
             command = svc.command
             if not command and svc.entrypoint:
-                if svc.framework == "fastapi":
-                    command = f"uvicorn {svc.entrypoint} --host 0.0.0.0 --port {svc.port}"
-                elif svc.framework == "flask":
-                    command = f"gunicorn {svc.entrypoint} -b 0.0.0.0:{svc.port}"
-                elif svc.framework == "django":
-                    command = f"gunicorn {svc.entrypoint} --bind 0.0.0.0:{svc.port}"
-            
-            service_entry = {
-                "build": {
-                    "context": svc.path or ".",
-                    "dockerfile": f"Dockerfile.{svc.name}"
-                },
-                "ports": [f"{svc.port}:{svc.port}"],
-                "restart": "unless-stopped",
-            }
-            
-            if command:
-                service_entry["command"] = command
-            
-            if svc.env:
-                service_entry["environment"] = svc.env
+                # Use standard blueprint-derived command logic
+                from .blueprints.python import PythonBlueprint
+                from .blueprints.node import NodeBlueprint
+                # This is still a bit coupled, but better than naked if-elifs
+                if svc.framework in ("fastapi", "flask", "django"):
+                    command = PythonBlueprint(temp_ctx.model_dump())._get_default_command()
+                elif svc.framework == "nodejs":
+                    command = NodeBlueprint(temp_ctx.model_dump())._get_default_command()
+
+            # Create ServiceDetail model
+            # Create ServiceDetail model
+            # ZEN FIX: Map flat ResourceLimits to nested DeployModel
+            tier_limits = get_resource_limits(self.tier)
+            service_detail = ServiceDetail(
+                build=svc.path or ".",
+                ports=[f"{svc.port}:{svc.port}"],
+                env_file=[".env"],
+                command=command,
+                deploy=DeployModel(
+                    resources=DeployResourcesModel(
+                        limits=ResourceLimitsModel(
+                            memory=tier_limits.memory,
+                            cpus=tier_limits.cpus
+                        ),
+                        reservations=ResourceReservationsModel(
+                            memory=tier_limits.memory_reserved,
+                            cpus=tier_limits.cpus_reserved
+                        )
+                    )
+                )
+            )
             
-            services_config[svc.name] = service_entry
-        
-        compose = {
-            "services": services_config
-        }
+            # Use specific Dockerfile if generated
+            if f"Dockerfile.{svc.name}" in [f.get("path") for f in self.file_manifest] or True: # Force for orchestrator
+                 service_detail.build_context = {
+                     "context": svc.path or ".",
+                     "dockerfile": f"Dockerfile.{svc.name}"
+                 }
+
+            services_map[svc.name] = service_detail
         
-        return yaml.dump(compose, default_flow_style=False, sort_keys=False)
+        compose = ComposeModel(services=services_map)
+        return yaml.dump(compose.model_dump(by_alias=True, exclude_none=True), sort_keys=False, default_flow_style=False)
     
     def _generate_caddyfile(self) -> str:
         """
         Generate Caddyfile for path-based routing.
         
         Routes:
-        - /<service-name>/* → localhost:<service-port> (Strip prefix)
+        - /<service-name>/* → <service-name>:<service-port> (Strip prefix)
         - / → Gateway info page (Exact match only)
         """
         routes = []
         
         for svc in self.services:
             # handle_path strips the prefix automatically
+            # Fix: Use service name instead of localhost for Docker networking
             route = f"""    handle_path /{svc.name}* {{
-        reverse_proxy localhost:{svc.port}
+        reverse_proxy {svc.name}:{svc.port}
     }}"""
             routes.append(route)
         
@@ -450,7 +557,8 @@ class ServiceOrchestrator:
                 logger(f"\n[cyan]Deploying {svc.name}...[/cyan]")
                 
                 # Generate single-service docker-compose
-                compose_content = self._generate_single_service_compose(svc)
+                global_env = kwargs.get("env_vars") or {}
+                compose_content = self._generate_single_service_compose(svc, global_env=global_env)
                 
                 try:
                     droplet_result = self.engine.deploy_server(
@@ -559,7 +667,7 @@ class ServiceOrchestrator:
         
         return result
     
-    def _generate_single_service_compose(self, svc: ServiceDefinition) -> str:
+    def _generate_single_service_compose(self, svc: ServiceDefinition, global_env: Dict[str, str] = None) -> str:
         """Generate docker-compose.yml for a single service."""
         command = svc.command
         if not command and svc.entrypoint:
@@ -574,13 +682,17 @@ class ServiceOrchestrator:
             "build": svc.path or ".",
             "ports": [f"{svc.port}:{svc.port}"],
             "restart": "unless-stopped",
+            # ZEN GAP FIX: Inject resource governance
+            "deploy": {
+                "resources": get_resource_limits(self.tier).model_dump(by_alias=True, exclude_none=True)
+            }
         }
         
         if command:
             service_entry["command"] = command
         
-        if svc.env:
-            service_entry["environment"] = svc.env
+        if svc.env or global_env:
+            service_entry["environment"] = {**(svc.env or {}), **(global_env or {})}
         
         compose = {
             "services": {
@@ -634,33 +746,45 @@ class ServiceOrchestrator:
         return None
 
 
-def get_orchestrator_for_project(engine, project_path: str = ".") -> Optional[ServiceOrchestrator]:
+def get_orchestrator_for_project(engine, project_path: str = ".", tier: str = "FREE") -> Optional[ServiceOrchestrator]:
     """
-    Factory function to create an orchestrator if xenfra.yaml has services.
+    Factory function to create an orchestrator if xenfra.yaml or auto-detection finds services.
     
     Args:
         engine: InfraEngine instance
         project_path: Path to project directory
+        tier: User tier for resource governance
     
     Returns:
-        ServiceOrchestrator if services found in xenfra.yaml, None otherwise
+        ServiceOrchestrator if services found, None otherwise
     """
-    from .manifest import load_services_from_xenfra_yaml, get_deployment_mode
+    from .manifest import load_services_from_xenfra_yaml, create_services_from_detected
+    from .detection import auto_detect_services
     
+    # 1. Try manifest first (User intent)
     services = load_services_from_xenfra_yaml(project_path)
+    yaml_path = Path(project_path) / "xenfra.yaml"
     
-    if services and len(services) > 1:
-        # Get project name from xenfra.yaml
-        yaml_path = Path(project_path) / "xenfra.yaml"
-        project_name = Path(project_path).name
-        mode = "single-droplet"
-        
-        if yaml_path.exists():
-            with open(yaml_path) as f:
+    project_name = Path(project_path).name
+    mode = "single-droplet"
+    
+    if yaml_path.exists():
+        with open(yaml_path) as f:
+            try:
                 data = yaml.safe_load(f)
-                project_name = data.get("project_name", project_name)
-                mode = data.get("mode", "single-droplet")
-        
-        return ServiceOrchestrator(engine, services, project_name, mode)
+                if data:
+                    project_name = data.get("project_name", project_name)
+                    mode = data.get("mode", "single-droplet")
+            except Exception:
+                pass
+    
+    # 2. Fallback to Autonomous Detection
+    if not services:
+        detected = auto_detect_services(project_path)
+        if detected and len(detected) > 1:
+            services = create_services_from_detected(detected)
+    
+    if services and len(services) > 1:
+        return ServiceOrchestrator(engine, services, project_name, mode, tier=tier)
     
     return None

xenfra_sdk/privacy.py

@@ -124,6 +124,17 @@ def scrub_logs(logs: str) -> str:
 
     return scrubbed_logs
 
+# Protocol Compliance Alias
+scrub_pii = scrub_logs
+
+
+def scrubbed_print(message: str, **kwargs) -> None:
+    """
+    Protocol-compliant print wrapper that scrubs PII before output.
+    Use this instead of raw print() throughout the SDK.
+    """
+    print(scrub_pii(str(message)), **kwargs)
+
 
 if __name__ == "__main__":
     # Example Usage

xenfra_sdk/protocol.py

@@ -0,0 +1,38 @@
+"""
+Xenfra Protocol Registry - Centralized constants for compliance with XENFRA_PROTOCOL.md.
+Eliminates hardcoded strings across SDK and Services.
+"""
+
+from typing import Final
+
+
+class ProtocolRegistry:
+    """
+    Structured registry for all strings and constants used in the Xenfra stack.
+    Satisfies Anti-Pattern #4 (No Hardcoded Constants).
+    """
+    
+    # Log Prefixes
+    LOG_PREFIX_INFRA_ENGINE: Final[str] = "[InfraEngine]"
+    LOG_PREFIX_ZEN_MODE: Final[str] = "[ZenMode]"
+    LOG_PREFIX_AUTO_MIGRATION: Final[str] = "[AutoMigration]"
+    
+    # Rate Limiting
+    RATE_LIMIT_USER_KEY: Final[str] = "user:{}"  # f-string template
+    
+    # Error Messages
+    MIGRATION_FAILED_MSG: Final[str] = "Auto-migration failed"
+    IDENTITY_SYNC_FAILED_MSG: Final[str] = "User identity cannot be synced"
+    
+    # Header Names
+    HEADER_USER_ID: Final[str] = "X-User-ID"
+    HEADER_USER_EMAIL: Final[str] = "X-User-Email"
+    HEADER_REQUEST_ID: Final[str] = "X-Request-ID"
+
+    # JWT Claims
+    JWT_ISSUER: Final[str] = "xenfra-sso"
+    JWT_AUDIENCE: Final[str] = "xenfra-api"
+
+    # Default Deployment Values
+    DEFAULT_DOCKER_IMAGE: Final[str] = "ubuntu-22-04-x64"
+    DEFAULT_PORT: Final[int] = 8000