diff --git a/server/alembic/versions/9d8e9f47a7b0_mcp_personal_keys.py b/server/alembic/versions/9d8e9f47a7b0_mcp_personal_keys.py new file mode 100644 index 0000000..a84289b --- /dev/null +++ b/server/alembic/versions/9d8e9f47a7b0_mcp_personal_keys.py @@ -0,0 +1,52 @@ +"""mcp personal keys + +Revision ID: 9d8e9f47a7b0 +Revises: d95b33da4bfb +Create Date: 2026-11-19 18:55:22.343761 + +""" +from __future__ import annotations + +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa +from sqlalchemy.dialects import postgresql + +# revision identifiers, used by Alembic. +revision: str = '9d8e9f47a7b0' +down_revision: Union[str, None] = 'd95b33da4bfb' +branch_labels: Union[str, Sequence[str], None] = None +depends_on: Union[str, Sequence[str], None] = None + + +def upgrade() -> None: + # ### commands auto generated by Alembic - please adjust! ### + op.create_table('mcp_tokens', + sa.Column('id', sa.UUID(), nullable=False), + sa.Column('user_id', sa.UUID(), nullable=False), + sa.Column('consumer', sa.Text(), nullable=False), + sa.Column('name', sa.Text(), nullable=False), + sa.Column('role', sa.Text(), nullable=True), + sa.Column('scopes', postgresql.JSONB(astext_type=sa.Text()), server_default=sa.text("'[]'::jsonb"), nullable=False), + sa.Column('token_hash', sa.Text(), nullable=False), + sa.Column('token_hint', sa.Text(), nullable=False), + sa.Column('created_at', sa.DateTime(timezone=True), nullable=False), + sa.Column('last_used_at', sa.DateTime(timezone=True), nullable=True), + sa.Column('revoked_at', sa.DateTime(timezone=True), nullable=True), + sa.Column('stale_at', sa.DateTime(timezone=True), nullable=True), + sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'), + sa.PrimaryKeyConstraint('id'), + sa.UniqueConstraint('token_hash') + ) + op.create_index('ix_mcp_tokens_user_id', 'mcp_tokens', ['user_id'], unique=False) + op.create_index('uq_mcp_tokens_user_consumer_active', 'mcp_tokens', ['user_id', 'consumer'], unique=True, postgresql_where=sa.text('revoked_at IS NULL')) + # ### end Alembic commands ### + + +def downgrade() -> None: + # ### commands auto generated by Alembic - please adjust! ### + op.drop_index('uq_mcp_tokens_user_consumer_active', table_name='mcp_tokens', postgresql_where=sa.text('revoked_at IS NULL')) + op.drop_index('ix_mcp_tokens_user_id', table_name='mcp_tokens') + op.drop_table('mcp_tokens') + # ### end Alembic commands ### diff --git a/server/app/auth/context.py b/server/app/auth/context.py index ea3f31b..7481409 100644 --- a/server/app/auth/context.py +++ b/server/app/auth/context.py @@ -5,3 +5,6 @@ from .actor import Actor current_actor: ContextVar[Actor | None] = ContextVar("gnexus_book_actor", default=None) +current_mcp_scopes: ContextVar[tuple[str, ...] | None] = ContextVar( + "gnexus_book_mcp_scopes", default=None +) diff --git a/server/app/auth/mcp_guard.py b/server/app/auth/mcp_guard.py new file mode 100644 index 0000000..2391f6a --- /dev/null +++ b/server/app/auth/mcp_guard.py @@ -0,0 +1,136 @@ +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) diff --git a/server/app/auth/mcp_keys.py b/server/app/auth/mcp_keys.py new file mode 100644 index 0000000..54c2c69 --- /dev/null +++ b/server/app/auth/mcp_keys.py @@ -0,0 +1,283 @@ +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_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, + }, + ) + ) diff --git a/server/app/auth/rate_limit.py b/server/app/auth/rate_limit.py new file mode 100644 index 0000000..d4008fa --- /dev/null +++ b/server/app/auth/rate_limit.py @@ -0,0 +1,38 @@ +from __future__ import annotations + +import threading +import time +from collections import deque + + +class SlidingWindowLimiter: + def __init__(self, limit: int, window_seconds: int = 60) -> None: + self.limit = max(1, limit) + self.window_seconds = window_seconds + self._events: dict[str, deque[float]] = {} + self._lock = threading.Lock() + + def allow(self, key: str) -> bool: + now = time.monotonic() + cutoff = now - self.window_seconds + with self._lock: + events = self._events.setdefault(key, deque()) + while events and events[0] < cutoff: + events.popleft() + if len(events) >= self.limit: + return False + events.append(now) + return True + + +_limiters: dict[int, SlidingWindowLimiter] = {} +_limiters_lock = threading.Lock() + + +def limiter_for(limit: int) -> SlidingWindowLimiter: + with _limiters_lock: + limiter = _limiters.get(limit) + if limiter is None: + limiter = SlidingWindowLimiter(limit) + _limiters[limit] = limiter + return limiter diff --git a/server/app/auth/sessions.py b/server/app/auth/sessions.py index d2feca0..54c758b 100644 --- a/server/app/auth/sessions.py +++ b/server/app/auth/sessions.py @@ -44,7 +44,7 @@ return hashlib.sha256(token.encode("utf-8")).hexdigest() -def _to_current(user: User) -> CurrentUser: +def to_current_user(user: User) -> CurrentUser: return CurrentUser( id=user.id, sub=user.sub, @@ -100,7 +100,7 @@ row.last_used_at = now session.commit() - return _to_current(user) + return to_current_user(user) def revoke_session(database: Database, token: str) -> None: @@ -141,7 +141,7 @@ raise ValueError("User not found") user.locale = normalized session.flush() - return _to_current(user) + return to_current_user(user) def with_locale(user: CurrentUser, locale: str | None) -> CurrentUser: diff --git a/server/app/auth/users.py b/server/app/auth/users.py index deb9bb3..54b7553 100644 --- a/server/app/auth/users.py +++ b/server/app/auth/users.py @@ -8,23 +8,7 @@ from ..storage.db import Database from ..storage.models import User, utcnow -from .sessions import CurrentUser - - -def _to_current(user: User) -> CurrentUser: - return CurrentUser( - id=user.id, - sub=user.sub, - email=user.email, - display_name=user.display_name, - profile=dict(user.profile or {}), - locale=user.locale, - system_role=user.system_role, - status=user.status, - client_roles=tuple(user.client_roles or []), - permissions=tuple(user.permissions or []), - blocked_at=user.blocked_at, - ) +from .sessions import CurrentUser, to_current_user def upsert_user_from_auth( @@ -76,7 +60,7 @@ user.blocked_at = None user.updated_at = utcnow() session.flush() - return _to_current(user) + return to_current_user(user) def serialize_user(user: CurrentUser) -> dict[str, Any]: diff --git a/server/app/config.py b/server/app/config.py index 667a361..57cbb76 100644 --- a/server/app/config.py +++ b/server/app/config.py @@ -55,6 +55,25 @@ "GNEXUS_BOOK_AUTH_COOKIE_SECURE", secure_default ).lower() in {"1", "true", "yes", "on"} + self.mcp_host = os.environ.get("GNEXUS_BOOK_MCP_HOST", "0.0.0.0") + self.mcp_port = int(os.environ.get("GNEXUS_BOOK_MCP_PORT", "8001")) + self.mcp_static_token = os.environ.get("GNEXUS_BOOK_MCP_TOKEN") + self.mcp_key_rate_limit = int( + os.environ.get("GNEXUS_BOOK_MCP_KEY_RATE_LIMIT", "30") + ) + self.mcp_request_rate_limit = int( + os.environ.get("GNEXUS_BOOK_MCP_REQUEST_RATE_LIMIT", "300") + ) + self.internal_key_secret = os.environ.get("GNEXUS_BOOK_INTERNAL_KEY_SECRET") + self.internal_allowlist = tuple( + item.strip() + for item in os.environ.get("GNEXUS_BOOK_INTERNAL_ALLOWLIST", "").split(",") + if item.strip() + ) + self.internal_rate_limit = int( + os.environ.get("GNEXUS_BOOK_INTERNAL_RATE_LIMIT", "60") + ) + @property def auth_enabled(self) -> bool: return bool( diff --git a/server/app/mcp_http.py b/server/app/mcp_http.py new file mode 100644 index 0000000..dc342c4 --- /dev/null +++ b/server/app/mcp_http.py @@ -0,0 +1,20 @@ +from __future__ import annotations + +from .auth.mcp_guard import McpTokenGuard +from .config import get_settings +from .mcp_server import mcp + +# The inner FastMCP app routes at /mcp-protocol/ (configured on the FastMCP +# instance); the guard rejects requests without a personal mcp_* key. +app = McpTokenGuard(mcp.streamable_http_app(), get_settings) + + +def run() -> None: + import uvicorn + + settings = get_settings() + uvicorn.run(app, host=settings.mcp_host, port=settings.mcp_port) + + +if __name__ == "__main__": + run() diff --git a/server/app/mcp_server.py b/server/app/mcp_server.py index c14b176..1dad639 100644 --- a/server/app/mcp_server.py +++ b/server/app/mcp_server.py @@ -9,6 +9,7 @@ from pydantic import Field from .auth.actor import Actor +from .auth.mcp_guard import mcp_actor, mcp_write_denied from .config import Settings from .freshness import build_freshness_report from .git_adapter import CommitRequest, GitAdapter @@ -73,6 +74,12 @@ - Use document_history, document_version, document_diff, and restore_document_version for version work. - Restoring a version creates a new version; it never rewrites history. +Transport and keys: +- Production agents connect over streamable HTTP at /mcp-protocol/ with a personal mcp_* key. +- Mutating tools accept is_user; set it true only when the key owner explicitly acts as themselves. +- Tool errors are returned as data: {"error": 401|403|..., "detail": "..."}. +- A read-only key cannot call mutating tools. + For propose_inventory_item_change, pass concrete top-level arguments, not a wrapper: inventory_type="hosts", item_id="bserv", mode="create", patch={"ip_address": "192.168.1.130", "user": "bserv"}, summary="Document bserv host". The patch object is the inventory item fields to create or update. @@ -252,8 +259,12 @@ content: Annotated[str, Field(description="Full Markdown document content, including frontmatter when the target document uses it.")], summary: Annotated[str, Field(description="Short factual change summary used for the pending change and later commit message.")], reason: Annotated[str, Field(description="Why this change is needed; mention the source of the fact when useful.")] = "", + is_user: Annotated[bool, Field(description="Set true only when the key owner explicitly acts as themselves; default actions are attributed to the agent.")] = False, ) -> dict[str, Any]: """Create a pending Markdown document change. Pass path, content, summary, and optional reason as top-level arguments.""" + denied = mcp_write_denied() + if denied: + return denied request = ProposedChangeRequest( kind="doc", target=path, @@ -261,7 +272,7 @@ reason=reason, payload={"content": content}, ) - return _pending().create(request) + return _pending().create(request, actor=mcp_actor(is_user)) def propose_inventory_item_change( @@ -271,8 +282,12 @@ summary: Annotated[str, Field(description="Short factual summary of the inventory change.")], reason: Annotated[str, Field(description="Why this inventory fact should be persisted; mention the source when useful.")] = "", mode: Annotated[Literal["update", "create"], Field(description="'create' for a new inventory item; 'update' to patch an existing item.")] = "update", + is_user: Annotated[bool, Field(description="Set true only when the key owner explicitly acts as themselves; default actions are attributed to the agent.")] = False, ) -> dict[str, Any]: """Create a pending inventory change. Use top-level arguments: inventory_type, item_id, patch, summary, reason, mode.""" + denied = mcp_write_denied() + if denied: + return denied request = ProposedChangeRequest( kind="inventory-item", target=f"{inventory_type}/{item_id}", @@ -280,15 +295,20 @@ reason=reason, payload={"mode": mode, "patch": patch}, ) - return _pending().create(request) + return _pending().create(request, actor=mcp_actor(is_user)) -def apply_pending_change(change_id: str) -> dict[str, Any]: +def apply_pending_change(change_id: str, is_user: bool = False) -> dict[str, Any]: """Apply one pending knowledge change and roll it back automatically if validation fails.""" - return _pending().apply(change_id) + denied = mcp_write_denied() + if denied: + return denied + return _pending().apply(change_id, actor=mcp_actor(is_user)) -def commit_changes(summary: str, files: list[str], details: str = "") -> dict[str, Any]: +def commit_changes( + summary: str, files: list[str], details: str = "", is_user: bool = False +) -> dict[str, Any]: """Validate the repository and create a local Git commit for selected documentation files.""" settings = _settings() if settings.storage_backend == "db": @@ -299,10 +319,16 @@ return _git().commit(CommitRequest(summary=summary, details=details, files=files)) -def update_doc(path: str, content: str, summary: str, reason: str = "") -> dict[str, Any]: +def update_doc( + path: str, content: str, summary: str, reason: str = "", is_user: bool = False +) -> dict[str, Any]: """For simple full-document updates: create pending change, apply, validate, and commit in one call.""" - change = propose_doc_change(path=path, content=content, summary=summary, reason=reason) - applied = apply_pending_change(str(change["id"])) + change = propose_doc_change( + path=path, content=content, summary=summary, reason=reason, is_user=is_user + ) + if "error" in change: + return change + applied = apply_pending_change(str(change["id"]), is_user=is_user) if _settings().storage_backend == "db": return { "change": applied, @@ -347,9 +373,12 @@ def restore_document_version( - path: str, version_no: int, summary: str = "" + path: str, version_no: int, summary: str = "", is_user: bool = False ) -> dict[str, Any]: """Restore a document by creating a new version with the content of an older version.""" + denied = mcp_write_denied() + if denied: + return denied settings = _settings() if settings.storage_backend != "db": raise RuntimeError("Document restore is available in database mode") @@ -360,13 +389,14 @@ version_no, summary=summary or None, via="mcp", - actor=Actor(kind="agent", via="mcp"), + actor=mcp_actor(is_user), ) mcp = FastMCP( "gnexus-book", instructions=MCP_INSTRUCTIONS, + streamable_http_path="/mcp-protocol/", ) @@ -442,6 +472,11 @@ transport = os.environ.get("GNEXUS_BOOK_MCP_TRANSPORT", "stdio") if transport not in {"stdio", "sse", "streamable-http"}: raise SystemExit("GNEXUS_BOOK_MCP_TRANSPORT must be stdio, sse, or streamable-http") + if transport == "streamable-http": + from .mcp_http import run + + run() + return mcp.run(transport=transport) # type: ignore[arg-type] diff --git a/server/app/storage/models.py b/server/app/storage/models.py index 27bdfdf..e48abf8 100644 --- a/server/app/storage/models.py +++ b/server/app/storage/models.py @@ -69,6 +69,37 @@ ip_address: Mapped[str | None] = mapped_column(Text) +class McpToken(Base): + __tablename__ = "mcp_tokens" + __table_args__ = ( + Index( + "uq_mcp_tokens_user_consumer_active", + "user_id", + "consumer", + unique=True, + postgresql_where=text("revoked_at IS NULL"), + ), + Index("ix_mcp_tokens_user_id", "user_id"), + ) + + id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4) + user_id: Mapped[uuid.UUID] = mapped_column( + UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), nullable=False + ) + consumer: Mapped[str] = mapped_column(Text, nullable=False) + name: Mapped[str] = mapped_column(Text, nullable=False) + role: Mapped[str | None] = mapped_column(Text) + scopes: Mapped[list[str]] = mapped_column( + JSONB, nullable=False, default=list, server_default=text("'[]'::jsonb") + ) + token_hash: Mapped[str] = mapped_column(Text, unique=True, nullable=False) + token_hint: Mapped[str] = mapped_column(Text, nullable=False) + created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, default=utcnow) + last_used_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True)) + revoked_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True)) + stale_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True)) + + class OAuthState(Base): __tablename__ = "oauth_states"