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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meta-data-mcp
-Version: 2.3.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

meta_data_mcp-2.3.2/meta_data_mcp/__init__.py

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

{meta_data_mcp-2.3.0 → meta_data_mcp-2.3.2}/meta_data_mcp/oauth_provider.py

@@ -87,6 +87,22 @@ class InMemoryOAuthProvider(
         }
         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)
@@ -136,7 +152,12 @@ class InMemoryOAuthProvider(
         client: OAuthClientInformationFull,
         authorization_code: AuthorizationCode,
     ) -> OAuthToken:
-        """Validate PKCE, consume the code, and issue access + refresh tokens."""
+        """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)
 

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

@@ -75,6 +75,19 @@ class RemoteClient:
         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"

{meta_data_mcp-2.3.0 → meta_data_mcp-2.3.2}/meta_data_mcp/server.py

@@ -390,7 +390,18 @@ async def run_server(
 
         oauth_issuer = os.getenv("META_DATA_MCP_OAUTH_ISSUER")
         if oauth_issuer:
-            from mcp.server.auth.routes import create_auth_routes
+            try:
+                from mcp.server.auth.routes import (
+                    create_auth_routes,
+                    create_protected_resource_routes,
+                )
+            except ImportError as exc:
+                raise RuntimeError(
+                    "OAuth support requires an MCP SDK version that provides "
+                    "`mcp.server.auth.routes.create_protected_resource_routes`. "
+                    "Please upgrade the `mcp` package to a compatible version or "
+                    "unset META_DATA_MCP_OAUTH_ISSUER to disable OAuth."
+                ) from exc
             from mcp.server.auth.settings import ClientRegistrationOptions
             from pydantic import AnyHttpUrl
             from starlette.responses import HTMLResponse
@@ -400,16 +411,46 @@ async def run_server(
 
             oauth_provider = InMemoryOAuthProvider(issuer_url=oauth_issuer)
 
+            import html as _html
+            from urllib.parse import urlencode, urlsplit, urlunsplit, parse_qsl
+
+            def _add_query_params(base_url: str, params: dict[str, str]) -> str:
+                """Append params to base_url, preserving any existing query string.
+
+                Uses list-of-tuples rather than a dict so that existing duplicate
+                or blank-value query params are never silently dropped. Only the
+                keys explicitly provided in ``params`` are added/overwritten.
+                """
+                parts = urlsplit(base_url)
+                # Keep all existing params except any that we're explicitly setting,
+                # then append the new ones. This preserves duplicate keys and blanks.
+                existing = [
+                    (k, v)
+                    for k, v in parse_qsl(parts.query, keep_blank_values=True)
+                    if k not in params
+                ]
+                merged = existing + list(params.items())
+                return urlunsplit(parts._replace(query=urlencode(merged)))
+
             # Consent page — GET /oauth/consent?session=<token>
             async def consent_get(request: Request) -> HTMLResponse:
                 session_token = request.query_params.get("session", "")
-                session = oauth_provider._auth_sessions.get(session_token)
+                # Use the provider's own peek method so expiry is enforced
+                # without consuming the session (POST /approve does that).
+                session = oauth_provider.peek_session(session_token)
                 if session is None:
                     return HTMLResponse(
                         "<h1>Session expired or invalid.</h1>", status_code=400
                     )
-                client_name = session.get("client_name", session.get("client_id", "?"))
-                scopes_html = ", ".join(session.get("scopes", [])) or "(default)"
+                # HTML-escape all values derived from dynamic client registration
+                # to prevent XSS via a maliciously crafted client_name or scope.
+                client_name = _html.escape(
+                    str(session.get("client_name", session.get("client_id", "?")))
+                )
+                scopes_html = _html.escape(
+                    ", ".join(session.get("scopes", [])) or "(default)"
+                )
+                session_token_escaped = _html.escape(session_token)
                 return HTMLResponse(f"""<!DOCTYPE html>
 <html lang="en"><head><meta charset="utf-8">
 <title>Authorize — meta-data-mcp</title>
@@ -424,7 +465,7 @@ async def run_server(
   <p><strong>{client_name}</strong> is requesting access to your meta-data-mcp server.</p>
   <p class="scope">Requested scopes: {scopes_html}</p>
   <form method="POST" action="/oauth/consent/approve">
-    <input type="hidden" name="session" value="{session_token}">
+    <input type="hidden" name="session" value="{session_token_escaped}">
     <button type="submit" class="approve">Approve</button>
     <button type="submit" name="deny" value="1" class="deny">Deny</button>
   </form>
@@ -433,7 +474,6 @@ async def run_server(
             # Consent approval — POST /oauth/consent/approve
             async def consent_post(request: Request) -> HTMLResponse:
                 from starlette.responses import RedirectResponse
-                from urllib.parse import urlencode
 
                 form = await request.form()
                 session_token = str(form.get("session", ""))
@@ -444,35 +484,98 @@ async def run_server(
                     )
                 if form.get("deny"):
                     redirect_uri = session["redirect_uri"]
-                    params = {"error": "access_denied"}
+                    params: dict[str, str] = {"error": "access_denied"}
                     if session.get("state"):
                         params["state"] = session["state"]
                     return RedirectResponse(
-                        f"{redirect_uri}?{urlencode(params)}", status_code=302
+                        _add_query_params(redirect_uri, params), status_code=302
                     )
                 code = oauth_provider.create_authorization_code(session)
                 params = {"code": code}
                 if session.get("state"):
                     params["state"] = session["state"]
                 return RedirectResponse(
-                    f"{session['redirect_uri']}?{urlencode(params)}", status_code=302
+                    _add_query_params(session["redirect_uri"], params), status_code=302
+                )
+
+            configured_resource_public_url = (
+                os.getenv("META_DATA_MCP_PUBLIC_URL", "").strip() or None
+            )
+            resource_public_url = configured_resource_public_url or oauth_issuer
+            validated_resource_url = AnyHttpUrl(resource_public_url)
+            validated_oauth_issuer = AnyHttpUrl(oauth_issuer)
+
+            if configured_resource_public_url is None:
+                log.info(
+                    "META_DATA_MCP_PUBLIC_URL is not set; defaulting protected "
+                    "resource URL to META_DATA_MCP_OAUTH_ISSUER (%s)",
+                    oauth_issuer,
+                )
+            elif hmac.compare_digest(
+                resource_public_url.rstrip("/"), oauth_issuer.rstrip("/")
+            ):
+                log.info(
+                    "META_DATA_MCP_PUBLIC_URL matches META_DATA_MCP_OAUTH_ISSUER; "
+                    "using %s for both protected resource URL and issuer",
+                    resource_public_url,
+                )
+            else:
+                log.warning(
+                    "META_DATA_MCP_PUBLIC_URL (%s) differs from "
+                    "META_DATA_MCP_OAUTH_ISSUER (%s); using "
+                    "META_DATA_MCP_PUBLIC_URL for the protected resource URL "
+                    "and META_DATA_MCP_OAUTH_ISSUER for the authorization server "
+                    "issuer",
+                    resource_public_url,
+                    oauth_issuer,
                 )
 
+            # Serve both RFC 9728 variants:
+            # - Base: /.well-known/oauth-protected-resource
+            # - Path: /.well-known/oauth-protected-resource/sse
+            # Clients (e.g. Claude Desktop) probe both.
+            protected_resource_routes = create_protected_resource_routes(
+                resource_url=validated_resource_url,
+                authorization_servers=[validated_oauth_issuer],
+                scopes_supported=["opendata"],
+            ) + create_protected_resource_routes(
+                resource_url=AnyHttpUrl(resource_public_url.rstrip("/") + "/sse"),
+                authorization_servers=[validated_oauth_issuer],
+                scopes_supported=["opendata"],
+            )
             oauth_routes = create_auth_routes(
                 provider=oauth_provider,
-                issuer_url=AnyHttpUrl(oauth_issuer),
+                issuer_url=validated_oauth_issuer,
                 client_registration_options=ClientRegistrationOptions(
                     enabled=True,
                     valid_scopes=["opendata"],
                     default_scopes=["opendata"],
                 ),
             )
-            extra_routes = oauth_routes + [
-                Route("/oauth/consent", endpoint=consent_get, methods=["GET"]),
-                Route(
-                    "/oauth/consent/approve", endpoint=consent_post, methods=["POST"]
-                ),
-            ]
+            from starlette.responses import RedirectResponse as _RedirectResponse
+
+            async def oidc_discovery(_request):
+                return _RedirectResponse(
+                    "/.well-known/oauth-authorization-server", status_code=301
+                )
+
+            extra_routes = (
+                protected_resource_routes
+                + oauth_routes
+                + [
+                    Route(
+                        "/.well-known/openid-configuration",
+                        endpoint=oidc_discovery,
+                        methods=["GET"],
+                    ),
+                    Route("/oauth/consent", endpoint=consent_get, methods=["GET"]),
+                    Route(
+                        "/oauth/consent/approve",
+                        endpoint=consent_post,
+                        methods=["POST"],
+                    ),
+                ]
+            )
             log.info(f"OAuth 2.0 enabled — issuer: {oauth_issuer}")
 
         app = Starlette(

{meta_data_mcp-2.3.0 → meta_data_mcp-2.3.2}/meta_data_mcp/ui_resources/app_news_tone_v1.html

@@ -374,6 +374,10 @@
       return m ? m[1] : '';
     }
 
+    function safeUrl(url) {
+      return url && /^https?:\/\//i.test(url) ? url : null;
+    }
+
     function sortByDate(arr) {
       return arr.slice().sort(function (a, b) {
         return a.date < b.date ? -1 : a.date > b.date ? 1 : 0;
@@ -550,9 +554,10 @@
       row('Domain', ev.domain || '-');
       row('Language', ev.language || '-');
       card.appendChild(dl);
-      if (ev.url) {
+      var safe = safeUrl(ev.url);
+      if (safe) {
         card.appendChild(el('a', {
-          href: ev.url, target: '_blank', rel: 'noopener noreferrer',
+          href: safe, target: '_blank', rel: 'noopener noreferrer',
           text: ev.url,
         }));
       }
@@ -665,7 +670,7 @@
           renderRightPanel();
         });
         g.addEventListener('click', function () {
-          if (ev.url) window.open(ev.url, '_blank', 'noopener,noreferrer');
+          var u = safeUrl(ev.url); if (u) window.open(u, '_blank', 'noopener,noreferrer');
         });
         var titleEl = svg('title');
         titleEl.textContent = ev.date + ' - ' + (ev.country || '-') +
@@ -827,7 +832,7 @@
           renderRightPanel();
         });
         tr.addEventListener('click', function () {
-          if (ev.url) window.open(ev.url, '_blank', 'noopener,noreferrer');
+          var u = safeUrl(ev.url); if (u) window.open(u, '_blank', 'noopener,noreferrer');
         });
         tbody.appendChild(tr);
       });

{meta_data_mcp-2.3.0 → meta_data_mcp-2.3.2}/pyproject.toml

@@ -35,7 +35,7 @@ dependencies = [
     "anyio>=4.0.0",
     "click>=8.1.7",
     "httpx>=0.28.0",
-    "mcp>=1.0.0",
+    "mcp>=1.9.0",
     "pydantic>=2.0.0",
     "pyyaml>=6.0",
     "starlette>=1.0.0",

meta_data_mcp-2.3.0/meta_data_mcp/__init__.py

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