from __future__ import annotations
import hmac
from typing import Any
from uuid import UUID
from fastapi import APIRouter, Depends, HTTPException, Request
from fastapi.responses import JSONResponse, Response
from pydantic import BaseModel
from sqlalchemy import select
from ..config import Settings, get_settings
from ..storage.db import Database
from ..storage.models import User
from .actor import Actor
from .mcp_keys import (
KeyExistsError,
KeyNotFoundError,
create_key,
list_keys,
revoke_key,
rotate_key,
)
from .rate_limit import limiter_for
from .sessions import CurrentUser, to_current_user
router = APIRouter()
class UserKeyRequest(BaseModel):
consumer: str
name: str = ""
reissue: bool = False
class InternalKeyRequest(BaseModel):
user_id: str
consumer: str
name: str = ""
reissue: bool = False
def require_internal_service(
request: Request, settings: Settings = Depends(get_settings)
) -> None:
if not settings.internal_key_secret:
raise HTTPException(status_code=503, detail="Internal key API is not configured")
supplied = request.headers.get("x-service-key")
if not supplied:
authorization = request.headers.get("authorization", "")
parts = authorization.split(None, 1)
if len(parts) == 2 and parts[0].lower() == "bearer":
supplied = parts[1].strip()
if not supplied or not hmac.compare_digest(supplied, settings.internal_key_secret):
raise HTTPException(status_code=401, detail="Invalid service credentials")
host = request.client.host if request.client else ""
allowed = set(settings.internal_allowlist) | {"127.0.0.1", "::1"}
if host not in allowed:
raise HTTPException(status_code=403, detail="Source address is not allowed")
limiter = limiter_for(settings.internal_rate_limit)
if not limiter.allow(host or "unknown"):
raise HTTPException(status_code=429, detail="Too many requests")
def _require_user(request: Request, settings: Settings) -> CurrentUser:
if not settings.auth_enabled:
raise HTTPException(status_code=400, detail="Authentication is not configured")
user = getattr(request.state, "user", None)
if user is None:
raise HTTPException(status_code=401, detail="Not authenticated")
if user.is_blocked:
raise HTTPException(status_code=403, detail="User is blocked")
return user
def _user_by_sub(database: Database, sub: str) -> CurrentUser | None:
with database.session() as session:
user = session.scalars(select(User).where(User.sub == sub)).first()
return to_current_user(user) if user is not None else None
def _key_response(key: dict[str, Any], token: str) -> dict[str, Any]:
return {**key, "token": token}
@router.get("/mcp-keys")
def user_keys(
request: Request, settings: Settings = Depends(get_settings)
) -> dict[str, Any]:
user = _require_user(request, settings)
database = Database.from_settings(settings)
include_all = request.query_params.get("all") == "true" and user.system_role == "admin"
return {
"items": list_keys(database, user_id=None if include_all else user.id)
}
@router.post("/mcp-keys", status_code=201)
def user_create_key(
payload: UserKeyRequest,
request: Request,
settings: Settings = Depends(get_settings),
):
user = _require_user(request, settings)
if not limiter_for(settings.mcp_key_rate_limit).allow(f"user:{user.id}"):
raise HTTPException(status_code=429, detail="Too many requests")
database = Database.from_settings(settings)
try:
key, token = create_key(
database,
user,
payload.consumer,
payload.name,
reissue=payload.reissue,
)
except KeyExistsError as exc:
return JSONResponse(
{"error": "key_exists", "key_id": exc.key_id, "token_hint": exc.token_hint},
status_code=409,
)
except ValueError as exc:
raise HTTPException(status_code=400, detail=str(exc)) from exc
return _key_response(key, token)
@router.post("/mcp-keys/{key_id}/rotate")
def user_rotate_key(
key_id: str,
request: Request,
settings: Settings = Depends(get_settings),
):
user = _require_user(request, settings)
if not limiter_for(settings.mcp_key_rate_limit).allow(f"user:{user.id}"):
raise HTTPException(status_code=429, detail="Too many requests")
database = Database.from_settings(settings)
try:
key, token = rotate_key(
database,
key_id,
owner_user_id=None if user.system_role == "admin" else user.id,
)
except KeyNotFoundError as exc:
raise HTTPException(status_code=404, detail=str(exc)) from exc
except ValueError as exc:
raise HTTPException(status_code=400, detail=str(exc)) from exc
return _key_response(key, token)
@router.delete("/mcp-keys/{key_id}", status_code=204)
def user_revoke_key(
key_id: str,
request: Request,
settings: Settings = Depends(get_settings),
) -> Response:
user = _require_user(request, settings)
try:
revoke_key(
Database.from_settings(settings),
key_id,
owner_user_id=None if user.system_role == "admin" else user.id,
)
except KeyNotFoundError as exc:
raise HTTPException(status_code=404, detail=str(exc)) from exc
return Response(status_code=204)
@router.post("/internal/keys", status_code=201)
def internal_create_key(
payload: InternalKeyRequest,
settings: Settings = Depends(get_settings),
_: None = Depends(require_internal_service),
):
database = Database.from_settings(settings)
user = _user_by_sub(database, payload.user_id)
if user is None:
return JSONResponse({"error": "invalid_user_id"}, status_code=400)
try:
key, token = create_key(
database,
user,
payload.consumer,
payload.name,
reissue=payload.reissue,
actor=Actor(kind="service", name="provisioning", via="api"),
)
except KeyExistsError as exc:
return JSONResponse(
{"error": "key_exists", "key_id": exc.key_id, "token_hint": exc.token_hint},
status_code=409,
)
except ValueError as exc:
return JSONResponse({"error": "invalid_request", "detail": str(exc)}, status_code=400)
return _key_response(key, token)
@router.get("/internal/keys")
def internal_list_keys(
user_id: str | None = None,
consumer: str | None = None,
settings: Settings = Depends(get_settings),
_: None = Depends(require_internal_service),
):
database = Database.from_settings(settings)
owner: UUID | None = None
if user_id:
user = _user_by_sub(database, user_id)
if user is None:
return {"items": []}
owner = user.id
return {"items": list_keys(database, user_id=owner, consumer=consumer)}
@router.delete("/internal/keys/{key_id}", status_code=204)
def internal_revoke_key(
key_id: str,
settings: Settings = Depends(get_settings),
_: None = Depends(require_internal_service),
) -> Response:
try:
revoke_key(
Database.from_settings(settings),
key_id,
actor=Actor(kind="service", name="provisioning", via="api"),
)
except KeyNotFoundError as exc:
raise HTTPException(status_code=404, detail=str(exc)) from exc
return Response(status_code=204)
@router.post("/internal/keys/{key_id}/rotate", status_code=201)
def internal_rotate_key(
key_id: str,
settings: Settings = Depends(get_settings),
_: None = Depends(require_internal_service),
):
try:
key, token = rotate_key(
Database.from_settings(settings),
key_id,
actor=Actor(kind="service", name="provisioning", via="api"),
)
except KeyNotFoundError as exc:
raise HTTPException(status_code=404, detail=str(exc)) from exc
except ValueError as exc:
raise HTTPException(status_code=400, detail=str(exc)) from exc
return _key_response(key, token)