bamboo-coding 0.1.0__py3-none-any.whl

bamboo_coding-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

bamboo_coding-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+bamboo-coding = bamboo_coding.client.main:main
+bamboo-coding-server = bamboo_coding.server.main:main

bamboo_coding-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,6 @@
+agent
+api
+bamboo_coding
+controller
+git_utils
+shared

controller/app/api/agents/__init__.py

@@ -0,0 +1,3 @@
+from .ws import router
+
+__all__ = ["router"]

controller/app/api/agents/ws.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+import asyncio
+
+from fastapi import APIRouter, WebSocket
+from fastapi.websockets import WebSocketDisconnect
+
+from controller.app.core.errors import AgentApprovalError
+from shared.protocol import (
+    AgentRegisterMessage,
+    ClientStatusMessage,
+    RegisterRequestMessage,
+    TaskEventMessage,
+    TaskResultMessage,
+    TerminalClosedMessage,
+    TerminalHeartbeatMessage,
+    TerminalOutputMessage,
+    TerminalStatusMessage,
+)
+
+
+router = APIRouter()
+
+
+def _extract_token(websocket: WebSocket) -> str:
+    auth_header = websocket.headers.get('authorization', '')
+    if auth_header.startswith('Bearer '):
+        return auth_header[7:]
+    return websocket.query_params.get('token', '')
+
+
+@router.websocket('/ws/agents')
+async def agent_socket(websocket: WebSocket) -> None:
+    await websocket.accept()
+    send_lock = asyncio.Lock()
+
+    async def send_json(payload: dict) -> None:
+        async with send_lock:
+            await websocket.send_json(payload)
+
+    token = _extract_token(websocket)
+    raw = await websocket.receive_json()
+    register = AgentRegisterMessage(**raw)
+    client_id = register.client_id or register.client_info.hostname
+    agents = websocket.app.state.agents
+    repos = websocket.app.state.repositories
+    router_service = websocket.app.state.router
+    terminals = websocket.app.state.terminals
+
+    if not token:
+        existing_agent = agents.get_agent_by_client_id(client_id)
+        if existing_agent and existing_agent.get('approval_status') == 'approved' and existing_agent.get('token'):
+            await send_json(RegisterRequestMessage(approved=True, client_id=client_id, token=existing_agent['token'], message='approved').model_dump())
+        else:
+            agents.create_registration_request(client_id)
+            await send_json(RegisterRequestMessage(approved=False, client_id=client_id, message='pending approval').model_dump())
+        await websocket.close()
+        return
+
+    try:
+        agent = agents.register_connection(client_id=client_id, token=token, client_info=register.client_info.model_dump())
+    except AgentApprovalError:
+        agents.create_registration_request(client_id)
+        await send_json(RegisterRequestMessage(approved=False, client_id=client_id, message='pending approval').model_dump())
+        await websocket.close()
+        return
+
+    for repo in register.repositories:
+        repos.upsert_repository_binding(
+            agent_id=agent['agent_id'],
+            repo_id=repo.repo_id,
+            name=repo.name,
+            path=repo.path,
+            status='ready',
+        )
+    router_service.attach_agent(
+        agent_id=agent['agent_id'],
+        send_json=send_json,
+        capabilities=[item.model_dump() for item in register.capabilities],
+        repositories=[item.model_dump() for item in register.repositories],
+    )
+    await send_json(RegisterRequestMessage(approved=True, client_id=client_id, token=token, message='registered').model_dump())
+
+    try:
+        while True:
+            payload = await websocket.receive_json()
+            message_type = payload.get('type')
+            if message_type == 'client_status':
+                status = ClientStatusMessage(**payload)
+                for repo in status.repositories:
+                    repos.upsert_repository_binding(
+                        agent_id=agent['agent_id'],
+                        repo_id=repo.repo_id,
+                        name=repo.name,
+                        path=repo.path,
+                        status='ready',
+                    )
+                router_service.attach_agent(
+                    agent_id=agent['agent_id'],
+                    send_json=send_json,
+                    capabilities=[item.model_dump() for item in status.capabilities],
+                    repositories=[item.model_dump() for item in status.repositories],
+                )
+            elif message_type == 'task_event':
+                event = TaskEventMessage(**payload)
+                await router_service.handle_event(
+                    task_id=event.task_id,
+                    status=event.status,
+                    message=event.message,
+                    details=event.details,
+                )
+            elif message_type == 'task_result':
+                result = TaskResultMessage(**payload)
+                await router_service.handle_result(
+                    task_id=result.task_id,
+                    success=result.success,
+                    result=result.result,
+                    error=result.error,
+                )
+            elif message_type == 'terminal_status':
+                await terminals.handle_terminal_status(TerminalStatusMessage(**payload))
+            elif message_type == 'terminal_output':
+                await terminals.handle_terminal_output(TerminalOutputMessage(**payload))
+            elif message_type == 'terminal_heartbeat':
+                await terminals.handle_terminal_heartbeat(TerminalHeartbeatMessage(**payload))
+            elif message_type == 'terminal_closed':
+                await terminals.handle_terminal_closed(TerminalClosedMessage(**payload))
+    except WebSocketDisconnect:
+        pass
+    finally:
+        router_service.detach_agent(agent['agent_id'])
+        agents.mark_disconnected(agent['agent_id'])
+        await terminals.close_agent_sessions(agent['agent_id'], reason='client_disconnected')

controller/app/api/public/__init__.py

@@ -0,0 +1,11 @@
+from fastapi import APIRouter
+
+from .repos import router as repos_router
+from .terminals import router as terminals_router
+
+
+router = APIRouter()
+router.include_router(repos_router)
+router.include_router(terminals_router)
+
+__all__ = ["router"]

controller/app/api/public/repos.py

@@ -0,0 +1,207 @@
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException, Request
+
+
+router = APIRouter(prefix="/api")
+
+
+def _list_public_roots(request: Request) -> list[dict]:
+    return [item.model_dump() for item in request.app.state.repositories.list_public_roots()]
+
+
+async def _dispatch(request: Request, path: str, capability: str, action: str, params: dict, agent_id: str | None = None) -> dict:
+    try:
+        return await request.app.state.router.dispatch_task(path, capability, action, params, agent_id=agent_id)
+    except PermissionError as exc:
+        raise HTTPException(status_code=403, detail=str(exc)) from exc
+    except RuntimeError as exc:
+        raise HTTPException(status_code=503, detail=str(exc)) from exc
+    except KeyError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+
+
+@router.get("/agents")
+async def list_agents(request: Request) -> list[dict]:
+    agents = request.app.state.agents.list_agents()
+    for agent in agents:
+        live_agent = request.app.state.router.live_agents.get(agent["agent_id"])
+        agent["roots"] = [dict(root) for root in (live_agent.roots if live_agent is not None else [])]
+    return agents
+
+
+@router.post("/agents/{agent_id}/approve")
+async def approve_agent(agent_id: str, request: Request) -> dict:
+    import uuid
+
+    token = uuid.uuid4().hex
+    agent = request.app.state.agents.approve_agent(agent_id=agent_id, token=token)
+    return {
+        "approved": True,
+        "agent_id": agent["agent_id"],
+        "client_id": agent["client_id"],
+        "token": agent["token"],
+    }
+
+
+@router.get("/roots")
+async def list_roots(request: Request) -> list[dict]:
+    return _list_public_roots(request)
+
+
+@router.get("/fs/tree")
+async def get_tree(path: str, request: Request, all: bool = False, agent_id: str | None = None) -> dict:
+    return await _dispatch(request, path, "fs.tree", "get", {"all": all}, agent_id=agent_id)
+
+
+@router.get("/fs/browse")
+async def browse(path: str, request: Request, agent_id: str | None = None) -> dict:
+    return await _dispatch(request, path, "fs.browse", "get", {}, agent_id=agent_id)
+
+
+@router.get("/fs/file")
+async def read_file(path: str, request: Request, agent_id: str | None = None) -> dict:
+    return await _dispatch(request, path, "fs.file.read", "get", {}, agent_id=agent_id)
+
+
+@router.get("/fs/file/raw")
+async def read_file_raw(path: str, request: Request, agent_id: str | None = None) -> dict:
+    return await _dispatch(request, path, "fs.file.read_raw", "get", {}, agent_id=agent_id)
+
+
+@router.put("/fs/file")
+async def write_file(path: str, request: Request, agent_id: str | None = None) -> dict:
+    body = await request.json()
+    return await _dispatch(request, path, "fs.file.write", "put", {"content": body.get("content", ""), "encoding": body.get("encoding", "utf-8")}, agent_id=agent_id)
+
+
+@router.post("/fs/folder")
+async def create_folder(path: str, request: Request, agent_id: str | None = None) -> dict:
+    try:
+        body = await request.json()
+    except Exception:
+        body = {}
+    exist_ok = bool(body.get("exist_ok", True)) if isinstance(body, dict) else True
+    return await _dispatch(request, path, "fs.folder.create", "post", {"exist_ok": exist_ok}, agent_id=agent_id)
+
+
+@router.delete("/fs/path")
+async def delete_path(path: str, request: Request, recursive: bool = False, agent_id: str | None = None) -> dict:
+    return await _dispatch(request, path, "fs.path.delete", "delete", {"recursive": recursive}, agent_id=agent_id)
+
+
+@router.put("/fs/path/rename")
+async def rename_path(path: str, request: Request, agent_id: str | None = None) -> dict:
+    body = await request.json()
+    if not isinstance(body, dict):
+        raise HTTPException(status_code=400, detail="Body must be a JSON object")
+    destination = body.get("to") or body.get("new_path")
+    if not destination:
+        raise HTTPException(status_code=400, detail="Missing 'to' field in body")
+    return await _dispatch(request, path, "fs.path.rename", "put", {"to": str(destination)}, agent_id=agent_id)
+
+
+@router.get("/git/status")
+async def get_status(path: str, request: Request, agent_id: str | None = None) -> dict:
+    return await _dispatch(request, path, "git.status", "get", {}, agent_id=agent_id)
+
+
+@router.get("/git/diff")
+async def get_diff(path: str, request: Request, file: str | None = None, staged: bool = False, context: int = 3, agent_id: str | None = None) -> dict:
+    if not file:
+        raise HTTPException(status_code=400, detail="Missing file parameter")
+    return await _dispatch(request, path, "git.diff", "get", {"file": file, "staged": staged, "context": context}, agent_id=agent_id)
+
+
+@router.get("/git/commits")
+async def get_commits(path: str, request: Request, limit: int = 50, offset: int = 0, agent_id: str | None = None) -> dict:
+    if limit < 1 or limit > 100:
+        raise HTTPException(status_code=400, detail="limit must be between 1 and 100")
+    if offset < 0:
+        raise HTTPException(status_code=400, detail="offset must be non-negative")
+    return await _dispatch(request, path, "git.commits", "list", {"limit": limit, "offset": offset}, agent_id=agent_id)
+
+
+@router.get("/git/commit/{commit_hash}")
+async def get_commit_details(path: str, commit_hash: str, request: Request, agent_id: str | None = None) -> dict:
+    return await _dispatch(request, path, "git.commit_details", "get", {"commit_hash": commit_hash}, agent_id=agent_id)
+
+
+@router.post("/git/stage")
+async def stage(path: str, request: Request, agent_id: str | None = None) -> dict:
+    body = await request.json()
+    return await _dispatch(request, path, "git.stage", "post", body, agent_id=agent_id)
+
+
+@router.post("/git/unstage")
+async def unstage(path: str, request: Request, agent_id: str | None = None) -> dict:
+    body = await request.json()
+    return await _dispatch(request, path, "git.unstage", "post", body, agent_id=agent_id)
+
+
+@router.get("/git/branches")
+async def list_branches(path: str, request: Request, agent_id: str | None = None) -> dict:
+    return await _dispatch(request, path, "git.branches.list", "get", {}, agent_id=agent_id)
+
+
+@router.post("/git/branches")
+async def create_branch(path: str, request: Request, agent_id: str | None = None) -> dict:
+    body = await request.json()
+    return await _dispatch(request, path, "git.branches.create", "post", body, agent_id=agent_id)
+
+
+@router.put("/git/branches/checkout")
+async def checkout_branch(path: str, request: Request, agent_id: str | None = None) -> dict:
+    body = await request.json()
+    return await _dispatch(request, path, "git.branches.checkout", "put", body, agent_id=agent_id)
+
+
+@router.delete("/git/branches/{name}")
+async def delete_branch(path: str, name: str, request: Request, force: bool = False, agent_id: str | None = None) -> dict:
+    return await _dispatch(request, path, "git.branches.delete", "delete", {"name": name, "force": force}, agent_id=agent_id)
+
+
+@router.post("/git/branches/merge")
+async def merge_branch(path: str, request: Request, agent_id: str | None = None) -> dict:
+    body = await request.json()
+    return await _dispatch(request, path, "git.branches.merge", "post", body, agent_id=agent_id)
+
+
+@router.post("/git/commit")
+async def create_commit(path: str, request: Request, agent_id: str | None = None) -> dict:
+    body = await request.json()
+    return await _dispatch(request, path, "git.commit.create", "post", body, agent_id=agent_id)
+
+
+@router.get("/git/remotes")
+async def list_remotes(path: str, request: Request, agent_id: str | None = None) -> dict:
+    return await _dispatch(request, path, "git.remotes.list", "get", {}, agent_id=agent_id)
+
+
+@router.post("/git/remotes")
+async def add_remote(path: str, request: Request, agent_id: str | None = None) -> dict:
+    body = await request.json()
+    if not isinstance(body, dict) or not body.get("name") or not body.get("url"):
+        raise HTTPException(status_code=400, detail="Missing 'name' or 'url'")
+    return await _dispatch(request, path, "git.remotes.add", "post", body, agent_id=agent_id)
+
+
+@router.delete("/git/remotes/{name}")
+async def remove_remote(path: str, name: str, request: Request, agent_id: str | None = None) -> dict:
+    return await _dispatch(request, path, "git.remotes.remove", "delete", {"name": name}, agent_id=agent_id)
+
+
+@router.post("/git/remotes/push")
+async def push_remote(path: str, request: Request, agent_id: str | None = None) -> dict:
+    body = await request.json()
+    if not isinstance(body, dict) or not body.get("remote"):
+        raise HTTPException(status_code=400, detail="Missing 'remote'")
+    return await _dispatch(request, path, "git.remotes.push", "post", body, agent_id=agent_id)
+
+
+@router.post("/git/remotes/pull")
+async def pull_remote(path: str, request: Request, agent_id: str | None = None) -> dict:
+    body = await request.json()
+    if not isinstance(body, dict) or not body.get("remote"):
+        raise HTTPException(status_code=400, detail="Missing 'remote'")
+    return await _dispatch(request, path, "git.remotes.pull", "post", body, agent_id=agent_id)

controller/app/api/public/terminals.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import asyncio
+from uuid import uuid4
+
+from fastapi import APIRouter, WebSocket
+from fastapi.websockets import WebSocketDisconnect
+
+from shared.protocol import TerminalClosedMessage, TerminalPingMessage, TerminalPongMessage, TerminalStatusMessage
+
+
+router = APIRouter()
+
+
+def _parse_positive_int(value: str | None, default: int) -> int:
+    try:
+        parsed = int(value or '')
+    except ValueError:
+        return default
+    return parsed if parsed > 0 else default
+
+
+@router.websocket('/ws/terminal')
+async def terminal_socket(websocket: WebSocket) -> None:
+    await websocket.accept()
+
+    agent_id = websocket.query_params.get('agent_id') or ''
+    path = websocket.query_params.get('path') or ''
+    terminal_id = websocket.query_params.get('terminal_id') or str(uuid4())
+    cols = _parse_positive_int(websocket.query_params.get('cols'), 120)
+    rows = _parse_positive_int(websocket.query_params.get('rows'), 32)
+    send_lock = asyncio.Lock()
+
+    async def send_json(payload: dict) -> None:
+        async with send_lock:
+            await websocket.send_json(payload)
+
+    try:
+        if not agent_id:
+            raise RuntimeError('Missing agent_id query parameter')
+        if not path:
+            raise RuntimeError('Missing path query parameter')
+
+        await websocket.app.state.terminals.open_browser_terminal(
+            terminal_id=terminal_id,
+            agent_id=agent_id,
+            path=path,
+            cols=cols,
+            rows=rows,
+            send_json=send_json,
+        )
+        while True:
+            payload = await websocket.receive_json()
+            if payload.get('type') == 'terminal_ping':
+                TerminalPingMessage(**payload)
+                await send_json(TerminalPongMessage(terminal_id=terminal_id).model_dump())
+                continue
+            await websocket.app.state.terminals.forward_browser_message(terminal_id, payload)
+    except WebSocketDisconnect:
+        await websocket.app.state.terminals.close_browser_terminal(terminal_id, reason='browser_disconnected')
+    except RuntimeError as exc:
+        await send_json(TerminalStatusMessage(terminal_id=terminal_id, status='error', message=str(exc)).model_dump())
+        await send_json(TerminalClosedMessage(terminal_id=terminal_id, reason=str(exc)).model_dump())
+        await websocket.close()

controller/app/core/config.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+import os
+
+
+@dataclass(frozen=True)
+class AppConfig:
+    database_path: Path
+    host: str = "0.0.0.0"
+    port: int = 8100
+
+
+def load_config() -> AppConfig:
+    root_dir = Path(__file__).resolve().parents[3]
+    database_path = Path(os.getenv("CONTROLLER_DB_PATH", root_dir / ".controller" / "controller.db"))
+    host = os.getenv("HOST", "0.0.0.0")
+    port = int(os.getenv("PORT", "8100"))
+    return AppConfig(database_path=database_path, host=host, port=port)

controller/app/core/errors.py

@@ -0,0 +1,14 @@
+class ControllerError(Exception):
+    """Base error for controller services."""
+
+
+class AgentApprovalError(ControllerError):
+    """Raised when an agent is not approved for connection."""
+
+
+class RepositoryNotFoundError(ControllerError):
+    """Raised when a repository binding is missing."""
+
+
+class TaskNotFoundError(ControllerError):
+    """Raised when a task is not present in controller storage."""

controller/app/db/models.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True)
+class AgentRecord:
+    agent_id: str
+    client_id: str
+    approval_status: str
+    status: str
+    token: str | None
+    client_info: dict[str, Any]
+
+
+@dataclass(frozen=True)
+class RepositoryBindingRecord:
+    repo_id: str
+    agent_id: str
+    name: str
+    path: str
+    status: str
+
+
+@dataclass(frozen=True)
+class TaskRecord:
+    task_id: str
+    repo_id: str
+    agent_id: str | None
+    capability: str
+    action: str
+    status: str
+    params: dict[str, Any]
+
+
+@dataclass(frozen=True)
+class TaskResultRecord:
+    task_id: str
+    success: bool
+    result: dict[str, Any]
+    error: str | None

controller/app/db/session.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from contextlib import contextmanager
+from pathlib import Path
+import sqlite3
+
+
+class ControllerDatabase:
+    def __init__(self, database_path: Path | str):
+        self.database_path = Path(database_path)
+
+    def initialize(self) -> None:
+        self.database_path.parent.mkdir(parents=True, exist_ok=True)
+        with self.connection() as conn:
+            conn.executescript(
+                """
+                PRAGMA foreign_keys = ON;
+                CREATE TABLE IF NOT EXISTS agents (
+                    agent_id TEXT PRIMARY KEY,
+                    client_id TEXT NOT NULL UNIQUE,
+                    token TEXT UNIQUE,
+                    approval_status TEXT NOT NULL,
+                    status TEXT NOT NULL,
+                    client_info_json TEXT NOT NULL DEFAULT '{}',
+                    created_at TEXT NOT NULL,
+                    updated_at TEXT NOT NULL,
+                    last_seen_at TEXT
+                );
+                CREATE TABLE IF NOT EXISTS repositories (
+                    repo_id TEXT PRIMARY KEY,
+                    agent_id TEXT NOT NULL,
+                    name TEXT NOT NULL,
+                    path TEXT NOT NULL,
+                    status TEXT NOT NULL,
+                    created_at TEXT NOT NULL,
+                    updated_at TEXT NOT NULL,
+                    FOREIGN KEY (agent_id) REFERENCES agents(agent_id)
+                );
+                CREATE TABLE IF NOT EXISTS tasks (
+                    task_id TEXT PRIMARY KEY,
+                    repo_id TEXT NOT NULL,
+                    agent_id TEXT,
+                    capability TEXT NOT NULL,
+                    action TEXT NOT NULL,
+                    params_json TEXT NOT NULL DEFAULT '{}',
+                    status TEXT NOT NULL,
+                    created_at TEXT NOT NULL,
+                    updated_at TEXT NOT NULL,
+                    terminal_at TEXT,
+                    result_success INTEGER,
+                    result_json TEXT,
+                    error TEXT
+                );
+                CREATE TABLE IF NOT EXISTS task_events (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    task_id TEXT NOT NULL,
+                    status TEXT NOT NULL,
+                    message TEXT,
+                    details_json TEXT NOT NULL DEFAULT '{}',
+                    created_at TEXT NOT NULL,
+                    FOREIGN KEY (task_id) REFERENCES tasks(task_id)
+                );
+                """
+            )
+
+    @contextmanager
+    def connection(self):
+        conn = sqlite3.connect(self.database_path)
+        conn.row_factory = sqlite3.Row
+        try:
+            yield conn
+            conn.commit()
+        finally:
+            conn.close()

controller/app/main.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import FileResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+
+from controller.app.api.agents import router as agent_router
+from controller.app.api.public import router as public_router
+from controller.app.core.config import load_config
+from controller.app.db.session import ControllerDatabase
+from controller.app.services.agents import AgentService
+from controller.app.services.registrations import RegistrationService
+from controller.app.services.repositories import RepositoryService
+from controller.app.services.router import TaskRouter
+from controller.app.services.terminals import TerminalRelayService
+from controller.app.services.tasks import TaskService
+
+
+def create_app(database_path: Path | str | None = None) -> FastAPI:
+    app = FastAPI(title="Bamboo Coding")
+    config = load_config()
+    static_dir = Path(__file__).resolve().parents[2] / "static"
+    index_file = static_dir / "index.html"
+    terminal_file = static_dir / "terminal.html"
+    resolved_db_path = Path(database_path) if database_path is not None else config.database_path
+    database = ControllerDatabase(resolved_db_path)
+    database.initialize()
+    repositories = RepositoryService(database)
+    tasks = TaskService(database)
+    agents = AgentService(database)
+    router = TaskRouter(repositories=repositories, tasks=tasks)
+    terminals = TerminalRelayService(router=router)
+
+    app.state.config = config
+    app.state.database = database
+    app.state.repositories = repositories
+    app.state.tasks = tasks
+    app.state.agents = agents
+    app.state.registrations = RegistrationService(agents)
+    app.state.router = router
+    app.state.terminals = terminals
+
+    @app.exception_handler(HTTPException)
+    async def http_error_handler(_request: Request, exc: HTTPException) -> JSONResponse:
+        return JSONResponse(status_code=exc.status_code, content={"error": "request_error", "message": str(exc.detail)})
+
+    @app.exception_handler(Exception)
+    async def unexpected_error_handler(_request: Request, exc: Exception) -> JSONResponse:
+        return JSONResponse(status_code=500, content={"error": "internal_error", "message": str(exc)})
+
+    @app.get("/api/health")
+    async def health_check() -> JSONResponse:
+        return JSONResponse({"status": "ok", "version": "2.0.0"})
+
+    @app.get("/")
+    async def index() -> FileResponse:
+        return FileResponse(index_file)
+
+    @app.get("/terminal")
+    async def terminal_page() -> FileResponse:
+        return FileResponse(terminal_file)
+
+    app.include_router(public_router)
+    app.include_router(agent_router)
+    app.mount("/static", StaticFiles(directory=str(static_dir)), name="static")
+    return app
+
+
+app = create_app()