Newer
Older
gnexus-book / server / app / auth / mcp_routes.py
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)