Newer
Older
gnexus-book / server / app / auth / mcp_guard.py
from __future__ import annotations

import hmac
from dataclasses import replace
from typing import Callable

from starlette.concurrency import run_in_threadpool
from starlette.responses import JSONResponse
from starlette.types import ASGIApp, Receive, Scope, Send

from ..config import Settings
from ..storage.db import Database
from .actor import Actor
from .context import current_actor, current_mcp_scopes
from .mcp_keys import resolve_mcp_token
from .rate_limit import limiter_for


class McpTokenGuard:
    """Bearer-key guard for the MCP streamable HTTP endpoint.

    Personal keys are resolved from `mcp_tokens`; the optional static token is a
    break-glass mechanism only and never acts as a fallback for user requests.
    """

    def __init__(
        self, app: ASGIApp, settings_provider: Callable[[], Settings]
    ) -> None:
        self.app = app
        self._settings_provider = settings_provider
        self._database: Database | None = None

    def _db(self, settings: Settings) -> Database:
        if self._database is None:
            self._database = Database.from_settings(settings)
        return self._database

    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
        if scope["type"] != "http":
            await self.app(scope, receive, send)
            return

        settings = self._settings_provider()
        headers = {
            key.decode("latin-1").lower(): value.decode("latin-1")
            for key, value in scope.get("headers", [])
        }
        token = _bearer_token(headers.get("authorization", ""))

        if not token:
            await _unauthorized(scope, receive, send)
            return

        user = None
        key = None
        if settings.mcp_static_token and hmac.compare_digest(
            token, settings.mcp_static_token
        ):
            actor = Actor(kind="system", name="break-glass", via="mcp")
            scopes: tuple[str, ...] = ("read", "write")
        else:
            try:
                resolved = await run_in_threadpool(
                    resolve_mcp_token, self._db(settings), token
                )
            except Exception:
                response = JSONResponse(
                    {"error": 503, "detail": "Authentication storage is unavailable"},
                    status_code=503,
                )
                await response(scope, receive, send)
                return
            if resolved is None:
                await _unauthorized(scope, receive, send)
                return
            user, key = resolved
            scopes = tuple(key.scopes or [])
            actor = Actor(
                kind="agent",
                name=key.name,
                via="mcp",
                user_id=user.id,
            )

        limit_key = str(key.id) if key is not None else "break-glass"
        if not limiter_for(settings.mcp_request_rate_limit).allow(limit_key):
            response = JSONResponse(
                {"error": 429, "detail": "rate limit exceeded"},
                status_code=429,
            )
            await response(scope, receive, send)
            return

        state = scope.setdefault("state", {})
        state["user"] = user
        state["mcp_token"] = key
        state["mcp_scopes"] = scopes

        actor_token = current_actor.set(actor)
        scopes_token = current_mcp_scopes.set(scopes)
        try:
            await self.app(scope, receive, send)
        finally:
            current_actor.reset(actor_token)
            current_mcp_scopes.reset(scopes_token)


def mcp_actor(is_user: bool = False) -> Actor:
    base = current_actor.get() or Actor(kind="agent", via="mcp")
    return replace(base, kind="user" if is_user else "agent")


def mcp_write_denied() -> dict[str, object] | None:
    scopes = current_mcp_scopes.get()
    if scopes is not None and "write" not in scopes:
        return {"error": 403, "detail": "write scope required"}
    return None


def _bearer_token(header: str) -> str | None:
    if not header:
        return None
    parts = header.split(None, 1)
    if len(parts) != 2 or parts[0].lower() != "bearer":
        return None
    token = parts[1].strip()
    return token or None


async def _unauthorized(scope: Scope, receive: Receive, send: Send) -> None:
    response = JSONResponse(
        {"error": 401, "detail": "Unauthorized"},
        status_code=401,
        headers={"WWW-Authenticate": "Bearer"},
    )
    await response(scope, receive, send)