sandboxy 0.0.1__py3-none-any.whl

sandboxy/api/app.py

@@ -0,0 +1,76 @@
+"""FastAPI application factory for local development."""
+
+import logging
+from contextlib import asynccontextmanager
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+from sandboxy.logging import setup_logging
+
+load_dotenv()
+setup_logging()
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+
+logger = logging.getLogger(__name__)
+
+
+@asynccontextmanager
+async def _local_lifespan(app: FastAPI):
+    """Lifespan handler for local mode (no database)."""
+    yield
+
+
+def create_local_app(
+    root_dir: Path,
+    local_ui_path: Path | None = None,
+) -> FastAPI:
+    """Create FastAPI app for local development mode.
+
+    This version is lightweight and reads from the local filesystem.
+
+    Args:
+        root_dir: Working directory for scenarios/tools/agents.
+        local_ui_path: Path to local UI static files.
+    """
+    from sandboxy.local.context import LocalContext, set_local_context
+
+    ctx = LocalContext(root_dir=root_dir)
+    set_local_context(ctx)
+
+    app = FastAPI(
+        title="Sandboxy Local",
+        description="Local development server for Sandboxy",
+        version="0.2.0",
+        lifespan=_local_lifespan,
+    )
+
+    # CORS - allow all origins in local mode
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    # Local routes only
+    from sandboxy.api.routes import agents, tools
+    from sandboxy.api.routes import local as local_routes
+
+    app.include_router(local_routes.router, prefix="/api/v1", tags=["local"])
+    app.include_router(agents.router, prefix="/api/v1", tags=["agents"])
+    app.include_router(tools.router, prefix="/api/v1", tags=["tools"])
+
+    @app.get("/health")
+    async def health_check():
+        return {"status": "ok", "mode": "local"}
+
+    # Serve local UI if available
+    if local_ui_path and local_ui_path.exists():
+        app.mount("/", StaticFiles(directory=str(local_ui_path), html=True), name="local-ui")
+
+    return app

sandboxy/api/routes/__init__.py

@@ -0,0 +1 @@
+"""API routes for Sandboxy."""

sandboxy/api/routes/agents.py

@@ -0,0 +1,92 @@
+"""Agent listing routes."""
+
+import logging
+
+import yaml
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from sandboxy.local.context import get_local_context
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+
+class AgentResponse(BaseModel):
+    """Response model for an agent."""
+
+    id: str
+    name: str
+    model: str
+    description: str | None = None
+    provider: str | None = None
+
+
+class AgentListResponse(BaseModel):
+    """Response model for agent listing."""
+
+    agents: list[AgentResponse]
+    count: int
+
+
+def _load_agents() -> list[AgentResponse]:
+    """Load agents from YAML files in the local agents directory."""
+    ctx = get_local_context()
+    if not ctx:
+        return []
+
+    agents = []
+    agent_dir = ctx.agents_dir
+
+    if not agent_dir.exists():
+        return agents
+
+    for path in agent_dir.glob("*.y*ml"):
+        try:
+            content = path.read_text()
+            data = yaml.safe_load(content)
+            if data and isinstance(data, dict):
+                agent_id = data.get("id", path.stem)
+                model = data.get("model", "unknown")
+
+                # Determine provider from model name
+                provider = None
+                if "gpt" in model.lower():
+                    provider = "openai"
+                elif "claude" in model.lower():
+                    provider = "anthropic"
+                elif "llama" in model.lower() or "mistral" in model.lower():
+                    provider = "local"
+
+                agents.append(
+                    AgentResponse(
+                        id=agent_id,
+                        name=data.get("name", agent_id),
+                        model=model,
+                        description=data.get("description"),
+                        provider=provider,
+                    )
+                )
+        except Exception as e:
+            logger.warning(f"Failed to load agent from {path}: {e}")
+            continue
+
+    return agents
+
+
+@router.get("/agents", response_model=AgentListResponse)
+async def list_agents():
+    """List all available agents."""
+    agents = _load_agents()
+    return AgentListResponse(agents=agents, count=len(agents))
+
+
+@router.get("/agents/{agent_id}", response_model=AgentResponse)
+async def get_agent(agent_id: str):
+    """Get an agent by ID."""
+    agents = _load_agents()
+    for agent in agents:
+        if agent.id == agent_id:
+            return agent
+
+    raise HTTPException(status_code=404, detail="Agent not found")