xenfra 0.1.7__py3-none-any.whl → 0.1.8__py3-none-any.whl

xenfra/cli/main.py

@@ -0,0 +1,211 @@
+import click
+from rich.console import Console
+from rich.table import Table
+
+from xenfra.engine import InfraEngine
+from xenfra import dockerizer
+import yaml
+
+console = Console()
+
+@click.group()
+@click.pass_context
+def main(ctx):
+    """
+    Xenfra CLI: A 'Zen Mode' infrastructure engine for Python developers.
+    """
+    try:
+        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(f"\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/config.py

@@ -0,0 +1,24 @@
+# src/xenfra/config.py
+
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from typing import Optional
+
+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/db/models.py

@@ -0,0 +1,51 @@
+# src/xenfra/db/models.py
+
+from typing import List, Optional
+from sqlmodel import Field, Relationship, SQLModel
+
+class UserBase(SQLModel):
+    email: str = Field(unique=True, index=True)
+    is_active: bool = True
+
+class User(UserBase, table=True):
+    id: Optional[int] = Field(default=None, primary_key=True)
+    hashed_password: str
+
+    credentials: List["Credential"] = Relationship(back_populates="user")
+
+class UserCreate(UserBase):
+    password: str
+
+class UserRead(UserBase):
+    id: int
+
+class CredentialBase(SQLModel):
+    service: str # e.g., "digitalocean", "github"
+    encrypted_token: str
+    user_id: int = Field(foreign_key="user.id")
+    github_installation_id: Optional[int] = Field(default=None, index=True)
+
+class Credential(CredentialBase, table=True):
+    id: Optional[int] = Field(default=None, primary_key=True)
+    
+    user: User = Relationship(back_populates="credentials")
+
+class CredentialCreate(CredentialBase):
+    pass
+
+class CredentialRead(SQLModel):
+    id: int
+    service: str
+    user_id: int
+
+# --- Project Model for CLI state ---
+
+class Project(SQLModel, table=True):
+    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
+

xenfra/db/session.py

@@ -0,0 +1,17 @@
+# src/xenfra/db/session.py
+
+from sqlmodel import create_engine, Session, SQLModel
+import os
+
+# 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", "sqlite:///./xenfra.db")
+
+engine = create_engine(DATABASE_URL, echo=True)
+
+def create_db_and_tables():
+    SQLModel.metadata.create_all(engine)
+
+def get_session():
+    with Session(engine) as session:
+        yield session

xenfra/dependencies.py

@@ -0,0 +1,35 @@
+# src/xenfra/dependencies.py
+
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer
+from sqlmodel import Session, select
+
+from xenfra.db.session import get_session
+from xenfra.db.models import User
+from xenfra.security import decode_token
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/auth/token")
+
+def get_current_user(token: str = Depends(oauth2_scheme), session: Session = Depends(get_session)) -> User:
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    payload = decode_token(token)
+    if payload is None:
+        raise credentials_exception
+    
+    email: str = payload.get("sub")
+    if email is None:
+        raise credentials_exception
+    
+    user = session.exec(select(User).where(User.email == email)).first()
+    if user is None:
+        raise credentials_exception
+    return user
+
+def get_current_active_user(current_user: User = Depends(get_current_user)) -> User:
+    if not current_user.is_active:
+        raise HTTPException(status_code=400, detail="Inactive user")
+    return current_user

xenfra/dockerizer.py

@@ -1,12 +1,18 @@
 import os
 from pathlib import Path
+from jinja2 import Environment, FileSystemLoader
 
-def detect_framework():
+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(os.getcwd())
+    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 = []
     
@@ -27,10 +33,7 @@ def detect_framework():
             content = f.read()
             
             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
-            # For uvicorn/gunicorn, we usually want package.module (e.g., testdeploy.main)
             if module_name.startswith("src."):
-                # Strip the "src." prefix
                 module_name = module_name[4:]
 
 
@@ -42,112 +45,45 @@ def detect_framework():
     
     return None, None, None
 
-def generate_deployment_assets(context):
+def generate_templated_assets(context: dict):
     """
-    Creates Dockerfile, docker-compose.yml, and Caddyfile
-    if a web framework is detected.
+    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'}
     """
-    framework, port, cmd = detect_framework()
+    # Path to the templates directory
+    template_dir = Path(__file__).parent / "templates"
+    env = Environment(loader=FileSystemLoader(template_dir))
+
+    # Detect framework specifics
+    framework, port, command = detect_framework()
     if not framework:
+        print("Warning: No recognizable web framework detected.")
         return []
 
-    generated = []
-    print(f"   ✨ Web framework detected: {framework.upper()}. Generating deployment assets...")
-
-    # --- 1. DOCKERFILE ---
-    if not os.path.exists("Dockerfile"):
-        # Use UV if detected, otherwise Pip
-        if context.get("type") == "uv":
-            install_cmd = "RUN pip install uv && uv pip install --system ."
-        else:
-            # Modern pip can install from pyproject.toml directly
-            install_cmd = "RUN pip install ."
-
-        dockerfile_content = f"""# Generated by Xenfra (Robust v2)
-FROM python:3.13-slim
-
-WORKDIR /app
-
-# Install uv via pip
-RUN pip install uv
-
-# Copy only the dependency file first to leverage Docker layer caching
-COPY pyproject.toml .
-
-# Install dependencies from pyproject.toml
-# This is more robust than `pip install .` as it doesn't build the local package
-RUN uv pip install --system -r pyproject.toml
-
-# Copy the rest of the application code
-COPY . .
-
-# Add the 'src' directory to Python's path
-# This allows imports to work correctly for projects with a src/ layout
-ENV PYTHONPATH="${{PYTHONPATH}}:/app/src"
-
-# Expose Port
-EXPOSE {port}
-
-# Start Command
-CMD ["/bin/sh", "-c", "{cmd}"]
-"""
-        with open("Dockerfile", "w") as f:
-            f.write(dockerfile_content)
-        generated.append("Dockerfile")
-
-    # --- 2. CADDYFILE ---
-    if not os.path.exists("Caddyfile"):
-        caddy_content = f"""{{
-    # Enable automatic HTTPS for all sites
-    email your_email@example.com
-}}
-
-:443 {{
-    reverse_proxy app:{port}
-}}
-
-:80 {{
-    redir https://{{host}}{{uri}}
-}}
-"""
-        with open("Caddyfile", "w") as f:
-            f.write(caddy_content)
-        generated.append("Caddyfile")
-
-    # --- 3. DOCKER COMPOSE ---
-    if not os.path.exists("docker-compose.yml"):
-        compose_content = f"""
-version: '3.8'
-
-services:
-  app:
-    build: .
-    container_name: xenfra_app
-    restart: always
-    # The internal port is exposed to other services in this network
-    expose:
-      - "{port}"
-
-  caddy:
-    image: caddy:latest
-    container_name: xenfra_caddy
-    restart: always
-    ports:
-      - "80:80"
-      - "443:443"
-    volumes:
-      - ./Caddyfile:/etc/caddy/Caddyfile
-      - caddy_data:/data
-      - caddy_config:/config
-    depends_on:
-      - app
-
-volumes:
-  caddy_data:
-  caddy_config:
-"""
-        with open("docker-compose.yml", "w") as f:
-            f.write(compose_content)
-        generated.append("docker-compose.yml")
-
-    return generated
+    # Merge detected context with provided context
+    render_context = {
+        '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