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)