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,
},
)
)