xenfra 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

xenfra/api/webhooks.py

@@ -1,146 +0,0 @@
-# src/xenfra/api/webhooks.py
-
-import hmac
-import hashlib
-from fastapi import APIRouter, Depends, HTTPException, status, Request, BackgroundTasks
-from sqlmodel import Session, select
-
-from xenfra.db.session import get_session
-from xenfra.db.models import User, Credential
-from xenfra.dependencies import get_current_active_user # Corrected import
-from xenfra.engine import InfraEngine
-from xenfra.security import decrypt_token
-from xenfra.config import settings
-
-router = APIRouter()
-
-# This secret should be configured in your GitHub App's webhook settings
-GITHUB_WEBHOOK_SECRET = settings.GITHUB_WEBHOOK_SECRET
-
-async def verify_github_signature(request: Request):
-    """
-    Verify that the incoming webhook request is genuinely from GitHub.
-    """
-    if not GITHUB_WEBHOOK_SECRET:
-        raise HTTPException(status_code=500, detail="GitHub webhook secret not configured.")
-
-    signature_header = request.headers.get("X-Hub-Signature-256")
-    if not signature_header:
-        raise HTTPException(status_code=400, detail="X-Hub-Signature-256 header is missing.")
-
-    signature_parts = signature_header.split("=", 1)
-    if len(signature_parts) != 2 or signature_parts[0] != "sha256":
-        raise HTTPException(status_code=400, detail="Invalid signature format.")
-
-    signature = signature_parts[1]
-    body = await request.body()
-    
-    expected_signature = hmac.new(
-        key=GITHUB_WEBHOOK_SECRET.encode(),
-        msg=body,
-        digestmod=hashlib.sha256
-    ).hexdigest()
-
-    if not hmac.compare_digest(expected_signature, signature):
-        raise HTTPException(status_code=400, detail="Invalid signature.")
-
-
-@router.post("/github", dependencies=[Depends(verify_github_signature)])
-async def github_webhook(request: Request, background_tasks: BackgroundTasks, session: Session = Depends(get_session)):
-    """
-    Handles incoming webhooks from GitHub to manage Preview Environments.
-    """
-    payload = await request.json()
-    event_type = request.headers.get("X-GitHub-Event")
-
-    if event_type == "pull_request":
-        action = payload.get("action")
-        pr_info = payload.get("pull_request", {})
-        repo_info = payload.get("repository", {})
-        
-        repo_full_name = repo_info.get("full_name")
-        pr_number = pr_info.get("number")
-        commit_sha = pr_info.get("head", {}).get("sha")
-        clone_url = repo_info.get("clone_url")
-        installation_id = payload.get("installation", {}).get("id")
-
-        if not all([repo_full_name, pr_number, commit_sha, clone_url, installation_id]):
-            raise HTTPException(status_code=400, detail="Incomplete pull request payload or missing installation ID.")
-
-        # Find the user associated with this GitHub App installation
-        github_credential = session.exec(
-            select(Credential).where(
-                Credential.service == "github",
-                Credential.github_installation_id == installation_id
-            )
-        ).first()
-
-        if not github_credential:
-            raise HTTPException(status_code=404, detail=f"No GitHub credential found for installation ID {installation_id}.")
-
-        user = session.exec(select(User).where(User.id == github_credential.user_id)).first()
-        if not user:
-            raise HTTPException(status_code=404, detail=f"User not found for credential with installation ID {installation_id}.")
-
-        # Find the user's DigitalOcean credential
-        do_credential = session.exec(
-            select(Credential).where(Credential.user_id == user.id, Credential.service == "digitalocean")
-        ).first()
-        
-        if not do_credential:
-            raise HTTPException(status_code=400, detail=f"No DigitalOcean credential found for user {user.email}.")
-
-        # Decrypt the token and instantiate the engine
-        try:
-            do_token = decrypt_token(do_credential.encrypted_token)
-            engine = InfraEngine(token=do_token) # InfraEngine needs to be adapted to accept a token
-            
-            print(f"DEBUG(WEBHOOKS): engine object id: {id(engine)}, type: {type(engine)}")
-            print(f"DEBUG(WEBHOOKS): engine.list_servers method id: {id(engine.list_servers)}, type: {type(engine.list_servers)}")
-
-        except Exception as e:
-            return {"status": "error", "detail": f"Failed to initialize engine: {e}"}
-
-        server_name = f"xenfra-pr-{repo_full_name.replace('/', '-')}-{pr_number}"
-
-        if action in ["opened", "synchronize"]:
-            print(f"🚀 Deploying preview for PR #{pr_number} from {repo_full_name} at {commit_sha[:7]}")
-            # This should be run in a background task in a real app
-            background_tasks.add_task(
-                engine.deploy_server,
-                name=server_name,
-                region="nyc3", # Using a default for now
-                size="s-1vcpu-1gb", # Using a default for now
-                image="ubuntu-22-04-x64", # Using a default for now
-                email=user.email,
-                repo_url=clone_url,
-                commit_sha=commit_sha
-            )
-            # TODO: Post comment back to GitHub with the preview URL
-            # TODO: Store the droplet_id and PR number association in the DB
-            
-            return {"status": "success", "action": "deploying in background"}
-
-
-        elif action == "closed":
-            print(f"🔥 Destroying preview for closed PR #{pr_number} from {repo_full_name}")
-            try:
-                # Find the droplet associated with this PR
-                servers = engine.list_servers()
-                droplet_to_destroy = None
-                for s in servers:
-                    if s.name == server_name:
-                        droplet_to_destroy = s
-                        break
-
-                if droplet_to_destroy:
-                    background_tasks.add_task(engine.destroy_server, droplet_to_destroy.id)
-                    print(f"✅ Droplet {droplet_to_destroy.name} ({droplet_to_destroy.id}) scheduled for destruction.")
-                else:
-                    print(f"⚠️ No droplet found with name {server_name} to destroy.")
-            except Exception as e:
-                print(f"❌ Failed to destroy preview environment: {e}")
-
-            return {"status": "success", "action": "destroying in background"}
-
-    return {"status": "success", "detail": "Webhook received"}

xenfra/cli/main.py

@@ -1,211 +0,0 @@
-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

@@ -1,24 +0,0 @@
-# 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

@@ -1,51 +0,0 @@
-# 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

@@ -1,17 +0,0 @@
-# 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

@@ -1,35 +0,0 @@
-# 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,89 +0,0 @@
-import os
-from pathlib import Path
-from jinja2 import Environment, FileSystemLoader
-
-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(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 = []
-    
-    # Check directly in project root
-    for name in ["main.py", "app.py"]:
-        if (project_root / name).is_file():
-            candidate_files.append(project_root / name)
-
-    # Check in src/*/ (standard package layout)
-    for src_dir in project_root.glob("src/*"):
-        if src_dir.is_dir():
-            for name in ["main.py", "app.py"]:
-                if (src_dir / name).is_file():
-                    candidate_files.append(src_dir / name)
-
-    for file_path in candidate_files:
-        with open(file_path, "r") as f:
-            content = f.read()
-            
-            module_name = str(file_path.relative_to(project_root)).replace(os.sep, '.')[:-3]
-            if module_name.startswith("src."):
-                module_name = module_name[4:]
-
-
-            if "FastAPI" in content:
-                return "fastapi", 8000, f"uvicorn {module_name}:app --host 0.0.0.0 --port 8000"
-            
-            if "Flask" in content:
-                return "flask", 5000, f"gunicorn {module_name}:app -b 0.0.0.0:5000"
-    
-    return None, None, None
-
-def generate_templated_assets(context: dict):
-    """
-    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'}
-    """
-    # 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 []
-
-    # 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