mcp-compress-router 3.0.0 → 3.0.1

package/build/cli/login-callback-page.js

@@ -0,0 +1,174 @@
+/**
+ * HTML pages served by the temporary loopback OAuth callback server.
+ *
+ * The pages are self-contained — inline CSS and inline SVG, no external
+ * requests — and carry the `mcp-compress-router` name, so the browser
+ * window that opens during `login` is identifiable as this tool. Every
+ * interpolated value is HTML-escaped, so OAuth error text reflected
+ * from the callback query cannot inject markup.
+ */
+/**
+ * Styles shared by every callback page. A single constant keeps the
+ * pages self-contained (no external stylesheet) and defines the layout
+ * once for both variants; the error variant only swaps the accent
+ * colors.
+ */
+const PAGE_STYLES = `      :root {
+        color-scheme: light dark;
+        --bg: #f4f5f7;
+        --card-bg: #ffffff;
+        --card-border: #e3e5e8;
+        --text: #1b1f24;
+        --muted: #656d76;
+        --code-bg: #f0f1f3;
+        --accent: #1a7f37;
+        --accent-soft: #dafbe1;
+      }
+      @media (prefers-color-scheme: dark) {
+        :root {
+          --bg: #0d1117;
+          --card-bg: #161b22;
+          --card-border: #30363d;
+          --text: #e6edf3;
+          --muted: #8b949e;
+          --code-bg: #21262d;
+          --accent: #3fb950;
+          --accent-soft: #12261e;
+        }
+      }
+      * {
+        box-sizing: border-box;
+      }
+      body {
+        margin: 0;
+        min-height: 100vh;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        padding: 24px;
+        background: var(--bg);
+        color: var(--text);
+        font-family:
+          -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial,
+          sans-serif;
+        -webkit-font-smoothing: antialiased;
+      }
+      .card {
+        width: 100%;
+        max-width: 420px;
+        padding: 40px 32px 28px;
+        background: var(--card-bg);
+        border: 1px solid var(--card-border);
+        border-radius: 14px;
+        box-shadow: 0 8px 24px rgb(0 0 0 / 8%);
+        text-align: center;
+      }
+      .card.error {
+        --accent: #cf222e;
+        --accent-soft: #ffebe9;
+      }
+      @media (prefers-color-scheme: dark) {
+        .card.error {
+          --accent: #f85149;
+          --accent-soft: #2d1416;
+        }
+      }
+      .icon {
+        display: block;
+        width: 56px;
+        height: 56px;
+        margin: 0 auto 20px;
+      }
+      h1 {
+        margin: 0 0 12px;
+        font-size: 20px;
+        font-weight: 600;
+        letter-spacing: -0.01em;
+      }
+      p {
+        margin: 0;
+        font-size: 14px;
+        line-height: 1.5;
+        color: var(--muted);
+      }
+      p + p {
+        margin-top: 12px;
+      }
+      .detail code {
+        display: inline-block;
+        padding: 3px 8px;
+        font-family: ui-monospace, SFMono-Regular, 'SF Mono', Menlo, Consolas, monospace;
+        font-size: 13px;
+        color: var(--text);
+        background: var(--code-bg);
+        border-radius: 6px;
+      }
+      footer {
+        margin-top: 28px;
+        padding-top: 16px;
+        border-top: 1px solid var(--card-border);
+        font-size: 12px;
+        color: var(--muted);
+      }`;
+/**
+ * Renders one self-contained callback page.
+ *
+ * @param options - Page content and variant.
+ * @returns A complete HTML document.
+ */
+export function renderCallbackPage(options) {
+    const title = `${escapeHtml(options.heading)} — mcp-compress-router`;
+    const detail = options.detail
+        ? `\n      <p class="detail"><code>${escapeHtml(options.detail)}</code></p>`
+        : '';
+    return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${title}</title>
+    <style>
+${PAGE_STYLES}
+    </style>
+  </head>
+  <body>
+    <main class="card ${options.kind}">
+      ${statusIcon(options.kind)}
+      <h1>${escapeHtml(options.heading)}</h1>
+      <p>${escapeHtml(options.message)}</p>${detail}
+      <footer>mcp-compress-router</footer>
+    </main>
+  </body>
+</html>
+`;
+}
+/**
+ * Builds the inline SVG status icon for a page variant.
+ *
+ * @param kind - Page variant.
+ * @returns The SVG markup (static, contains no user input).
+ */
+function statusIcon(kind) {
+    const path = kind === 'success'
+        ? '<path d="M19 29l7 7 12-14" fill="none" stroke="var(--accent)" stroke-width="4" stroke-linecap="round" stroke-linejoin="round" />'
+        : '<path d="M21 21l14 14M35 21L21 35" fill="none" stroke="var(--accent)" stroke-width="4" stroke-linecap="round" />';
+    return `<svg class="icon" viewBox="0 0 56 56" aria-hidden="true" focusable="false">
+        <circle cx="28" cy="28" r="28" fill="var(--accent-soft)" />
+        ${path}
+      </svg>`;
+}
+/**
+ * Escapes the HTML special characters in a reflected value, so an OAuth
+ * error string cannot inject markup into a callback page.
+ *
+ * @param value - The raw value to escape.
+ * @returns The escaped value.
+ */
+function escapeHtml(value) {
+    return value
+        .replaceAll('&', '&amp;')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;')
+        .replaceAll("'", '&#39;');
+}

package/build/cli/login-callback-server.js

@@ -1,5 +1,6 @@
 import { randomBytes } from 'node:crypto';
 import * as http from 'node:http';
+import { renderCallbackPage } from './login-callback-page.js';
 /**
  * Starts a temporary loopback HTTP server on `callbackPort`, runs the
  * authorization-code flow through `beginAuthorization`, and waits for the
@@ -90,76 +91,136 @@ function validateCallback(flow, url) {
     return undefined;
 }
 /**
- * Escapes the HTML special characters in a reflected value, so an OAuth
- * error string cannot inject markup into the callback page.
+ * Response headers for every callback page: self-contained HTML plus a
+ * strict CSP. The pages load no scripts and no external resources; the
+ * policy is defense in depth behind the renderer's HTML escaping.
+ */
+const PAGE_HEADERS = {
+    'Content-Type': 'text/html; charset=utf-8',
+    'Content-Security-Policy': "default-src 'none'; style-src 'unsafe-inline'",
+};
+/**
+ * Writes one callback page response.
  *
- * @param value - The raw value to escape.
- * @returns The escaped value.
+ * @param res - The server response.
+ * @param status - HTTP status code.
+ * @param html - The complete page document.
  */
-function escapeHtml(value) {
-    return value
-        .replaceAll('&', '&')
-        .replaceAll('<', '&lt;')
-        .replaceAll('>', '&gt;')
-        .replaceAll('"', '&quot;')
-        .replaceAll("'", '&#39;');
+function sendPage(res, status, html) {
+    res.writeHead(status, PAGE_HEADERS);
+    res.end(html);
 }
 /**
- * Creates the HTTP request listener for the temporary callback server.
+ * Responds with the failure page for a callback that failed validation
+ * (a stray or forged request that must not settle the flow).
+ *
+ * @param res - The server response.
+ */
+function respondInvalidCallback(res) {
+    sendPage(res, 400, renderCallbackPage({
+        kind: 'error',
+        heading: 'Authorization failed',
+        message: 'Invalid OAuth callback.',
+    }));
+}
+/**
+ * Responds with the failure page for an authorization error, showing the
+ * OAuth error code and, when provided, the server's description.
  *
- * Validates the CSRF `state` echoed by the authorization server and, when
- * present, the RFC 9207 `iss` issuer parameter before acting on the
- * callback. A callback that fails validation is ignored: it gets a 400
- * response but never settles the flow, so a stray loopback request cannot
- * abort a login whose legitimate callback is still on its way. Uses
- * `tempServer` captured via closure to close the listener once the
- * callback settles.
+ * @param res - The server response.
+ * @param error - The OAuth error code from the callback.
+ * @param description - The OAuth `error_description`, or null.
+ */
+function respondAuthorizationError(res, error, description) {
+    sendPage(res, 400, renderCallbackPage({
+        kind: 'error',
+        heading: 'Authorization failed',
+        message: description ?? 'The authorization server rejected the request.',
+        detail: error,
+    }));
+}
+/**
+ * Responds with the success page after a valid callback.
+ *
+ * @param res - The server response.
+ */
+function respondSuccess(res) {
+    sendPage(res, 200, renderCallbackPage({
+        kind: 'success',
+        heading: 'Authorization successful',
+        message: 'You can close this window and return to your terminal.',
+    }));
+}
+/**
+ * Settles the flow with a failure: clears the callback timeout, closes
+ * the temporary server, and rejects the pending promise.
+ *
+ * @param flow - Callback flow state for this login attempt.
+ * @param tempServer - The temporary callback server (closed on failure).
+ * @param reject - Promise reject function.
+ * @param message - The error message for the rejection.
+ */
+function failFlow(flow, tempServer, reject, message) {
+    if (flow.timeoutHandle.current)
+        clearTimeout(flow.timeoutHandle.current);
+    tempServer.close();
+    reject(new Error(message));
+}
+/**
+ * Handles one callback request: validates the CSRF `state` echoed by the
+ * authorization server and, when present, the RFC 9207 `iss` issuer
+ * parameter before acting on the callback. A callback that fails
+ * validation is ignored: it gets a 400 response but never settles the
+ * flow, so a stray loopback request cannot abort a login whose
+ * legitimate callback is still on its way.
  *
  * @param flow - Callback flow state for this login attempt.
  * @param tempServer - The temporary callback server (closed on completion).
  * @param resolve - Promise resolve function (authorization code).
  * @param reject - Promise reject function.
- * @returns An HTTP request listener.
+ * @param req - The incoming request.
+ * @param res - The server response.
  */
-function makeCallbackHandler(flow, tempServer, resolve, reject) {
-    const fail = (message) => {
-        if (flow.timeoutHandle.current)
-            clearTimeout(flow.timeoutHandle.current);
-        tempServer.close();
-        reject(new Error(message));
-    };
-    return (req, res) => {
-        const url = new URL(req.url, `http://127.0.0.1`);
-        const error = url.searchParams.get('error');
-        const code = url.searchParams.get('code');
-        // Only authorization responses (a code or an error) carry a state to
-        // validate; anything else is not a callback.
-        if (error !== null || code !== null) {
-            const validationError = validateCallback(flow, url);
-            if (validationError) {
-                res.writeHead(400, { 'Content-Type': 'text/html' });
-                res.end('<html><body><h1>Authorization failed</h1><p>Invalid OAuth callback.</p></body></html>');
-                return;
-            }
-        }
-        if (error !== null) {
-            res.writeHead(400, { 'Content-Type': 'text/html' });
-            res.end(`<html><body><h1>Authorization failed</h1><p>${escapeHtml(error)}</p></body></html>`);
-            fail(`Authorization failed: ${error}`);
-            return;
-        }
-        if (code === null) {
-            res.writeHead(404);
-            res.end('Not found');
+function handleCallbackRequest(flow, tempServer, resolve, reject, req, res) {
+    const url = new URL(req.url, `http://127.0.0.1`);
+    const error = url.searchParams.get('error');
+    const code = url.searchParams.get('code');
+    // Only authorization responses (a code or an error) carry a state to
+    // validate; anything else is not a callback.
+    if (error !== null || code !== null) {
+        const validationError = validateCallback(flow, url);
+        if (validationError) {
+            respondInvalidCallback(res);
             return;
         }
-        if (flow.timeoutHandle.current)
-            clearTimeout(flow.timeoutHandle.current);
-        res.writeHead(200, { 'Content-Type': 'text/html' });
-        res.end('<html><body><h1>Authorization successful!</h1><p>You can close this window.</p></body></html>');
-        tempServer.close();
-        resolve(code);
-    };
+    }
+    if (error !== null) {
+        respondAuthorizationError(res, error, url.searchParams.get('error_description'));
+        failFlow(flow, tempServer, reject, `Authorization failed: ${error}`);
+        return;
+    }
+    if (code === null) {
+        res.writeHead(404);
+        res.end('Not found');
+        return;
+    }
+    if (flow.timeoutHandle.current)
+        clearTimeout(flow.timeoutHandle.current);
+    respondSuccess(res);
+    tempServer.close();
+    resolve(code);
+}
+/**
+ * Creates the HTTP request listener for the temporary callback server.
+ *
+ * @param flow - Callback flow state for this login attempt.
+ * @param tempServer - The temporary callback server (closed on completion).
+ * @param resolve - Promise resolve function (authorization code).
+ * @param reject - Promise reject function.
+ * @returns An HTTP request listener.
+ */
+function makeCallbackHandler(flow, tempServer, resolve, reject) {
+    return (req, res) => handleCallbackRequest(flow, tempServer, resolve, reject, req, res);
 }
 /**
  * Listen callback: records the bound port, prepares the authorization

package/build/cli/login-command.js

@@ -59,9 +59,11 @@ async function _getOpenBrowser() {
  *
  * @param targetServer - Typed downstream server configuration.
  * @param name - Server name (for error messages).
- * @returns The discovered OAuth metadata and whether the authorization
+ * @returns The discovered OAuth metadata, whether the authorization
  *   server commits to the RFC 9207 `iss` parameter (read from the raw
- *   metadata document, so it also covers OpenID Connect discovery).
+ *   metadata document, so it also covers OpenID Connect discovery),
+ *   and the RFC 9728 Protected Resource Metadata when the server
+ *   publishes it (used to derive the RFC 8707 `resource` indicator).
  * @throws If the server does not expose OAuth metadata.
  */
 async function discoverOAuthMetadata(targetServer, name) {
@@ -74,6 +76,7 @@ async function discoverOAuthMetadata(targetServer, name) {
     return {
         metadata: metadata,
         requireIssuer: discovered.authorizationResponseIssParameterSupported,
+        resourceMetadata: discovered.resourceMetadata,
     };
 }
 /**
@@ -147,9 +150,12 @@ async function registerClientIfNeeded(mgr, metadata, name) {
  * @param targetServer - Typed downstream server configuration.
  * @param name - Server name (for error messages).
  * @param state - CSRF state generated for this login attempt.
+ * @param resource - RFC 8707 resource indicator selected from the
+ *   server's Protected Resource Metadata, or undefined when the server
+ *   publishes none (the SDK then omits the `resource` parameter).
  * @returns The `startAuthorization` result.
  */
-async function beginAuthorization(mgr, metadata, targetServer, name, state) {
+async function beginAuthorization(mgr, metadata, targetServer, name, state, resource) {
     await registerClientIfNeeded(mgr, metadata, name);
     const { startAuthorization } = await _getSdkAuth();
     return startAuthorization(new URL(metadata.authorization_endpoint), {
@@ -158,6 +164,7 @@ async function beginAuthorization(mgr, metadata, targetServer, name, state) {
         redirectUrl: mgr.redirectUrl,
         scope: targetServer.oauth?.scope,
         state,
+        resource,
     });
 }
 /**
@@ -202,7 +209,9 @@ function _resolveCallbackPort(override, server) {
  * temporary loopback callback server, registers the client (when
  * needed) with the portless loopback callback URI, opens a browser,
  * handles the redirect callback, exchanges the authorization code for
- * tokens, and persists them in credentials.json.
+ * tokens, and persists them in credentials.json. The authorization and
+ * token requests carry the RFC 8707 `resource` indicator derived from
+ * the server's Protected Resource Metadata when it publishes one.
  *
  * @param configPath - Absolute path to the mcp.json file.
  * @param name - Server name to authenticate.
@@ -219,16 +228,21 @@ export async function handleLogin(configPath, name, portOverride) {
     const callbackPort = _resolveCallbackPort(_validatePortOverride(portOverride), targetServer);
     const { OAuthCredentialManager } = await import('../services/oauth.js');
     const mgr = new OAuthCredentialManager(configPath, targetServer);
-    const { metadata, requireIssuer } = await discoverOAuthMetadata(targetServer, name);
+    const { metadata, requireIssuer, resourceMetadata } = await discoverOAuthMetadata(targetServer, name);
+    const { selectResourceURL, exchangeAuthorization } = await _getSdkAuth();
+    // RFC 8707 resource indicator, selected from the server's Protected
+    // Resource Metadata the same way the SDK's auth() flow selects it.
+    // Undefined when the server publishes no such metadata: the SDK then
+    // omits the parameter, matching the runtime transport path.
+    const resource = await selectResourceURL(new URL(targetServer.url), mgr, resourceMetadata);
     const { authorizationCode, authResult } = await acquireAuthorizationCode({
         mgr,
         callbackPort,
         openBrowser: await _getOpenBrowser(),
         expectedIssuer: metadata.issuer,
         requireIssuer,
-        beginAuthorization: (state) => beginAuthorization(mgr, metadata, targetServer, name, state),
+        beginAuthorization: (state) => beginAuthorization(mgr, metadata, targetServer, name, state, resource),
     });
-    const { exchangeAuthorization } = await _getSdkAuth();
     const realRedirectUrl = mgr.redirectUrl;
     const tokens = await exchangeAuthorization(new URL(metadata.token_endpoint), {
         metadata,
@@ -236,6 +250,7 @@ export async function handleLogin(configPath, name, portOverride) {
         authorizationCode,
         codeVerifier: authResult.codeVerifier,
         redirectUri: realRedirectUrl,
+        resource,
     });
     await mgr.saveTokens(tokens);
     // Best-effort: discover tools and save to cache so the next router

package/build/services/oauth.js

@@ -1,4 +1,4 @@
-import { refreshAuthorization, } from '@modelcontextprotocol/sdk/client/auth.js';
+import { refreshAuthorization, selectResourceURL, } from '@modelcontextprotocol/sdk/client/auth.js';
 import { readCredentials, writeCredentials, removeCredentials } from '../cli/config-io.js';
 import { discoverAuth } from './oauth-discovery.js';
 import { GuidedAuthError } from './index.js';
@@ -337,16 +337,20 @@ export class OAuthCredentialManager {
      * Performs the token refresh: discovers the authorization server
      * metadata, calls the SDK's `refreshAuthorization`, and persists the
      * refreshed tokens via {@link saveTokens} (which recomputes
-     * `expires_at`). Errors are logged (when a logger is supplied) and
-     * swallowed — proactive refresh is best-effort; the SDK's 401 path
-     * handles terminal failures.
+     * `expires_at`). The request carries the RFC 8707 `resource`
+     * indicator selected from the server's Protected Resource Metadata —
+     * the same indicator `login` sent — so a provider that binds tokens
+     * to a specific resource accepts the refresh. Errors are logged
+     * (when a logger is supplied) and swallowed — proactive refresh is
+     * best-effort; the SDK's 401 path handles terminal failures.
      */
     async _refreshTokens(refreshToken, logger) {
         try {
             if (!this._server.url) {
                 return;
             }
-            const discovered = await discoverAuth(new URL(this._server.url));
+            const serverUrl = new URL(this._server.url);
+            const discovered = await discoverAuth(serverUrl);
             if (!discovered.serverMetadata) {
                 return;
             }
@@ -354,10 +358,12 @@ export class OAuthCredentialManager {
             if (!clientInformation) {
                 return;
             }
+            const resource = await selectResourceURL(serverUrl, this, discovered.resourceMetadata);
             const newTokens = await refreshAuthorization(discovered.authorizationServerUrl, {
                 metadata: discovered.serverMetadata,
                 clientInformation,
                 refreshToken,
+                resource,
             });
             await this.saveTokens(newTokens);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-compress-router",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "description": "Compress all connected MCP servers into a single router MCP to save tokens",
   "license": "MIT",
   "type": "module",