agentbridge-cli 0.1.11__py3-none-any.whl

agentbridge/__init__.py

@@ -0,0 +1,8 @@
+"""AgentBridge - OpenAI-compatible API for Claude Code SDK and Codex CLI."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("agentbridge-cli")
+except PackageNotFoundError:
+    __version__ = "0.0.0+unknown"

agentbridge/_build_info.py

@@ -0,0 +1 @@
+GIT_HASH = "unknown"

agentbridge/config.py

@@ -0,0 +1,85 @@
+"""User configuration paths and .env loading for AgentBridge."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+CONFIG_DIR_ENV = "AGENTBRIDGE_CONFIG_DIR"
+DEFAULT_POOL_SIZE = 1
+DEFAULT_ENV_CONTENT = """# AgentBridge local configuration
+# Keep API keys on this machine only. Values in the process environment override this file.
+OPENROUTER_API_KEY=
+OPENROUTER_SITE_URL=
+OPENROUTER_APP_NAME=agentbridge
+"""
+
+def user_config_dir(*, create: bool = False) -> Path:
+    """Return the user config directory, defaulting to ~/.config/agentbridge."""
+    raw = os.environ.get(CONFIG_DIR_ENV)
+    path = Path(raw).expanduser() if raw else Path.home() / ".config" / "agentbridge"
+    if create:
+        path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def user_env_path(*, create_parent: bool = False) -> Path:
+    """Return the AgentBridge .env path."""
+    return user_config_dir(create=create_parent) / ".env"
+
+
+def _write_default_env(path: Path) -> None:
+    path.write_text(DEFAULT_ENV_CONTENT, encoding="utf-8")
+    try:
+        path.chmod(0o600)
+    except OSError:
+        pass
+
+
+def _unquote_env_value(value: str) -> str:
+    value = value.strip()
+    if len(value) >= 2 and value[0] == value[-1] and value[0] in ("'", '"'):
+        return value[1:-1]
+    return value
+
+
+def load_user_env(*, create: bool = False) -> Path | None:
+    """Load ~/.config/agentbridge/.env into os.environ without overriding existing values."""
+    path = user_env_path(create_parent=create)
+    if create and not path.exists():
+        _write_default_env(path)
+    if not path.is_file():
+        return None
+
+    for raw_line in path.read_text(encoding="utf-8").splitlines():
+        line = raw_line.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, value = line.split("=", 1)
+        key = key.strip()
+        if not key or key.startswith("#"):
+            continue
+        parsed_value = _unquote_env_value(value)
+        if parsed_value:
+            os.environ.setdefault(key, parsed_value)
+
+    return path
+
+
+def session_log_dir(*, create: bool = False) -> Path:
+    """Return the session log directory, defaulting inside the AgentBridge config dir."""
+    raw = os.environ.get("LOG_DIR")
+    if raw:
+        path = Path(os.path.expandvars(raw)).expanduser()
+    else:
+        path = user_config_dir(create=create) / "logs" / "sessions"
+    if create:
+        path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def ensure_user_config() -> Path:
+    """Create the AgentBridge config directory, .env, and default log directory."""
+    load_user_env(create=True)
+    session_log_dir(create=True)
+    return user_config_dir(create=True)

agentbridge/dashboard.py

@@ -0,0 +1,494 @@
+"""Dashboard state tracking and FastAPI routes."""
+
+import asyncio
+import json
+import logging
+import re
+import time
+from pathlib import Path
+from typing import Callable
+
+from fastapi import APIRouter, HTTPException, Request
+from fastapi.responses import FileResponse, HTMLResponse, StreamingResponse
+from fastapi.templating import Jinja2Templates
+
+from .config import session_log_dir
+from .models import AVAILABLE_MODELS
+
+logger = logging.getLogger(__name__)
+_REQUEST_ID_PATTERN = re.compile(r"chatcmpl-[a-f0-9]{8,32}")
+
+
+# ---------------------------------------------------------------------------
+# In-memory state
+# ---------------------------------------------------------------------------
+
+class _ActiveRequest:
+    """Tracks a single in-flight request."""
+
+    __slots__ = (
+        "request_id",
+        "model",
+        "start_time",
+        "messages",
+        "buffered_text",
+        "_subscribers",
+    )
+
+    def __init__(
+        self,
+        request_id: str,
+        model: str,
+        messages: list[dict] | None = None,
+    ):
+        self.request_id = request_id
+        self.model = model
+        self.start_time = time.monotonic()
+        self.messages = messages or []
+        self.buffered_text = ""
+        self._subscribers: list[asyncio.Queue] = []
+
+    def to_dict(self) -> dict:
+        return {
+            "request_id": self.request_id,
+            "model": self.model,
+            "elapsed_s": round(time.monotonic() - self.start_time, 2),
+            "messages": self.messages,
+            "buffered_text": self.buffered_text,
+        }
+
+
+class DashboardState:
+    """Tracks active requests so the dashboard can display them and stream tokens."""
+
+    def __init__(self):
+        self._active: dict[str, _ActiveRequest] = {}
+        self._change_event = asyncio.Event()
+        self._pool_change_event = asyncio.Event()
+
+    def _notify(self) -> None:
+        """Signal that the active requests list has changed."""
+        self._change_event.set()
+
+    def notify_pool_change(self) -> None:
+        """Signal that pool status has changed."""
+        self._pool_change_event.set()
+
+    async def wait_for_pool_change(self, timeout: float = 5.0) -> None:
+        """Wait for a pool change notification or timeout, then clear the event."""
+        self._pool_change_event.clear()
+        try:
+            await asyncio.wait_for(self._pool_change_event.wait(), timeout=timeout)
+        except asyncio.TimeoutError:
+            pass
+
+    async def wait_for_change(self, timeout: float = 2.0) -> None:
+        """Wait for a change notification or timeout, then clear the event."""
+        self._change_event.clear()
+        try:
+            await asyncio.wait_for(self._change_event.wait(), timeout=timeout)
+        except asyncio.TimeoutError:
+            pass
+
+    def request_started(
+        self,
+        request_id: str,
+        model: str,
+        messages: list[dict] | None = None,
+    ) -> None:
+        self._active[request_id] = _ActiveRequest(
+            request_id,
+            model,
+            messages=messages,
+        )
+        self._notify()
+
+    def chunk_received(self, request_id: str, text: str) -> None:
+        req = self._active.get(request_id)
+        if req is None:
+            return
+        req.buffered_text += text
+        msg = {"type": "chunk", "text": text}
+        for q in req._subscribers:
+            try:
+                q.put_nowait(msg)
+            except asyncio.QueueFull:
+                pass  # Drop for slow consumers
+
+    def request_completed(self, request_id: str) -> None:
+        req = self._active.pop(request_id, None)
+        if req is None:
+            return
+        for q in req._subscribers:
+            try:
+                q.put_nowait({"type": "done"})
+            except asyncio.QueueFull:
+                pass  # Drop for slow consumers
+        self._notify()
+
+    def request_errored(self, request_id: str, error: str) -> None:
+        req = self._active.pop(request_id, None)
+        if req is None:
+            return
+        for q in req._subscribers:
+            try:
+                q.put_nowait({"type": "error", "error": error})
+            except asyncio.QueueFull:
+                pass  # Drop for slow consumers
+        self._notify()
+
+    def get_active_requests(self) -> list[dict]:
+        return [r.to_dict() for r in self._active.values()]
+
+    def subscribe(self, request_id: str) -> asyncio.Queue | None:
+        req = self._active.get(request_id)
+        if req is None:
+            return None
+        q: asyncio.Queue = asyncio.Queue(maxsize=100)
+        req._subscribers.append(q)
+        return q
+
+    def unsubscribe(self, request_id: str, queue: asyncio.Queue) -> None:
+        req = self._active.get(request_id)
+        if req is None:
+            return
+        try:
+            req._subscribers.remove(queue)
+        except ValueError:
+            pass
+
+
+# ---------------------------------------------------------------------------
+# Route helpers
+# ---------------------------------------------------------------------------
+
+def _sse_data_lines(text: str) -> str:
+    """Return text formatted as SSE data lines."""
+    if "\n" in text:
+        return "\n".join(f"data: {line}" for line in text.splitlines())
+    return f"data: {text}"
+
+
+def _validate_request_id(request_id: str) -> None:
+    """Reject malformed request IDs before constructing filesystem paths."""
+    if _REQUEST_ID_PATTERN.fullmatch(request_id) is None:
+        raise HTTPException(status_code=400, detail="Invalid request ID")
+
+
+TEMPLATES_DIR = Path(__file__).parent / "templates" / "dashboard"
+templates = Jinja2Templates(directory=str(TEMPLATES_DIR))
+
+
+def _parse_log_file(path: Path) -> dict | None:
+    """Parse a session log file (JSON format) into a structured dict.
+
+    Returns dict with session data or None if the file cannot be parsed.
+    Only accepts dicts with a ``request_id`` key (skips attachment manifests, etc.).
+    """
+    try:
+        with open(path) as f:
+            data = json.load(f)
+        if not isinstance(data, dict) or "request_id" not in data:
+            return None
+        return data
+    except (OSError, json.JSONDecodeError):
+        return None
+
+
+def _get_recent_logs(limit: int = 20) -> list[dict]:
+    """Read recent session log files, newest first."""
+    log_dir = session_log_dir()
+    if not log_dir.exists():
+        return []
+
+    def _mtime(f: Path) -> float:
+        try:
+            return f.stat().st_mtime
+        except OSError:
+            return 0.0
+
+    log_files = sorted(
+        log_dir.glob("*.json"),
+        key=_mtime,
+        reverse=True,
+    )
+
+    results = []
+    for path in log_files[:limit]:
+        parsed = _parse_log_file(path)
+        if parsed is not None:
+            results.append(parsed)
+
+    return results
+
+
+# ---------------------------------------------------------------------------
+# Router factory
+# ---------------------------------------------------------------------------
+
+def create_dashboard_router(
+    state: DashboardState,
+    pool_status_fn: Callable[[], dict],
+) -> APIRouter:
+    """Create and return a dashboard APIRouter.
+
+    Args:
+        state: DashboardState instance for tracking active requests.
+        pool_status_fn: Callable returning pool status dict with keys
+            'size' and 'in_use'.
+    """
+    router = APIRouter()
+
+    @router.get("/dashboard", response_class=HTMLResponse)
+    async def dashboard_page(request: Request):
+        """Serve the main dashboard page."""
+        return templates.TemplateResponse(
+            request,
+            "page.html",
+            {"active_view": "monitor"},
+        )
+
+    @router.get("/dashboard/chat", response_class=HTMLResponse)
+    async def dashboard_chat_page(request: Request):
+        """Serve the chat completion test console."""
+        return templates.TemplateResponse(
+            request,
+            "chat.html",
+            {
+                "available_models": AVAILABLE_MODELS,
+                "default_model": "claudecode/sonnet",
+                "active_view": "chat",
+            },
+        )
+
+    @router.get("/dashboard/pool", response_class=HTMLResponse)
+    async def dashboard_pool(request: Request):
+        """Render pool status fragment."""
+        status = pool_status_fn()
+        return templates.TemplateResponse(
+            request,
+            "pool.html",
+            {
+                "size": status.get("size", 0),
+                "in_use": status.get("in_use", 0),
+            },
+        )
+
+    @router.get("/dashboard/pool/stream")
+    async def dashboard_pool_stream(request: Request):
+        """SSE endpoint that pushes pool status HTML on change."""
+
+        async def event_stream():
+            try:
+                while True:
+                    if await request.is_disconnected():
+                        break
+                    status = pool_status_fn()
+                    rendered = templates.get_template("pool.html").render(
+                        size=status.get("size", 0),
+                        in_use=status.get("in_use", 0),
+                    )
+                    sse_data = _sse_data_lines(rendered)
+                    yield f"event: message\n{sse_data}\n\n"
+                    await state.wait_for_pool_change(timeout=5.0)
+            except asyncio.CancelledError:
+                pass
+            except Exception:
+                logger.exception("Error in pool SSE stream")
+
+        return StreamingResponse(
+            event_stream(),
+            media_type="text/event-stream",
+            headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
+        )
+
+    def _get_merged_requests(limit: int = 20) -> list[dict]:
+        """Merge active and completed requests into a single list.
+
+        Active requests appear first (newest first), then completed (newest first).
+        Each item has an ``is_active`` flag.
+        """
+        active = state.get_active_requests()
+        for req in active:
+            req["is_active"] = True
+        active.sort(key=lambda r: r["elapsed_s"])  # lowest elapsed = newest
+
+        completed = _get_recent_logs(limit=limit)
+        for log in completed:
+            log["is_active"] = False
+            timing = log.get("timing") if isinstance(log.get("timing"), dict) else {}
+            if log.get("duration_ms") is None:
+                log["duration_ms"] = timing.get("duration_ms", 0)
+            if log.get("input_tokens") is None:
+                usage_data = log.get("usage")
+                if usage_data:
+                    log["input_tokens"] = usage_data.get("input_tokens")
+                    log["output_tokens"] = usage_data.get("output_tokens")
+
+        merged = active + completed
+        return merged[:limit]
+
+    @router.get("/dashboard/requests")
+    async def dashboard_requests(request: Request):
+        """SSE endpoint that pushes unified requests HTML on change."""
+
+        async def event_stream():
+            try:
+                while True:
+                    if await request.is_disconnected():
+                        break
+                    merged = _get_merged_requests()
+                    rendered = templates.get_template("requests.html").render(
+                        requests=merged
+                    )
+                    sse_data = _sse_data_lines(rendered)
+                    yield f"event: message\n{sse_data}\n\n"
+                    await state.wait_for_change(timeout=2.0)
+            except asyncio.CancelledError:
+                pass
+            except Exception:
+                logger.exception("Error in requests SSE stream")
+
+        return StreamingResponse(
+            event_stream(),
+            media_type="text/event-stream",
+            headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
+        )
+
+    @router.get("/dashboard/request/{request_id}", response_class=HTMLResponse)
+    async def dashboard_request_detail(request_id: str, request: Request):
+        """Render request detail — checks active state first, then log file."""
+        _validate_request_id(request_id)
+
+        # Check active requests first
+        active_requests = state.get_active_requests()
+        active = None
+        for req in active_requests:
+            if req["request_id"] == request_id:
+                active = req
+                break
+
+        if active is not None:
+            return templates.TemplateResponse(
+                request,
+                "detail.html",
+                {
+                    "request_id": request_id,
+                    "model": active["model"],
+                    "timestamp": "",
+                    "duration_ms": int(active["elapsed_s"] * 1000),
+                    "input_tokens": None,
+                    "output_tokens": None,
+                    "error": None,
+                    "exception_type": None,
+                    "is_active": True,
+                    "buffered_text": active.get("buffered_text", ""),
+                    "messages": active.get("messages", []),
+                    "response": None,
+                },
+            )
+
+        # Fall back to log file
+        log_dir = session_log_dir()
+        log_path = log_dir / f"{request_id}.json"
+        parsed = _parse_log_file(log_path)
+        if parsed is None:
+            raise HTTPException(status_code=404, detail="Request not found")
+
+        timing = parsed.get("timing", {})
+        usage = parsed.get("usage", {})
+        return templates.TemplateResponse(
+            request,
+            "detail.html",
+            {
+                "request_id": parsed.get("request_id", request_id),
+                "model": parsed.get("model"),
+                "timestamp": parsed.get("timestamp", ""),
+                "duration_ms": timing.get("duration_ms", 0),
+                "input_tokens": usage.get("input_tokens"),
+                "output_tokens": usage.get("output_tokens"),
+                "error": parsed.get("error"),
+                "exception_type": parsed.get("exception_type"),
+                "is_active": False,
+                "buffered_text": "",
+                "messages": parsed.get("messages", []),
+                "response": parsed.get("response"),
+            },
+        )
+
+    @router.get("/dashboard/log/{request_id}")
+    async def dashboard_log(request_id: str):
+        """Serve the raw JSON log for a completed request."""
+        _validate_request_id(request_id)
+
+        log_dir = session_log_dir()
+        log_path = log_dir / f"{request_id}.json"
+        if not log_path.is_file():
+            raise HTTPException(status_code=404, detail="Request log not found")
+        if not log_path.resolve().is_relative_to(log_dir.resolve()):
+            raise HTTPException(status_code=400, detail="Invalid request ID")
+
+        return FileResponse(log_path, media_type="application/json")
+
+    @router.get("/dashboard/attachment/{request_id}/{filename}")
+    async def dashboard_attachment(request_id: str, filename: str):
+        """Serve a saved attachment file."""
+        _validate_request_id(request_id)
+        # Validate filename — no path traversal
+        if ".." in filename or "/" in filename or "\\" in filename:
+            raise HTTPException(status_code=400, detail="Invalid filename")
+
+        log_dir = session_log_dir()
+        file_path = log_dir / f"{request_id}_attachments" / filename
+        # Resolved-path containment check to prevent path traversal
+        if not file_path.resolve().is_relative_to(log_dir.resolve()):
+            raise HTTPException(status_code=400, detail="Invalid filename")
+        if not file_path.is_file():
+            raise HTTPException(status_code=404, detail="Attachment not found")
+
+        return FileResponse(file_path)
+
+    @router.get("/dashboard/stream/{request_id}")
+    async def dashboard_stream(request_id: str):
+        """SSE endpoint for live token streaming."""
+        _validate_request_id(request_id)
+        queue = state.subscribe(request_id)
+        if queue is None:
+            raise HTTPException(status_code=404, detail="Request not active")
+
+        async def event_stream():
+            try:
+                while True:
+                    msg = await queue.get()
+                    if msg["type"] == "chunk":
+                        escaped = (
+                            msg["text"]
+                            .replace("&", "&")
+                            .replace("<", "&lt;")
+                            .replace(">", "&gt;")
+                        )
+                        data_lines = _sse_data_lines(escaped)
+                        yield f"event: chunk\n{data_lines}\n\n"
+                    elif msg["type"] == "done":
+                        yield "event: done\ndata: complete\n\n"
+                        return
+                    elif msg["type"] == "error":
+                        escaped_err = (
+                            msg["error"]
+                            .replace("&", "&amp;")
+                            .replace("<", "&lt;")
+                            .replace(">", "&gt;")
+                        )
+                        data_lines = _sse_data_lines(escaped_err)
+                        yield f"event: error\n{data_lines}\n\n"
+                        return
+            finally:
+                state.unsubscribe(request_id, queue)
+
+        return StreamingResponse(
+            event_stream(),
+            media_type="text/event-stream",
+            headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
+        )
+
+    return router