xenfra-sdk 0.1.0__py3-none-any.whl

xenfra_sdk/__init__.py

@@ -0,0 +1,21 @@
+# This file makes src/xenfra_sdk a Python package.
+
+from .client import XenfraClient
+from .exceptions import AuthenticationError, XenfraAPIError, XenfraError
+from .models import (
+    CodebaseAnalysisResponse,
+    DiagnosisResponse,
+    PatchObject,
+    ProjectRead,
+)
+
+__all__ = [
+    "XenfraClient",
+    "XenfraError",
+    "AuthenticationError",
+    "XenfraAPIError",
+    "DiagnosisResponse",
+    "CodebaseAnalysisResponse",
+    "PatchObject",
+    "ProjectRead",
+]

xenfra_sdk/cli/main.py

@@ -0,0 +1,226 @@
+import click
+import yaml
+from rich.console import Console
+from rich.table import Table
+from xenfra_sdk import dockerizer
+from xenfra_sdk.db.session import create_db_and_tables
+from xenfra_sdk.engine import DeploymentError, InfraEngine
+
+console = Console()
+
+
+@click.group()
+@click.pass_context
+def main(ctx):
+    """
+    Xenfra CLI: A 'Zen Mode' infrastructure engine for Python developers.
+    """
+    try:
+        create_db_and_tables()
+        ctx.obj = {"engine": InfraEngine()}
+        user_info = ctx.obj["engine"].get_user_info()
+        console.print(
+            f"[bold underline]Xenfra CLI[/bold underline] - Logged in as [green]{user_info.email}[/green]"
+        )
+    except Exception as e:
+        console.print(f"[bold red]CRITICAL ERROR:[/bold red] Failed to initialize engine: {e}")
+        exit(1)
+
+
+@main.command()
+@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.")
+
+    use_db = click.confirm(
+        "\n   Would you like to add a PostgreSQL database to your deployment?", default=False
+    )
+
+    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)
+
+    console.print("\n[bold green]✅ SUCCESS![/bold green]")
+    console.print("   - Created [cyan]xenfra.yaml[/cyan].")
+    console.print("\n   Next step: Review the configuration and run 'xenfra deploy'!")
+
+
+@main.command()
+@click.pass_context
+def deploy(ctx):
+    """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:
+        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
+    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,
+    }
+
+    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 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
+        )
+
+    console.print("\n[bold green]✅ DEPLOYMENT COMPLETE![/bold green]")
+    console.print(result)
+
+
+@main.command(name="list")
+@click.option("--refresh", is_flag=True, help="Sync with the cloud provider before listing.")
+@click.pass_context
+def list_projects(ctx, refresh):
+    """Lists all active Xenfra projects from the local database."""
+    engine = ctx.obj["engine"]
+
+    if refresh:
+        console.print("\n[bold]📡 SYNCING WITH CLOUD PROVIDER...[/bold]")
+        with console.status("Calling DigitalOcean API and reconciling state..."):
+            projects = engine.sync_with_provider()
+    else:
+        console.print("\n[bold]⚡️ LISTING PROJECTS FROM LOCAL DATABASE[/bold]")
+        projects = engine.list_projects_from_db()
+
+    if not projects:
+        console.print(
+            "[yellow]   No active projects found. Run 'xenfra deploy' to create one.[/yellow]"
+        )
+    else:
+        table = Table(show_header=True, header_style="bold magenta")
+        table.add_column("Droplet ID", style="dim", width=12)
+        table.add_column("Name", style="cyan")
+        table.add_column("IP Address", style="green")
+        table.add_column("Status")
+        table.add_column("Region")
+        table.add_column("Size")
+        for p in projects:
+            table.add_row(str(p.droplet_id), p.name, p.ip_address, p.status, p.region, p.size)
+        console.print(table)
+
+
+@main.command(name="logs")
+@click.pass_context
+def logs(ctx):
+    """Streams real-time logs from a deployed project."""
+    engine = ctx.obj["engine"]
+
+    console.print("\n[bold yellow]📡 SELECT A PROJECT TO STREAM LOGS[/bold yellow]")
+    projects = engine.list_projects_from_db()
+
+    if not projects:
+        console.print("[yellow]   No active projects to stream logs from.[/yellow]")
+        return
+
+    project_map = {str(i + 1): p for i, p in enumerate(projects)}
+    for k, p in project_map.items():
+        console.print(f"   [{k}] {p.name} ({p.ip_address})")
+
+    choice_key = click.prompt(
+        "\n   Select Project (0 to cancel)",
+        type=click.Choice(["0"] + list(project_map.keys())),
+        show_choices=False,
+    )
+    if choice_key == "0":
+        return
+
+    target = project_map[choice_key]
+
+    try:
+        console.print(
+            f"\n[bold green]-- Attaching to logs for {target.name} (Press Ctrl+C to stop) --[/bold green]"
+        )
+        engine.stream_logs(target.droplet_id)
+    except DeploymentError as e:
+        console.print(f"[bold red]ERROR:[/bold red] {e.message}")
+    except KeyboardInterrupt:
+        console.print("\n[bold yellow]-- Log streaming stopped by user. --[/bold yellow]")
+    except Exception as e:
+        console.print(f"[bold red]An unexpected error occurred:[/bold red] {e}")
+
+
+@main.command()
+@click.pass_context
+def destroy(ctx):
+    """Destroys a deployed project."""
+    engine = ctx.obj["engine"]
+
+    console.print("\n[bold red]🧨 SELECT A PROJECT TO DESTROY[/bold red]")
+    projects = engine.list_projects_from_db()
+
+    if not projects:
+        console.print("[yellow]   No active projects to destroy.[/yellow]")
+        return
+
+    project_map = {str(i + 1): p for i, p in enumerate(projects)}
+    for k, p in project_map.items():
+        console.print(f"   [{k}] {p.name} ({p.ip_address})")
+
+    choice_key = click.prompt(
+        "\n   Select Project to DESTROY (0 to cancel)",
+        type=click.Choice(["0"] + list(project_map.keys())),
+        show_choices=False,
+    )
+    if choice_key == "0":
+        return
+
+    target = project_map[choice_key]
+
+    if click.confirm(
+        f"   Are you SURE you want to permanently delete [red]{target.name}[/red] (Droplet ID: {target.droplet_id})? This action cannot be undone."
+    ):
+        with console.status(f"💥 Destroying {target.name}..."):
+            engine.destroy_server(target.droplet_id)
+        console.print(f"[green]   Project '{target.name}' has been destroyed.[/green]")
+
+
+if __name__ == "__main__":
+    main()

xenfra_sdk/client.py

@@ -0,0 +1,69 @@
+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 = "http://localhost:8000"):
+        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
+            detail = e.response.json().get("detail", e.response.text)
+            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/client_with_hooks.py

@@ -0,0 +1,275 @@
+"""
+Enhanced XenfraClient with context management and lifecycle hooks.
+"""
+import logging
+import os
+from typing import Any, Callable, Optional
+
+import httpx
+
+from .exceptions import AuthenticationError, XenfraAPIError, XenfraError
+from .resources.deployments import DeploymentsManager
+from .resources.intelligence import IntelligenceManager
+from .resources.projects import ProjectsManager
+
+logger = logging.getLogger(__name__)
+
+
+class RequestHooks:
+    """Container for request lifecycle hooks."""
+
+    def __init__(self):
+        self.before_request: list[Callable] = []
+        self.after_request: list[Callable] = []
+        self.on_error: list[Callable] = []
+        self.on_retry: list[Callable] = []
+
+    def register_before_request(self, callback: Callable):
+        """Register a callback to run before each request."""
+        self.before_request.append(callback)
+
+    def register_after_request(self, callback: Callable):
+        """Register a callback to run after each request."""
+        self.after_request.append(callback)
+
+    def register_on_error(self, callback: Callable):
+        """Register a callback to run on request errors."""
+        self.on_error.append(callback)
+
+    def register_on_retry(self, callback: Callable):
+        """Register a callback to run on request retries."""
+        self.on_retry.append(callback)
+
+
+class XenfraClient:
+    """
+    Xenfra SDK client with context manager support and lifecycle hooks.
+
+    Usage:
+        # With context manager (recommended):
+        with XenfraClient(token=token) as client:
+            projects = client.projects.list()
+
+        # Without context manager (manual cleanup):
+        client = XenfraClient(token=token)
+        try:
+            projects = client.projects.list()
+        finally:
+            client.close()
+
+        # With hooks:
+        client = XenfraClient(token=token)
+        client.hooks.register_before_request(lambda req: print(f"Calling {req.url}"))
+        client.hooks.register_after_request(lambda req, resp: print(f"Status: {resp.status_code}"))
+    """
+
+    def __init__(
+        self,
+        token: str = None,
+        api_url: str = "http://localhost:8000",
+        timeout: float = 30.0,
+        max_retries: int = 3,
+        enable_logging: bool = False,
+    ):
+        """
+        Initialize Xenfra client.
+
+        Args:
+            token: API authentication token
+            api_url: Base URL for Xenfra API
+            timeout: Request timeout in seconds
+            max_retries: Maximum number of retries for failed requests
+            enable_logging: Enable request/response logging
+        """
+        self.api_url = api_url
+        self._token = token or os.getenv("XENFRA_TOKEN")
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self.enable_logging = enable_logging
+
+        if not self._token:
+            raise AuthenticationError(
+                "No API token provided. Pass it to the client or set XENFRA_TOKEN."
+            )
+
+        # Initialize hooks
+        self.hooks = RequestHooks()
+
+        # Create HTTP client with retry logic
+        transport = httpx.HTTPTransport(retries=max_retries)
+        self._http_client = httpx.Client(
+            base_url=self.api_url,
+            headers={
+                "Authorization": f"Bearer {self._token}",
+                "Content-Type": "application/json",
+                "User-Agent": "Xenfra-SDK/0.2.0",
+            },
+            timeout=timeout,
+            transport=transport,
+        )
+
+        # Track if client is closed
+        self._closed = False
+
+        # Initialize resource managers
+        self.projects = ProjectsManager(self)
+        self.deployments = DeploymentsManager(self)
+        self.intelligence = IntelligenceManager(self)
+
+        logger.debug(f"XenfraClient initialized for {api_url}")
+
+    def _request(self, method: str, path: str, json: dict = None) -> httpx.Response:
+        """
+        Internal method to handle all HTTP requests with hooks.
+
+        Args:
+            method: HTTP method (GET, POST, etc.)
+            path: API endpoint path
+            json: Optional JSON body
+
+        Returns:
+            HTTP response
+
+        Raises:
+            XenfraAPIError: For API errors (4xx, 5xx)
+            XenfraError: For connection/network errors
+        """
+        if self._closed:
+            raise XenfraError("Client is closed. Create a new client or use context manager.")
+
+        # Build request context
+        request_context = {
+            "method": method,
+            "path": path,
+            "json": json,
+            "url": f"{self.api_url}{path}",
+        }
+
+        # Run before_request hooks
+        for hook in self.hooks.before_request:
+            try:
+                hook(request_context)
+            except Exception as e:
+                logger.warning(f"before_request hook failed: {e}")
+
+        # Log request if enabled
+        if self.enable_logging or logger.isEnabledFor(logging.DEBUG):
+            logger.debug(f"{method} {path}")
+            if json:
+                logger.debug(f"Request body: {json}")
+
+        try:
+            # Make the request
+            response = self._http_client.request(method, path, json=json)
+            response.raise_for_status()
+
+            # Log response if enabled
+            if self.enable_logging or logger.isEnabledFor(logging.DEBUG):
+                logger.debug(f"Response: {response.status_code}")
+
+            # Run after_request hooks
+            for hook in self.hooks.after_request:
+                try:
+                    hook(request_context, response)
+                except Exception as e:
+                    logger.warning(f"after_request hook failed: {e}")
+
+            return response
+
+        except httpx.HTTPStatusError as e:
+            # API error (4xx, 5xx)
+            detail = e.response.json().get("detail", e.response.text) if e.response else str(e)
+
+            # Run error hooks
+            error_context = {**request_context, "error": e, "response": e.response}
+            for hook in self.hooks.on_error:
+                try:
+                    hook(error_context)
+                except Exception as hook_error:
+                    logger.warning(f"on_error hook failed: {hook_error}")
+
+            # Log error
+            logger.error(f"{method} {path} failed: {e.response.status_code if e.response else 'unknown'}")
+
+            raise XenfraAPIError(
+                status_code=e.response.status_code if e.response else 500,
+                detail=detail
+            ) from e
+
+        except httpx.RequestError as e:
+            # Connection/network error
+            error_context = {**request_context, "error": e}
+            for hook in self.hooks.on_error:
+                try:
+                    hook(error_context)
+                except Exception as hook_error:
+                    logger.warning(f"on_error hook failed: {hook_error}")
+
+            logger.error(f"{method} {path} failed: {e}")
+            raise XenfraError(f"HTTP request failed: {e}") from e
+
+    def close(self):
+        """Close the HTTP client and cleanup resources."""
+        if not self._closed:
+            logger.debug("Closing XenfraClient")
+            self._http_client.close()
+            self._closed = True
+
+    def __enter__(self):
+        """Context manager entry."""
+        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 not self._closed:
+            logger.warning("XenfraClient was not properly closed. Use 'with' statement or call close().")
+            self.close()
+
+    def __repr__(self):
+        """String representation."""
+        status = "closed" if self._closed else "open"
+        return f"<XenfraClient(api_url='{self.api_url}', status='{status}')>"
+
+
+# Example hooks for common use cases
+
+def logging_hook_before(request_context):
+    """Example: Log all requests."""
+    print(f"→ {request_context['method']} {request_context['url']}")
+
+
+def logging_hook_after(request_context, response):
+    """Example: Log all responses."""
+    print(f"← {response.status_code} {request_context['url']}")
+
+
+def error_notification_hook(error_context):
+    """Example: Send notifications on errors."""
+    # Could send to Sentry, DataDog, etc.
+    print(f"⚠️  API Error: {error_context['url']} - {error_context['error']}")
+
+
+def rate_limit_tracker_hook(request_context, response):
+    """Example: Track rate limits."""
+    remaining = response.headers.get("X-RateLimit-Remaining")
+    if remaining:
+        print(f"Rate limit remaining: {remaining}")
+
+
+def request_timing_hook(request_context):
+    """Example: Track request timing."""
+    import time
+    request_context["start_time"] = time.time()
+
+
+def response_timing_hook(request_context, response):
+    """Example: Calculate request duration."""
+    import time
+    if "start_time" in request_context:
+        duration = time.time() - request_context["start_time"]
+        print(f"Request took {duration:.3f}s")

xenfra_sdk/config.py

@@ -0,0 +1,26 @@
+# src/xenfra/config.py
+
+
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_file=".env", extra="ignore")
+
+    SECRET_KEY: str
+    ENCRYPTION_KEY: str
+
+    GITHUB_CLIENT_ID: str
+    GITHUB_CLIENT_SECRET: str
+    GITHUB_REDIRECT_URI: str
+    GITHUB_WEBHOOK_SECRET: str
+
+    DO_CLIENT_ID: str
+    DO_CLIENT_SECRET: str
+    DO_REDIRECT_URI: str
+
+    # Frontend redirect for successful OAuth (e.g., /dashboard/connections)
+    FRONTEND_OAUTH_REDIRECT_SUCCESS: str = "/dashboard/connections"
+
+
+settings = Settings()

xenfra_sdk/db/models.py

@@ -0,0 +1,27 @@
+# src/xenfra/db/models.py
+
+from typing import Optional
+
+from sqlmodel import Field, SQLModel
+
+# --- Project Model for CLI state ---
+
+
+class Project(SQLModel, table=True):
+    """
+    Project model storing deployment state in the SDK's local database.
+
+    Note: user_id references a User in the SSO service database.
+    In a microservices architecture, we store the ID but don't enforce
+    a foreign key constraint across service boundaries.
+    """
+    id: Optional[int] = Field(default=None, primary_key=True)
+    droplet_id: int = Field(unique=True, index=True)
+    name: str
+    ip_address: str
+    status: str
+    region: str
+    size: str
+    # user_id is a reference to User.id in the SSO service database
+    # No foreign key constraint since databases are separate in microservices architecture
+    user_id: int = Field(index=True)  # Index for query performance

xenfra_sdk/db/session.py

@@ -0,0 +1,30 @@
+# src/xenfra/db/session.py
+
+import os
+from pathlib import Path
+
+import click
+from sqlmodel import Session, SQLModel, create_engine
+
+# Get the app directory for the current user
+app_dir = Path(click.get_app_dir("xenfra"))
+app_dir.mkdir(parents=True, exist_ok=True)
+db_path = app_dir / "xenfra.db"
+
+# For now, we will use a simple SQLite database for ease of setup.
+# In production, this should be a PostgreSQL database URL from environment variables.
+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)
+
+
+def create_db_and_tables():
+    SQLModel.metadata.create_all(engine)
+
+
+def get_session():
+    with Session(engine) as session:
+        yield session