meta-data-mcp 2.2.0__tar.gz → 2.3.2__tar.gz

{meta_data_mcp-2.2.0 → meta_data_mcp-2.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meta-data-mcp
-Version: 2.2.0
+Version: 2.3.2
 Summary: MCP server exposing 60+ open data providers to LLM clients via intelligent metadata routing.
 Project-URL: Homepage, https://github.com/derekslinz/meta-data-mcp
 Project-URL: Repository, https://github.com/derekslinz/meta-data-mcp
@@ -41,7 +41,7 @@ Requires-Python: >=3.12
 Requires-Dist: anyio>=4.0.0
 Requires-Dist: click>=8.1.7
 Requires-Dist: httpx>=0.28.0
-Requires-Dist: mcp>=1.0.0
+Requires-Dist: mcp>=1.9.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: starlette>=1.0.0
@@ -373,6 +373,7 @@ A few bundled plugins accept optional API keys for higher rate limits. Set these
 |---|---|
 | `META_DATA_MCP_PRELOAD` | Comma-separated plugin ids to activate at startup, or `*` for all. Default unset = discovery-only (~13 meta tools). |
 | `META_DATA_MCP_AUTH_TOKEN` | When set on the SSE transport, requires `Authorization: Bearer <token>` on `/sse` and `/messages`. |
+| `META_DATA_MCP_OAUTH_ISSUER` | Enable OAuth 2.0 Authorization Code + PKCE. Set to the server's public base URL (e.g. `http://localhost:8000`). Mounts `/.well-known/oauth-authorization-server`, `/register`, `/authorize`, `/token`, `/revoke`, and a consent page at `/oauth/consent`. Coexists with `META_DATA_MCP_AUTH_TOKEN` — both auth methods remain valid simultaneously. |
 | `META_DATA_MCP_PROVENANCE` | Truthy (`1`, `true`, `yes`, `on`) enables a `meta-data-mcp/provenance` entry on every tool-call result's first content block's `_meta`, carrying `sha256` and `timestamp` (ISO 8601 UTC, ms precision). The digest covers the canonical `(tool, arguments, content)` envelope — content blocks dumped via `model_dump(mode="json", by_alias=True, exclude_none=True)` with `_meta` stripped, JSON-serialized with `sort_keys=True, separators=(",",":"), ensure_ascii=True`. Binding tool name + arguments into the hash means audit logs can distinguish "tool A returned X" from "tool B returned X". Default off — opt in when you need tamper-evidence. See `meta_data_mcp/provenance.py` module docstring for the verbatim receiver recipe. |
 
 ## Transports

{meta_data_mcp-2.2.0 → meta_data_mcp-2.3.2}/README.md

@@ -323,6 +323,7 @@ A few bundled plugins accept optional API keys for higher rate limits. Set these
 |---|---|
 | `META_DATA_MCP_PRELOAD` | Comma-separated plugin ids to activate at startup, or `*` for all. Default unset = discovery-only (~13 meta tools). |
 | `META_DATA_MCP_AUTH_TOKEN` | When set on the SSE transport, requires `Authorization: Bearer <token>` on `/sse` and `/messages`. |
+| `META_DATA_MCP_OAUTH_ISSUER` | Enable OAuth 2.0 Authorization Code + PKCE. Set to the server's public base URL (e.g. `http://localhost:8000`). Mounts `/.well-known/oauth-authorization-server`, `/register`, `/authorize`, `/token`, `/revoke`, and a consent page at `/oauth/consent`. Coexists with `META_DATA_MCP_AUTH_TOKEN` — both auth methods remain valid simultaneously. |
 | `META_DATA_MCP_PROVENANCE` | Truthy (`1`, `true`, `yes`, `on`) enables a `meta-data-mcp/provenance` entry on every tool-call result's first content block's `_meta`, carrying `sha256` and `timestamp` (ISO 8601 UTC, ms precision). The digest covers the canonical `(tool, arguments, content)` envelope — content blocks dumped via `model_dump(mode="json", by_alias=True, exclude_none=True)` with `_meta` stripped, JSON-serialized with `sort_keys=True, separators=(",",":"), ensure_ascii=True`. Binding tool name + arguments into the hash means audit logs can distinguish "tool A returned X" from "tool B returned X". Default off — opt in when you need tamper-evidence. See `meta_data_mcp/provenance.py` module docstring for the verbatim receiver recipe. |
 
 ## Transports

meta_data_mcp-2.3.2/meta_data_mcp/__init__.py

@@ -0,0 +1 @@
+__version__ = "2.3.2"

meta_data_mcp-2.3.2/meta_data_mcp/oauth_provider.py

@@ -0,0 +1,270 @@
+"""In-memory OAuth 2.0 Authorization Server provider for meta-data-mcp.
+
+Implements the MCP SDK's ``OAuthAuthorizationServerProvider`` Protocol with
+full in-memory storage (tokens are lost on server restart). Suitable for
+development, single-node deployments, and operator-managed SSE servers.
+
+Enable OAuth by setting ``META_DATA_MCP_OAUTH_ISSUER`` (e.g.
+``http://localhost:8000``). This coexists with the existing bearer-token
+auth (``META_DATA_MCP_AUTH_TOKEN``) — both remain valid simultaneously.
+
+Flow (Authorization Code + PKCE + Dynamic Client Registration):
+  1. Client POSTs to ``/register`` → receives ``client_id`` + ``client_secret``
+  2. Client opens ``/authorize?client_id=…&code_challenge=…&redirect_uri=…``
+  3. User is redirected to ``/oauth/consent?session=…``
+  4. User approves → ``/oauth/consent/approve`` creates an auth code and
+     redirects the browser to the client's ``redirect_uri?code=…&state=…``
+  5. Client POSTs to ``/token`` with ``code`` + ``code_verifier`` → tokens
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import secrets
+import time
+from typing import Any
+
+from mcp.server.auth.provider import (
+    AccessToken,
+    AuthorizationCode,
+    AuthorizationParams,
+    OAuthAuthorizationServerProvider,
+    RefreshToken,
+)
+from mcp.shared.auth import OAuthClientInformationFull, OAuthToken
+
+
+class InMemoryOAuthProvider(
+    OAuthAuthorizationServerProvider[AuthorizationCode, RefreshToken, AccessToken]
+):
+    """Stateful in-memory OAuth provider.
+
+    All state is local to the process — tokens are lost on restart.
+    Thread-safe for asyncio (single-threaded event loop) but not safe for
+    multi-process deployments; use a shared cache (Redis/Postgres) for HA.
+    """
+
+    def __init__(self, issuer_url: str) -> None:
+        self.issuer_url = issuer_url.rstrip("/")
+        # Storage maps: key → object
+        self._clients: dict[str, OAuthClientInformationFull] = {}
+        self._auth_sessions: dict[str, dict[str, Any]] = {}  # consent-page sessions
+        self._auth_codes: dict[str, AuthorizationCode] = {}
+        self._access_tokens: dict[str, AccessToken] = {}
+        self._refresh_tokens: dict[str, RefreshToken] = {}
+
+    # ------------------------------------------------------------------
+    # Client management
+    # ------------------------------------------------------------------
+
+    async def get_client(self, client_id: str) -> OAuthClientInformationFull | None:
+        return self._clients.get(client_id)
+
+    async def register_client(self, client_info: OAuthClientInformationFull) -> None:
+        if client_info.client_id is None:
+            raise ValueError("client_id is required")
+        self._clients[client_info.client_id] = client_info
+
+    # ------------------------------------------------------------------
+    # Authorization (consent page redirect)
+    # ------------------------------------------------------------------
+
+    async def authorize(
+        self, client: OAuthClientInformationFull, params: AuthorizationParams
+    ) -> str:
+        """Create a short-lived consent session and return the consent page URL."""
+        session_token = secrets.token_urlsafe(32)
+        self._auth_sessions[session_token] = {
+            "client_id": client.client_id,
+            "client_name": getattr(client, "client_name", client.client_id),
+            "code_challenge": params.code_challenge,
+            "redirect_uri": str(params.redirect_uri),
+            "redirect_uri_provided_explicitly": params.redirect_uri_provided_explicitly,
+            "scopes": params.scopes or [],
+            "state": params.state,
+            "expires_at": time.time() + 600,  # 10-minute consent window
+        }
+        return f"{self.issuer_url}/oauth/consent?session={session_token}"
+
+    def peek_session(self, session_token: str) -> dict[str, Any] | None:
+        """Return a shallow copy of a pending consent session without consuming it.
+
+        Used by the GET consent page to display session details while leaving
+        the session intact for the POST approval step. Returns a shallow copy
+        so callers cannot accidentally mutate internal provider state.
+        Returns None for unknown or expired sessions.
+        """
+        session = self._auth_sessions.get(session_token)
+        if session is None:
+            return None
+        if time.time() > session["expires_at"]:
+            self._auth_sessions.pop(session_token, None)
+            return None
+        return dict(session)  # shallow copy — callers cannot mutate stored state
+
+    def consume_session(self, session_token: str) -> dict[str, Any] | None:
+        """Retrieve and remove a pending consent session (one-shot)."""
+        session = self._auth_sessions.pop(session_token, None)
+        if session is None:
+            return None
+        if time.time() > session["expires_at"]:
+            return None
+        return session
+
+    def create_authorization_code(self, session: dict[str, Any]) -> str:
+        """Issue an authorization code from an approved consent session."""
+        code = secrets.token_urlsafe(32)
+        self._auth_codes[code] = AuthorizationCode(
+            code=code,
+            scopes=session["scopes"],
+            expires_at=time.time() + 300,  # 5-minute code lifetime
+            client_id=session["client_id"],
+            code_challenge=session["code_challenge"],
+            redirect_uri=session["redirect_uri"],  # type: ignore[arg-type]
+            redirect_uri_provided_explicitly=session[
+                "redirect_uri_provided_explicitly"
+            ],
+        )
+        return code
+
+    # ------------------------------------------------------------------
+    # Authorization code exchange
+    # ------------------------------------------------------------------
+
+    async def load_authorization_code(
+        self,
+        client: OAuthClientInformationFull,
+        authorization_code: str,
+    ) -> AuthorizationCode | None:
+        code = self._auth_codes.get(authorization_code)
+        if code is None:
+            return None
+        if time.time() > code.expires_at:
+            del self._auth_codes[authorization_code]
+            return None
+        if code.client_id != client.client_id:
+            return None
+        return code
+
+    async def exchange_authorization_code(
+        self,
+        client: OAuthClientInformationFull,
+        authorization_code: AuthorizationCode,
+    ) -> OAuthToken:
+        """Consume the authorization code and issue access + refresh tokens.
+
+        PKCE validation (code_verifier vs code_challenge) is performed by the
+        MCP SDK's ``TokenHandler`` before calling this method — this provider
+        does not repeat that check.
+        """
+        # Remove the used code (one-shot).
+        self._auth_codes.pop(authorization_code.code, None)
+
+        access_token_str = secrets.token_urlsafe(32)
+        refresh_token_str = secrets.token_urlsafe(32)
+
+        client_id = client.client_id or ""
+        self._access_tokens[access_token_str] = AccessToken(
+            token=access_token_str,
+            client_id=client_id,
+            scopes=authorization_code.scopes,
+            expires_at=int(time.time()) + 3600,  # 1-hour access token
+        )
+        self._refresh_tokens[refresh_token_str] = RefreshToken(
+            token=refresh_token_str,
+            client_id=client_id,
+            scopes=authorization_code.scopes,
+        )
+
+        return OAuthToken(
+            access_token=access_token_str,
+            token_type="Bearer",
+            expires_in=3600,
+            refresh_token=refresh_token_str,
+            scope=" ".join(authorization_code.scopes),
+        )
+
+    # ------------------------------------------------------------------
+    # Refresh token exchange
+    # ------------------------------------------------------------------
+
+    async def load_refresh_token(
+        self,
+        client: OAuthClientInformationFull,
+        refresh_token: str,
+    ) -> RefreshToken | None:
+        rt = self._refresh_tokens.get(refresh_token)
+        if rt is None or rt.client_id != client.client_id:
+            return None
+        return rt
+
+    async def exchange_refresh_token(
+        self,
+        client: OAuthClientInformationFull,
+        refresh_token: RefreshToken,
+        scopes: list[str],
+    ) -> OAuthToken:
+        """Issue a new access token (and rotate the refresh token)."""
+        # Invalidate the old refresh token.
+        self._refresh_tokens.pop(refresh_token.token, None)
+
+        effective_scopes = scopes or refresh_token.scopes
+        new_access = secrets.token_urlsafe(32)
+        new_refresh = secrets.token_urlsafe(32)
+        client_id = client.client_id or ""
+
+        self._access_tokens[new_access] = AccessToken(
+            token=new_access,
+            client_id=client_id,
+            scopes=effective_scopes,
+            expires_at=int(time.time()) + 3600,
+        )
+        self._refresh_tokens[new_refresh] = RefreshToken(
+            token=new_refresh,
+            client_id=client_id,
+            scopes=effective_scopes,
+        )
+
+        return OAuthToken(
+            access_token=new_access,
+            token_type="Bearer",
+            expires_in=3600,
+            refresh_token=new_refresh,
+            scope=" ".join(effective_scopes),
+        )
+
+    # ------------------------------------------------------------------
+    # Access token verification
+    # ------------------------------------------------------------------
+
+    async def verify_access_token(self, token: str) -> AccessToken | None:
+        at = self._access_tokens.get(token)
+        if at is None:
+            return None
+        if at.expires_at is not None and time.time() > at.expires_at:
+            del self._access_tokens[token]
+            return None
+        return at
+
+    # ------------------------------------------------------------------
+    # Token revocation
+    # ------------------------------------------------------------------
+
+    async def revoke_token(
+        self,
+        token: AccessToken | RefreshToken,
+    ) -> None:
+        self._access_tokens.pop(token.token, None)
+        self._refresh_tokens.pop(token.token, None)
+
+
+# ---------------------------------------------------------------------------
+# PKCE helper (used by tests; not part of the Protocol)
+# ---------------------------------------------------------------------------
+
+
+def compute_pkce_challenge(code_verifier: str) -> str:
+    """Return the S256 code_challenge for a given verifier."""
+    digest = hashlib.sha256(code_verifier.encode()).digest()
+    return base64.urlsafe_b64encode(digest).rstrip(b"=").decode()

{meta_data_mcp-2.2.0 → meta_data_mcp-2.3.2}/meta_data_mcp/sdk/remote.py

@@ -73,11 +73,30 @@ class RemoteClient:
         base_url: str,
         token: str | None = None,
         timeout: float = 30.0,
+        auth: Any = None,
     ) -> None:
+        """
+        Args:
+            base_url: Root URL of the server (e.g. ``"https://mcp.example.com"``).
+                The ``/sse`` path is appended automatically.
+            token: Bearer token for the server's auth middleware.
+                Falls back to ``META_DATA_MCP_AUTH_TOKEN`` env var.
+                Mutually exclusive with ``auth``.
+            timeout: Connection timeout in seconds (default 30 s).
+            auth: MCP-compatible OAuth client provider for Authorization Code
+                + PKCE flows.  Accepts any object implementing the
+                ``mcp.client.sse`` ``auth=`` interface (e.g. a custom
+                ``OAuthClientProvider``).  Mutually exclusive with ``token``.
+        """
+        if token is not None and auth is not None:
+            raise ValueError(
+                "token and auth are mutually exclusive — use one or the other"
+            )
         self._base_url = base_url.rstrip("/")
         self._token = (
             token if token is not None else os.getenv("META_DATA_MCP_AUTH_TOKEN")
         )
+        self._auth = auth  # mcp-compatible OAuthClientProvider, or None
         self._timeout = timeout
         self._session: Any = None  # mcp.client.session.ClientSession when active
         self._exit_stack: AsyncExitStack | None = None
@@ -91,13 +110,15 @@ class RemoteClient:
         from mcp.client.sse import sse_client
 
         self._exit_stack = AsyncExitStack()
-        streams = await self._exit_stack.enter_async_context(
-            sse_client(
-                url=f"{self._base_url}/sse",
-                headers=self._headers(),
-                timeout=self._timeout,
-            )
-        )
+        sse_kwargs: dict[str, Any] = {
+            "url": f"{self._base_url}/sse",
+            "timeout": self._timeout,
+        }
+        if self._auth is not None:
+            sse_kwargs["auth"] = self._auth
+        else:
+            sse_kwargs["headers"] = self._headers()
+        streams = await self._exit_stack.enter_async_context(sse_client(**sse_kwargs))
         self._session = await self._exit_stack.enter_async_context(
             ClientSession(*streams)
         )
@@ -131,11 +152,15 @@ class RemoteClient:
             from mcp.client.session import ClientSession
             from mcp.client.sse import sse_client
 
-            async with sse_client(
-                url=f"{self._base_url}/sse",
-                headers=self._headers(),
-                timeout=self._timeout,
-            ) as streams:
+            one_shot_kwargs: dict[str, Any] = {
+                "url": f"{self._base_url}/sse",
+                "timeout": self._timeout,
+            }
+            if self._auth is not None:
+                one_shot_kwargs["auth"] = self._auth
+            else:
+                one_shot_kwargs["headers"] = self._headers()
+            async with sse_client(**one_shot_kwargs) as streams:
                 async with ClientSession(*streams) as session:
                     await session.initialize()
                     result = await session.call_tool(name, arguments)