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

import hashlib
import re
import secrets
from datetime import datetime
from typing import Any
from uuid import UUID

from sqlalchemy import select, update

from ..storage.db import Database
from ..storage.models import AuditLog, McpToken, User, utcnow
from .actor import Actor
from .sessions import CurrentUser, to_current_user

CONSUMER_RE = re.compile(r"^[a-z0-9._-]{1,32}$")
KEY_PREFIX = "mcp_"
DEFAULT_SCOPES = ["read", "write"]


class KeyExistsError(ValueError):
    def __init__(self, key_id: str, token_hint: str) -> None:
        super().__init__("Key already exists for this user and consumer")
        self.key_id = key_id
        self.token_hint = token_hint


class KeyNotFoundError(ValueError):
    pass


def _hash(token: str) -> str:
    return hashlib.sha256(token.encode("utf-8")).hexdigest()


def _new_token() -> tuple[str, str, str]:
    token = KEY_PREFIX + secrets.token_urlsafe(32)
    return token, _hash(token), token[-6:]


def _iso(value: datetime | None) -> str | None:
    if value is None:
        return None
    return value.isoformat().replace("+00:00", "Z")


def validate_consumer(consumer: str) -> str:
    if not isinstance(consumer, str) or not CONSUMER_RE.match(consumer):
        raise ValueError("consumer must match ^[a-z0-9._-]{1,32}$")
    return consumer


def serialize_key(row: McpToken, user_sub: str | None = None) -> dict[str, Any]:
    return {
        "key_id": str(row.id),
        "user_id": user_sub or str(row.user_id),
        "consumer": row.consumer,
        "name": row.name,
        "role": row.role,
        "scopes": list(row.scopes or []),
        "token_hint": row.token_hint,
        "created_at": _iso(row.created_at),
        "last_used_at": _iso(row.last_used_at),
        "revoked_at": _iso(row.revoked_at),
        "stale_at": _iso(row.stale_at),
    }


def create_key(
    database: Database,
    user: CurrentUser,
    consumer: str,
    name: str,
    reissue: bool = False,
    actor: Actor | None = None,
) -> tuple[dict[str, Any], str]:
    validate_consumer(consumer)
    clean_name = (name or f"{consumer} key").strip()
    if not clean_name or len(clean_name) > 120:
        raise ValueError("name must be 1..120 characters")

    actor = actor or Actor(
        kind="user",
        name=user.display_name or user.email or user.sub,
        via="api",
        user_id=user.id,
    )
    now = utcnow()

    with database.session() as session:
        with session.begin():
            active = session.scalars(
                select(McpToken)
                .where(
                    McpToken.user_id == user.id,
                    McpToken.consumer == consumer,
                    McpToken.revoked_at.is_(None),
                )
                .with_for_update()
            ).first()
            if active is not None:
                if not reissue:
                    raise KeyExistsError(str(active.id), active.token_hint)
                active.revoked_at = now
                active.stale_at = None

            token, token_hash, hint = _new_token()
            row = McpToken(
                user_id=user.id,
                consumer=consumer,
                name=clean_name,
                role=user.system_role or "user",
                scopes=list(DEFAULT_SCOPES),
                token_hash=token_hash,
                token_hint=hint,
                created_at=now,
            )
            session.add(row)
            session.flush()
            _audit(session, actor, "mcp_key.issue", row)
            return serialize_key(row, user.sub), token


def list_keys(
    database: Database,
    user_id: UUID | None = None,
    consumer: str | None = None,
) -> list[dict[str, Any]]:
    with database.session() as session:
        query = select(McpToken).order_by(McpToken.created_at.desc())
        if user_id is not None:
            query = query.where(McpToken.user_id == user_id)
        if consumer:
            query = query.where(McpToken.consumer == consumer)
        rows = session.scalars(query).all()
        user_ids = {row.user_id for row in rows}
        subs = {
            identifier: sub
            for identifier, sub in session.execute(
                select(User.id, User.sub).where(User.id.in_(user_ids))
            ).all()
        }
        return [serialize_key(row, subs.get(row.user_id)) for row in rows]


def revoke_key(
    database: Database,
    key_id: str,
    owner_user_id: UUID | None = None,
    actor: Actor | None = None,
) -> dict[str, Any]:
    actor = actor or Actor(kind="service", name="key-management", via="api")
    with database.session() as session:
        with session.begin():
            row = _load_key(session, key_id)
            if owner_user_id is not None and row.user_id != owner_user_id:
                raise KeyNotFoundError("Key not found")
            if row.revoked_at is None:
                row.revoked_at = utcnow()
                _audit(session, actor, "mcp_key.revoke", row)
            user = session.get(User, row.user_id)
            return serialize_key(row, user.sub if user else None)


def rotate_key(
    database: Database,
    key_id: str,
    owner_user_id: UUID | None = None,
    actor: Actor | None = None,
) -> tuple[dict[str, Any], str]:
    with database.session() as session:
        row = _load_key(session, key_id)
        if owner_user_id is not None and row.user_id != owner_user_id:
            raise KeyNotFoundError("Key not found")
        if row.revoked_at is not None:
            raise KeyNotFoundError("Key not found")
        user = session.get(User, row.user_id)
        if user is None:
            raise KeyNotFoundError("Key not found")
        current = to_current_user(user)
        consumer = row.consumer
        name = row.name

    actor = actor or Actor(
        kind="user",
        name=current.display_name or current.email or current.sub,
        via="api",
        user_id=current.id,
    )
    return create_key(
        database,
        current,
        consumer,
        name,
        reissue=True,
        actor=actor,
    )


def resolve_mcp_token(
    database: Database, token: str
) -> tuple[CurrentUser, McpToken] | None:
    if not token or not token.startswith(KEY_PREFIX):
        return None

    now = utcnow()
    with database.session() as session:
        row = session.scalars(
            select(McpToken).where(McpToken.token_hash == _hash(token))
        ).first()
        if row is None or row.revoked_at is not None:
            return None
        user = session.get(User, row.user_id)
        if user is None or user.blocked_at is not None:
            return None
        row.last_used_at = now
        session.commit()
        return to_current_user(user), row


def revoke_user_keys(database: Database, user_id: UUID) -> None:
    with database.session() as session:
        with session.begin():
            session.execute(
                update(McpToken)
                .where(
                    McpToken.user_id == user_id,
                    McpToken.revoked_at.is_(None),
                )
                .values(revoked_at=utcnow())
            )


def revoke_user_keys_in_session(session, user_id: UUID, now: datetime) -> None:
    session.execute(
        update(McpToken)
        .where(
            McpToken.user_id == user_id,
            McpToken.revoked_at.is_(None),
        )
        .values(revoked_at=now)
    )


def mark_user_keys_stale_in_session(session, user_id: UUID, now: datetime) -> None:
    session.execute(
        update(McpToken)
        .where(
            McpToken.user_id == user_id,
            McpToken.revoked_at.is_(None),
        )
        .values(stale_at=now)
    )


def _load_key(session, key_id: str) -> McpToken:
    try:
        identifier = UUID(str(key_id))
    except ValueError as exc:
        raise KeyNotFoundError("Key not found") from exc
    row = session.get(McpToken, identifier)
    if row is None:
        raise KeyNotFoundError("Key not found")
    return row


def _audit(session, actor: Actor, action: str, row: McpToken) -> None:
    session.add(
        AuditLog(
            actor_user_id=actor.user_id,
            actor_kind=actor.kind,
            actor_name=actor.name,
            via=actor.via,
            action=action,
            entity_type="mcp_key",
            entity_id=str(row.id),
            after={
                "user_id": str(row.user_id),
                "consumer": row.consumer,
                "token_hint": row.token_hint,
            },
        )
    )