codeframe-ai 0.9.0__py3-none-any.whl

codeframe/ui/routers/templates_v2.py

@@ -0,0 +1,232 @@
+"""V2 Templates router - delegates to core modules.
+
+This module provides v2-style API endpoints for template management that
+delegate to core/templates.py. It uses the v2 Workspace model.
+
+The v1 router (templates.py) remains for backwards compatibility.
+"""
+
+import logging
+from typing import Any, Literal, Optional
+
+from fastapi import APIRouter, Depends, HTTPException, Query, Request
+from pydantic import BaseModel, Field
+
+from codeframe.core.workspace import Workspace
+from codeframe.lib.rate_limiter import rate_limit_standard
+from codeframe.core import templates
+from codeframe.ui.dependencies import get_v2_workspace
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/v2/templates", tags=["templates-v2"])
+
+
+# ============================================================================
+# Request/Response Models
+# ============================================================================
+
+
+class TemplateTaskResponse(BaseModel):
+    """Response model for a template task."""
+
+    title: str
+    description: str
+    estimated_hours: float = Field(..., gt=0, description="Estimated hours (must be positive)")
+    complexity_score: int = Field(..., ge=1, le=5, description="Complexity rating (1-5)")
+    uncertainty_level: Literal["low", "medium", "high"] = Field(
+        ..., description="Uncertainty level"
+    )
+    depends_on_indices: list[int]
+    tags: list[str]
+
+
+class TemplateResponse(BaseModel):
+    """Response model for a task template."""
+
+    id: str
+    name: str
+    description: str
+    category: str
+    tags: list[str]
+    total_estimated_hours: float
+    tasks: list[TemplateTaskResponse]
+
+
+class TemplateListResponse(BaseModel):
+    """Response model for template list."""
+
+    id: str
+    name: str
+    description: str
+    category: str
+    total_estimated_hours: float
+
+
+class ApplyTemplateRequest(BaseModel):
+    """Request model for applying a template."""
+
+    template_id: str
+    context: dict[str, Any] = Field(default_factory=dict)
+    issue_number: str = "1"
+
+
+class ApplyTemplateResponse(BaseModel):
+    """Response model for applied template."""
+
+    template_id: str
+    tasks_created: int
+    task_ids: list[str]  # v2 uses string UUIDs
+
+
+class CategoryListResponse(BaseModel):
+    """Response model for category list."""
+
+    categories: list[str]
+
+
+# ============================================================================
+# Template Endpoints
+# ============================================================================
+
+
+@router.get("", response_model=list[TemplateListResponse])
+@rate_limit_standard()
+async def list_templates(
+    request: Request,
+    category: Optional[str] = Query(None, description="Optional category filter"),
+) -> list[TemplateListResponse]:
+    """List all available task templates.
+
+    This is the v2 equivalent of `cf templates list`.
+
+    Args:
+        category: Optional category filter
+
+    Returns:
+        List of templates with basic info
+    """
+    try:
+        template_list = templates.list_templates(category=category)
+
+        return [
+            TemplateListResponse(
+                id=t.id,
+                name=t.name,
+                description=t.description,
+                category=t.category,
+                total_estimated_hours=t.total_estimated_hours,
+            )
+            for t in template_list
+        ]
+
+    except Exception as e:
+        logger.error(f"Failed to list templates: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/categories", response_model=CategoryListResponse)
+@rate_limit_standard()
+async def list_categories(request: Request) -> CategoryListResponse:
+    """List all template categories.
+
+    Returns:
+        List of category names
+    """
+    try:
+        categories = templates.get_categories()
+        return CategoryListResponse(categories=categories)
+
+    except Exception as e:
+        logger.error(f"Failed to list categories: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/{template_id}", response_model=TemplateResponse)
+@rate_limit_standard()
+async def get_template(
+    request: Request,
+    template_id: str,
+) -> TemplateResponse:
+    """Get details for a specific template.
+
+    This is the v2 equivalent of `cf templates show`.
+
+    Args:
+        template_id: Template ID
+
+    Returns:
+        Template with full details including tasks
+    """
+    try:
+        template = templates.get_template(template_id)
+
+        if not template:
+            raise HTTPException(status_code=404, detail=f"Template not found: {template_id}")
+
+        return TemplateResponse(
+            id=template.id,
+            name=template.name,
+            description=template.description,
+            category=template.category,
+            tags=template.tags,
+            total_estimated_hours=template.total_estimated_hours,
+            tasks=[
+                TemplateTaskResponse(
+                    title=task.title,
+                    description=task.description,
+                    estimated_hours=task.estimated_hours,
+                    complexity_score=task.complexity_score,
+                    uncertainty_level=task.uncertainty_level,
+                    depends_on_indices=task.depends_on_indices,
+                    tags=task.tags,
+                )
+                for task in template.tasks
+            ],
+        )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to get template {template_id}: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/apply", response_model=ApplyTemplateResponse)
+@rate_limit_standard()
+async def apply_template(
+    request: Request,
+    body: ApplyTemplateRequest,
+    workspace: Workspace = Depends(get_v2_workspace),
+) -> ApplyTemplateResponse:
+    """Apply a template to create tasks for a workspace.
+
+    This is the v2 equivalent of `cf templates apply`.
+
+    Args:
+        request: HTTP request for rate limiting
+        body: Template application request
+        workspace: v2 Workspace
+
+    Returns:
+        Result with created task IDs
+    """
+    try:
+        result = templates.apply_template(
+            workspace=workspace,
+            template_id=body.template_id,
+            issue_number=body.issue_number,
+            context=body.context,
+        )
+
+        return ApplyTemplateResponse(
+            template_id=result.template_id,
+            tasks_created=result.tasks_created,
+            task_ids=result.task_ids,
+        )
+
+    except ValueError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except Exception as e:
+        logger.error(f"Failed to apply template: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))

codeframe/ui/routers/terminal_ws.py

@@ -0,0 +1,267 @@
+"""WebSocket router for interactive terminal in a session workspace.
+
+Endpoint:
+    WS /ws/sessions/{session_id}/terminal?token=<JWT>
+
+Client → Server message types:
+    Raw bytes / text: forwarded verbatim to subprocess stdin.
+    {"type": "resize", "cols": 120, "rows": 40}: resize the terminal window.
+
+Server → Client:
+    Raw bytes from subprocess stdout/stderr.
+
+Note: Uses asyncio pipes (not PTY) for simplicity. Arrow keys, colour output,
+and interactive programs like vim require a PTY — that is a known limitation of
+this initial implementation.
+"""
+
+import asyncio
+import json
+import logging
+import os
+import shutil
+
+import jwt as pyjwt
+from fastapi import APIRouter, WebSocket, WebSocketDisconnect
+from sqlalchemy import select
+
+from codeframe.auth.manager import SECRET, JWT_ALGORITHM, JWT_AUDIENCE, get_async_session_maker
+from codeframe.auth.models import User
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(tags=["websocket"])
+
+# Per-user concurrent terminal connection counter (in-process; resets on restart)
+_MAX_TERMINALS_PER_USER = 3
+_user_terminal_counts: dict[int, int] = {}
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+async def _authenticate_websocket(websocket: WebSocket) -> int | None:
+    """Validate JWT from query param. Returns user_id or closes the socket."""
+    token = websocket.query_params.get("token")
+    if not token:
+        await websocket.close(code=4001, reason="Authentication required: missing token")
+        return None
+
+    try:
+        payload = pyjwt.decode(token, SECRET, algorithms=[JWT_ALGORITHM], audience=JWT_AUDIENCE)
+        user_id_str = payload.get("sub")
+        if not user_id_str:
+            await websocket.close(code=4001, reason="Invalid token: missing subject")
+            return None
+        user_id = int(user_id_str)
+    except pyjwt.ExpiredSignatureError:
+        await websocket.close(code=4001, reason="Token expired")
+        return None
+    except (pyjwt.InvalidTokenError, ValueError) as exc:
+        logger.debug("Terminal WS JWT decode error: %s", exc)
+        await websocket.close(code=4001, reason="Invalid authentication token")
+        return None
+
+    try:
+        async_session_maker = get_async_session_maker()
+        async with async_session_maker() as session:
+            result = await session.execute(select(User).where(User.id == user_id))
+            user = result.scalar_one_or_none()
+            if user is None:
+                await websocket.close(code=4001, reason="User not found")
+                return None
+            if not user.is_active:
+                await websocket.close(code=4001, reason="User is inactive")
+                return None
+    except Exception as exc:
+        logger.error("Terminal WS user lookup error: %s", exc)
+        await websocket.close(code=4001, reason="Authentication failed")
+        return None
+
+    return user_id
+
+
+# ---------------------------------------------------------------------------
+# Endpoint
+# ---------------------------------------------------------------------------
+
+
+@router.websocket("/ws/sessions/{session_id}/terminal")
+async def session_terminal_ws(session_id: str, websocket: WebSocket) -> None:
+    """Bidirectional WebSocket that shells bash in the session's workspace."""
+    # --- Auth ---
+    user_id = await _authenticate_websocket(websocket)
+    if user_id is None:
+        return
+
+    # --- Session lookup ---
+    db = getattr(websocket.app.state, "db", None)
+    if db is None:
+        await websocket.close(code=1011, reason="Database unavailable")
+        return
+
+    session = await asyncio.to_thread(db.interactive_sessions.get, session_id)
+    if session is None or session.get("state") == "ended":
+        await websocket.close(code=4004, reason="Session not found or ended")
+        return
+
+    # --- Ownership check ---
+    session_user_id = session.get("user_id")
+    if session_user_id is not None and int(session_user_id) != user_id:
+        await websocket.close(code=4003, reason="Forbidden: session belongs to another user")
+        return
+
+    workspace_path = session.get("workspace_path")
+    if not workspace_path:
+        logger.error("session_id=%s has no workspace_path; refusing terminal spawn", session_id)
+        await websocket.close(code=4008, reason="Session has no workspace configured")
+        return
+
+    # --- Per-user connection cap ---
+    current = _user_terminal_counts.get(user_id, 0)
+    if current >= _MAX_TERMINALS_PER_USER:
+        await websocket.close(code=4029, reason="Too many open terminals; close an existing session first")
+        return
+    _user_terminal_counts[user_id] = current + 1
+
+    await websocket.accept()
+
+    # --- Spawn bash with a minimal, explicit environment ---
+    # Do NOT use os.environ.copy() — it would expose server secrets (API keys, DB creds)
+    # to the subprocess. Only pass variables required for a functional terminal.
+    env = {
+        "TERM": "xterm-256color",
+        "HOME": os.environ.get("HOME", "/tmp"),
+        "PATH": os.environ.get("PATH", "/usr/local/bin:/usr/bin:/bin"),
+        "SHELL": "/bin/bash",
+        "LANG": os.environ.get("LANG", "en_US.UTF-8"),
+        "USER": os.environ.get("USER", ""),
+    }
+
+    shell_exe = shutil.which("bash") or shutil.which("sh") or "sh"
+
+    process: asyncio.subprocess.Process | None = None
+    ws_to_stdin_task: asyncio.Task | None = None
+    stdout_to_ws_task: asyncio.Task | None = None
+
+    try:
+        process = await asyncio.create_subprocess_exec(
+            shell_exe,
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.STDOUT,
+            cwd=workspace_path,
+            env=env,
+        )
+
+        # --- Relay: stdout → WebSocket ---
+        async def _stdout_relay() -> None:
+            assert process is not None
+            assert process.stdout is not None
+            try:
+                while True:
+                    chunk = await process.stdout.read(4096)
+                    if not chunk:
+                        break
+                    try:
+                        await websocket.send_bytes(chunk)
+                    except Exception:
+                        break
+            except asyncio.CancelledError:
+                pass
+            except Exception as exc:
+                logger.debug("Terminal stdout relay error: %s", exc)
+
+        # --- Relay: WebSocket → stdin (handles both text and binary frames) ---
+        async def _stdin_relay() -> None:
+            assert process is not None
+            assert process.stdin is not None
+            try:
+                while True:
+                    try:
+                        msg = await websocket.receive()
+                    except WebSocketDisconnect:
+                        raise
+
+                    if "text" in msg:
+                        raw_text: str = msg["text"]
+                        if len(raw_text) > 65536:
+                            logger.warning("session_id=%s: dropping oversized text frame (%d bytes)", session_id, len(raw_text))
+                            continue
+                        try:
+                            parsed = json.loads(raw_text)
+                            if isinstance(parsed, dict) and parsed.get("type") == "resize":
+                                # Resize: nothing to do without a PTY
+                                continue
+                        except json.JSONDecodeError:
+                            pass
+                        process.stdin.write(raw_text.encode())
+                        await process.stdin.drain()
+                    elif "bytes" in msg:
+                        raw_bytes: bytes = msg["bytes"]
+                        if len(raw_bytes) > 65536:
+                            logger.warning("session_id=%s: dropping oversized binary frame (%d bytes)", session_id, len(raw_bytes))
+                            continue
+                        try:
+                            parsed = json.loads(raw_bytes)
+                            if isinstance(parsed, dict) and parsed.get("type") == "resize":
+                                continue
+                        except (json.JSONDecodeError, UnicodeDecodeError):
+                            pass
+                        process.stdin.write(raw_bytes)
+                        await process.stdin.drain()
+
+            except WebSocketDisconnect:
+                raise
+            except asyncio.CancelledError:
+                pass
+            except Exception as exc:
+                logger.debug("Terminal stdin relay error: %s", exc)
+
+        stdout_to_ws_task = asyncio.create_task(_stdout_relay())
+        ws_to_stdin_task = asyncio.create_task(_stdin_relay())
+
+        # Wait for either task to finish (disconnect or process exit)
+        await asyncio.wait(
+            [stdout_to_ws_task, ws_to_stdin_task],
+            return_when=asyncio.FIRST_COMPLETED,
+        )
+
+    except WebSocketDisconnect:
+        logger.debug("Terminal WebSocket disconnected: session_id=%s", session_id)
+    except Exception as exc:
+        logger.error("Terminal WebSocket error: %s", exc, exc_info=True)
+    finally:
+        # Cancel relay tasks
+        for task in [ws_to_stdin_task, stdout_to_ws_task]:
+            if task and not task.done():
+                task.cancel()
+                try:
+                    await task
+                except (asyncio.CancelledError, Exception):
+                    pass
+
+        # Terminate subprocess
+        if process is not None:
+            try:
+                process.terminate()
+                await asyncio.wait_for(process.wait(), timeout=3.0)
+            except (ProcessLookupError, asyncio.TimeoutError):
+                try:
+                    process.kill()
+                except ProcessLookupError:
+                    pass
+
+        # Release the per-user connection slot
+        count = _user_terminal_counts.get(user_id, 0)
+        if count > 1:
+            _user_terminal_counts[user_id] = count - 1
+        else:
+            _user_terminal_counts.pop(user_id, None)
+
+        try:
+            await websocket.close()
+        except Exception:
+            pass