@mcp-z/client 1.2.0 → 1.3.0

package/dist/esm/auth/capability-discovery.js

@@ -38,11 +38,21 @@ import { discoverAuthorizationServerIssuer, discoverAuthorizationServerMetadata,
  * if (caps.supportsDcr) {
  *   console.log('Registration endpoint:', caps.registrationEndpoint);
  * }
- */ function buildCapabilities(metadata, scopes) {
+ */ function buildCapabilities(metadata, scopes, resource) {
     const supportsDcr = !!metadata.registration_endpoint;
     const capabilities = {
-        supportsDcr
+        supportsDcr,
+        authorizationResponseIssSupported: metadata.authorization_response_iss_parameter_supported === true
     };
+    if (metadata.issuer) {
+        capabilities.issuer = metadata.issuer;
+    }
+    // Carried from the RFC 9728 document, not from the URL we were given: the
+    // resource server names itself, and that name is what RFC 8707 audience-binds
+    // a token to.
+    if (resource) {
+        capabilities.resource = resource;
+    }
     if (metadata.registration_endpoint) {
         capabilities.registrationEndpoint = metadata.registration_endpoint;
     }
@@ -60,12 +70,12 @@ import { discoverAuthorizationServerIssuer, discoverAuthorizationServerMetadata,
     }
     return capabilities;
 }
-async function resolveCapabilitiesFromAuthorizationServer(authServerUrl, scopes, allowLoopback) {
+async function resolveCapabilitiesFromAuthorizationServer(authServerUrl, scopes, allowLoopback, resource) {
     const metadata = await discoverAuthorizationServerMetadata(authServerUrl, {
         allowLoopback
     });
     if (!metadata) return null;
-    return buildCapabilities(metadata, scopes);
+    return buildCapabilities(metadata, scopes, resource);
 }
 export async function probeAuthCapabilities(baseUrl) {
     try {
@@ -86,13 +96,13 @@ export async function probeAuthCapabilities(baseUrl) {
                     supportsDcr: false
                 };
             }
-            const capabilities = await resolveCapabilitiesFromAuthorizationServer(authServerUrl, resourceMetadata.scopes_supported, allowLoopback);
+            const capabilities = await resolveCapabilitiesFromAuthorizationServer(authServerUrl, resourceMetadata.scopes_supported, allowLoopback, resourceMetadata.resource);
             if (capabilities) {
                 return capabilities;
             }
             const issuer = await discoverAuthorizationServerIssuer(baseUrl);
             if (issuer) {
-                const issuerCapabilities = await resolveCapabilitiesFromAuthorizationServer(issuer, resourceMetadata.scopes_supported, allowLoopback);
+                const issuerCapabilities = await resolveCapabilitiesFromAuthorizationServer(issuer, resourceMetadata.scopes_supported, allowLoopback, resourceMetadata.resource);
                 if (issuerCapabilities) return issuerCapabilities;
             }
         }

package/dist/esm/auth/capability-discovery.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/mcp-z/client/src/auth/capability-discovery.ts"],"sourcesContent":["/**\n * OAuth Server Capability Discovery\n * Probes RFC 9728 (Protected Resource) and RFC 8414 (Authorization Server) metadata\n */\n\nimport { normalizeUrl } from '../lib/url-utils.ts';\nimport { isLoopbackUrl } from './discovery-fetch.ts';\nimport { discoverAuthorizationServerIssuer, discoverAuthorizationServerMetadata, discoverProtectedResourceMetadata } from './rfc9728-discovery.ts';\nimport type { AuthCapabilities, AuthorizationServerMetadata } from './types.ts';\n\n/**\n * Extract origin (protocol + host) from a URL\n * @param url - Full URL that may include a path\n * @returns Origin (e.g., \"https://example.com\") or original string if invalid URL\n *\n * @example\n * getOrigin('https://example.com/mcp') // → 'https://example.com'\n * getOrigin('http://localhost:9999/api/v1/mcp') // → 'http://localhost:9999'\n */\nfunction getOrigin(url: string): string {\n  try {\n    return new URL(url).origin;\n  } catch {\n    // Invalid URL - return as-is for graceful degradation\n    return url;\n  }\n}\n\n/**\n * Probe OAuth server capabilities using RFC 9728 → RFC 8414 discovery chain\n * Returns capabilities including DCR support detection\n *\n * Discovery Strategy:\n * 1. Try RFC 9728 Protected Resource Metadata (supports cross-domain OAuth)\n * 2. If found, use first authorization_server to discover RFC 8414 Authorization Server Metadata\n * 3. Fall back to direct RFC 8414 discovery at resource origin\n *\n * @param baseUrl - Base URL of the protected resource (e.g., https://ai.todoist.net/mcp)\n * @returns AuthCapabilities object with discovered endpoints and features\n *\n * @example\n * // Todoist case: MCP at ai.todoist.net/mcp, OAuth at todoist.com\n * const caps = await probeAuthCapabilities('https://ai.todoist.net/mcp');\n * if (caps.supportsDcr) {\n *   console.log('Registration endpoint:', caps.registrationEndpoint);\n * }\n */\nfunction buildCapabilities(metadata: AuthorizationServerMetadata, scopes?: string[]): AuthCapabilities {\n  const supportsDcr = !!metadata.registration_endpoint;\n  const capabilities: AuthCapabilities = { supportsDcr };\n\n  if (metadata.registration_endpoint) {\n    capabilities.registrationEndpoint = metadata.registration_endpoint;\n  }\n  if (metadata.authorization_endpoint) {\n    capabilities.authorizationEndpoint = metadata.authorization_endpoint;\n  }\n  if (metadata.token_endpoint) capabilities.tokenEndpoint = metadata.token_endpoint;\n  if (metadata.introspection_endpoint) {\n    capabilities.introspectionEndpoint = metadata.introspection_endpoint;\n  }\n\n  if (scopes && scopes.length > 0) {\n    capabilities.scopes = scopes;\n  } else if (metadata.scopes_supported) {\n    capabilities.scopes = metadata.scopes_supported;\n  }\n\n  return capabilities;\n}\n\nasync function resolveCapabilitiesFromAuthorizationServer(authServerUrl: string, scopes: string[] | undefined, allowLoopback: boolean): Promise<AuthCapabilities | null> {\n  const metadata = await discoverAuthorizationServerMetadata(authServerUrl, { allowLoopback });\n  if (!metadata) return null;\n  return buildCapabilities(metadata, scopes);\n}\n\nexport async function probeAuthCapabilities(baseUrl: string): Promise<AuthCapabilities> {\n  try {\n    const normalizedBaseUrl = normalizeUrl(baseUrl);\n    // Trust signal for every authorization-server fetch below: whether the\n    // configured MCP server is itself loopback, never a remote-supplied URL.\n    const allowLoopback = isLoopbackUrl(normalizedBaseUrl);\n    // Strategy 1: Try RFC 9728 Protected Resource Metadata discovery\n    // This handles cross-domain OAuth (e.g., Todoist: ai.todoist.net/mcp → todoist.com)\n    const resourceMetadata = await discoverProtectedResourceMetadata(normalizedBaseUrl);\n\n    if (resourceMetadata && resourceMetadata.authorization_servers.length > 0) {\n      // Found protected resource metadata with authorization servers\n      // Discover the authorization server's metadata (RFC 8414)\n      const authServerUrl = resourceMetadata.authorization_servers[0];\n      if (!authServerUrl) {\n        // Array has length > 0 but first element is undefined/null - skip this path\n        return { supportsDcr: false };\n      }\n      const capabilities = await resolveCapabilitiesFromAuthorizationServer(authServerUrl, resourceMetadata.scopes_supported, allowLoopback);\n      if (capabilities) {\n        return capabilities;\n      }\n\n      const issuer = await discoverAuthorizationServerIssuer(baseUrl);\n      if (issuer) {\n        const issuerCapabilities = await resolveCapabilitiesFromAuthorizationServer(issuer, resourceMetadata.scopes_supported, allowLoopback);\n        if (issuerCapabilities) return issuerCapabilities;\n      }\n    }\n\n    const issuer = await discoverAuthorizationServerIssuer(normalizedBaseUrl);\n    if (issuer) {\n      const issuerCapabilities = await resolveCapabilitiesFromAuthorizationServer(issuer, undefined, allowLoopback);\n      if (issuerCapabilities) return issuerCapabilities;\n    }\n\n    // Strategy 2: Fall back to direct RFC 8414 discovery at resource origin\n    // This handles same-domain OAuth (traditional setup)\n    const origin = getOrigin(normalizedBaseUrl);\n    const originCapabilities = await resolveCapabilitiesFromAuthorizationServer(origin, undefined, allowLoopback);\n    if (originCapabilities) return originCapabilities;\n\n    // No OAuth metadata found\n    return { supportsDcr: false };\n  } catch (_error) {\n    // Network error, invalid JSON, or other fetch failure\n    // Gracefully degrade - assume no DCR support\n    return { supportsDcr: false };\n  }\n}\n"],"names":["normalizeUrl","isLoopbackUrl","discoverAuthorizationServerIssuer","discoverAuthorizationServerMetadata","discoverProtectedResourceMetadata","getOrigin","url","URL","origin","buildCapabilities","metadata","scopes","supportsDcr","registration_endpoint","capabilities","registrationEndpoint","authorization_endpoint","authorizationEndpoint","token_endpoint","tokenEndpoint","introspection_endpoint","introspectionEndpoint","length","scopes_supported","resolveCapabilitiesFromAuthorizationServer","authServerUrl","allowLoopback","probeAuthCapabilities","baseUrl","normalizedBaseUrl","resourceMetadata","authorization_servers","issuer","issuerCapabilities","undefined","originCapabilities","_error"],"mappings":"AAAA;;;CAGC,GAED,SAASA,YAAY,QAAQ,sBAAsB;AACnD,SAASC,aAAa,QAAQ,uBAAuB;AACrD,SAASC,iCAAiC,EAAEC,mCAAmC,EAAEC,iCAAiC,QAAQ,yBAAyB;AAGnJ;;;;;;;;CAQC,GACD,SAASC,UAAUC,GAAW;IAC5B,IAAI;QACF,OAAO,IAAIC,IAAID,KAAKE,MAAM;IAC5B,EAAE,OAAM;QACN,sDAAsD;QACtD,OAAOF;IACT;AACF;AAEA;;;;;;;;;;;;;;;;;;CAkBC,GACD,SAASG,kBAAkBC,QAAqC,EAAEC,MAAiB;IACjF,MAAMC,cAAc,CAAC,CAACF,SAASG,qBAAqB;IACpD,MAAMC,eAAiC;QAAEF;IAAY;IAErD,IAAIF,SAASG,qBAAqB,EAAE;QAClCC,aAAaC,oBAAoB,GAAGL,SAASG,qBAAqB;IACpE;IACA,IAAIH,SAASM,sBAAsB,EAAE;QACnCF,aAAaG,qBAAqB,GAAGP,SAASM,sBAAsB;IACtE;IACA,IAAIN,SAASQ,cAAc,EAAEJ,aAAaK,aAAa,GAAGT,SAASQ,cAAc;IACjF,IAAIR,SAASU,sBAAsB,EAAE;QACnCN,aAAaO,qBAAqB,GAAGX,SAASU,sBAAsB;IACtE;IAEA,IAAIT,UAAUA,OAAOW,MAAM,GAAG,GAAG;QAC/BR,aAAaH,MAAM,GAAGA;IACxB,OAAO,IAAID,SAASa,gBAAgB,EAAE;QACpCT,aAAaH,MAAM,GAAGD,SAASa,gBAAgB;IACjD;IAEA,OAAOT;AACT;AAEA,eAAeU,2CAA2CC,aAAqB,EAAEd,MAA4B,EAAEe,aAAsB;IACnI,MAAMhB,WAAW,MAAMP,oCAAoCsB,eAAe;QAAEC;IAAc;IAC1F,IAAI,CAAChB,UAAU,OAAO;IACtB,OAAOD,kBAAkBC,UAAUC;AACrC;AAEA,OAAO,eAAegB,sBAAsBC,OAAe;IACzD,IAAI;QACF,MAAMC,oBAAoB7B,aAAa4B;QACvC,uEAAuE;QACvE,yEAAyE;QACzE,MAAMF,gBAAgBzB,cAAc4B;QACpC,iEAAiE;QACjE,oFAAoF;QACpF,MAAMC,mBAAmB,MAAM1B,kCAAkCyB;QAEjE,IAAIC,oBAAoBA,iBAAiBC,qBAAqB,CAACT,MAAM,GAAG,GAAG;YACzE,+DAA+D;YAC/D,0DAA0D;YAC1D,MAAMG,gBAAgBK,iBAAiBC,qBAAqB,CAAC,EAAE;YAC/D,IAAI,CAACN,eAAe;gBAClB,4EAA4E;gBAC5E,OAAO;oBAAEb,aAAa;gBAAM;YAC9B;YACA,MAAME,eAAe,MAAMU,2CAA2CC,eAAeK,iBAAiBP,gBAAgB,EAAEG;YACxH,IAAIZ,cAAc;gBAChB,OAAOA;YACT;YAEA,MAAMkB,SAAS,MAAM9B,kCAAkC0B;YACvD,IAAII,QAAQ;gBACV,MAAMC,qBAAqB,MAAMT,2CAA2CQ,QAAQF,iBAAiBP,gBAAgB,EAAEG;gBACvH,IAAIO,oBAAoB,OAAOA;YACjC;QACF;QAEA,MAAMD,SAAS,MAAM9B,kCAAkC2B;QACvD,IAAIG,QAAQ;YACV,MAAMC,qBAAqB,MAAMT,2CAA2CQ,QAAQE,WAAWR;YAC/F,IAAIO,oBAAoB,OAAOA;QACjC;QAEA,wEAAwE;QACxE,qDAAqD;QACrD,MAAMzB,SAASH,UAAUwB;QACzB,MAAMM,qBAAqB,MAAMX,2CAA2ChB,QAAQ0B,WAAWR;QAC/F,IAAIS,oBAAoB,OAAOA;QAE/B,0BAA0B;QAC1B,OAAO;YAAEvB,aAAa;QAAM;IAC9B,EAAE,OAAOwB,QAAQ;QACf,sDAAsD;QACtD,6CAA6C;QAC7C,OAAO;YAAExB,aAAa;QAAM;IAC9B;AACF"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/mcp-z/client/src/auth/capability-discovery.ts"],"sourcesContent":["/**\n * OAuth Server Capability Discovery\n * Probes RFC 9728 (Protected Resource) and RFC 8414 (Authorization Server) metadata\n */\n\nimport { normalizeUrl } from '../lib/url-utils.ts';\nimport { isLoopbackUrl } from './discovery-fetch.ts';\nimport { discoverAuthorizationServerIssuer, discoverAuthorizationServerMetadata, discoverProtectedResourceMetadata } from './rfc9728-discovery.ts';\nimport type { AuthCapabilities, AuthorizationServerMetadata } from './types.ts';\n\n/**\n * Extract origin (protocol + host) from a URL\n * @param url - Full URL that may include a path\n * @returns Origin (e.g., \"https://example.com\") or original string if invalid URL\n *\n * @example\n * getOrigin('https://example.com/mcp') // → 'https://example.com'\n * getOrigin('http://localhost:9999/api/v1/mcp') // → 'http://localhost:9999'\n */\nfunction getOrigin(url: string): string {\n  try {\n    return new URL(url).origin;\n  } catch {\n    // Invalid URL - return as-is for graceful degradation\n    return url;\n  }\n}\n\n/**\n * Probe OAuth server capabilities using RFC 9728 → RFC 8414 discovery chain\n * Returns capabilities including DCR support detection\n *\n * Discovery Strategy:\n * 1. Try RFC 9728 Protected Resource Metadata (supports cross-domain OAuth)\n * 2. If found, use first authorization_server to discover RFC 8414 Authorization Server Metadata\n * 3. Fall back to direct RFC 8414 discovery at resource origin\n *\n * @param baseUrl - Base URL of the protected resource (e.g., https://ai.todoist.net/mcp)\n * @returns AuthCapabilities object with discovered endpoints and features\n *\n * @example\n * // Todoist case: MCP at ai.todoist.net/mcp, OAuth at todoist.com\n * const caps = await probeAuthCapabilities('https://ai.todoist.net/mcp');\n * if (caps.supportsDcr) {\n *   console.log('Registration endpoint:', caps.registrationEndpoint);\n * }\n */\nfunction buildCapabilities(metadata: AuthorizationServerMetadata, scopes?: string[], resource?: string): AuthCapabilities {\n  const supportsDcr = !!metadata.registration_endpoint;\n  const capabilities: AuthCapabilities = { supportsDcr, authorizationResponseIssSupported: metadata.authorization_response_iss_parameter_supported === true };\n\n  if (metadata.issuer) {\n    capabilities.issuer = metadata.issuer;\n  }\n\n  // Carried from the RFC 9728 document, not from the URL we were given: the\n  // resource server names itself, and that name is what RFC 8707 audience-binds\n  // a token to.\n  if (resource) {\n    capabilities.resource = resource;\n  }\n\n  if (metadata.registration_endpoint) {\n    capabilities.registrationEndpoint = metadata.registration_endpoint;\n  }\n  if (metadata.authorization_endpoint) {\n    capabilities.authorizationEndpoint = metadata.authorization_endpoint;\n  }\n  if (metadata.token_endpoint) capabilities.tokenEndpoint = metadata.token_endpoint;\n  if (metadata.introspection_endpoint) {\n    capabilities.introspectionEndpoint = metadata.introspection_endpoint;\n  }\n\n  if (scopes && scopes.length > 0) {\n    capabilities.scopes = scopes;\n  } else if (metadata.scopes_supported) {\n    capabilities.scopes = metadata.scopes_supported;\n  }\n\n  return capabilities;\n}\n\nasync function resolveCapabilitiesFromAuthorizationServer(authServerUrl: string, scopes: string[] | undefined, allowLoopback: boolean, resource?: string): Promise<AuthCapabilities | null> {\n  const metadata = await discoverAuthorizationServerMetadata(authServerUrl, { allowLoopback });\n  if (!metadata) return null;\n  return buildCapabilities(metadata, scopes, resource);\n}\n\nexport async function probeAuthCapabilities(baseUrl: string): Promise<AuthCapabilities> {\n  try {\n    const normalizedBaseUrl = normalizeUrl(baseUrl);\n    // Trust signal for every authorization-server fetch below: whether the\n    // configured MCP server is itself loopback, never a remote-supplied URL.\n    const allowLoopback = isLoopbackUrl(normalizedBaseUrl);\n    // Strategy 1: Try RFC 9728 Protected Resource Metadata discovery\n    // This handles cross-domain OAuth (e.g., Todoist: ai.todoist.net/mcp → todoist.com)\n    const resourceMetadata = await discoverProtectedResourceMetadata(normalizedBaseUrl);\n\n    if (resourceMetadata && resourceMetadata.authorization_servers.length > 0) {\n      // Found protected resource metadata with authorization servers\n      // Discover the authorization server's metadata (RFC 8414)\n      const authServerUrl = resourceMetadata.authorization_servers[0];\n      if (!authServerUrl) {\n        // Array has length > 0 but first element is undefined/null - skip this path\n        return { supportsDcr: false };\n      }\n      const capabilities = await resolveCapabilitiesFromAuthorizationServer(authServerUrl, resourceMetadata.scopes_supported, allowLoopback, resourceMetadata.resource);\n      if (capabilities) {\n        return capabilities;\n      }\n\n      const issuer = await discoverAuthorizationServerIssuer(baseUrl);\n      if (issuer) {\n        const issuerCapabilities = await resolveCapabilitiesFromAuthorizationServer(issuer, resourceMetadata.scopes_supported, allowLoopback, resourceMetadata.resource);\n        if (issuerCapabilities) return issuerCapabilities;\n      }\n    }\n\n    const issuer = await discoverAuthorizationServerIssuer(normalizedBaseUrl);\n    if (issuer) {\n      const issuerCapabilities = await resolveCapabilitiesFromAuthorizationServer(issuer, undefined, allowLoopback);\n      if (issuerCapabilities) return issuerCapabilities;\n    }\n\n    // Strategy 2: Fall back to direct RFC 8414 discovery at resource origin\n    // This handles same-domain OAuth (traditional setup)\n    const origin = getOrigin(normalizedBaseUrl);\n    const originCapabilities = await resolveCapabilitiesFromAuthorizationServer(origin, undefined, allowLoopback);\n    if (originCapabilities) return originCapabilities;\n\n    // No OAuth metadata found\n    return { supportsDcr: false };\n  } catch (_error) {\n    // Network error, invalid JSON, or other fetch failure\n    // Gracefully degrade - assume no DCR support\n    return { supportsDcr: false };\n  }\n}\n"],"names":["normalizeUrl","isLoopbackUrl","discoverAuthorizationServerIssuer","discoverAuthorizationServerMetadata","discoverProtectedResourceMetadata","getOrigin","url","URL","origin","buildCapabilities","metadata","scopes","resource","supportsDcr","registration_endpoint","capabilities","authorizationResponseIssSupported","authorization_response_iss_parameter_supported","issuer","registrationEndpoint","authorization_endpoint","authorizationEndpoint","token_endpoint","tokenEndpoint","introspection_endpoint","introspectionEndpoint","length","scopes_supported","resolveCapabilitiesFromAuthorizationServer","authServerUrl","allowLoopback","probeAuthCapabilities","baseUrl","normalizedBaseUrl","resourceMetadata","authorization_servers","issuerCapabilities","undefined","originCapabilities","_error"],"mappings":"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"}

package/dist/esm/auth/discovery-fetch.d.ts

@@ -1,6 +1,15 @@
 export declare class DiscoveryFetchError extends Error {
     constructor(message: string);
 }
+type LookupRecord = {
+    address: string;
+    family: number;
+};
+/** DNS implementation, injectable for deterministic tests. Same contract as `dns.lookup` with `{ all: true, verbatim: true }`. */
+type Lookup = (hostname: string, options: {
+    all: true;
+    verbatim: true;
+}, callback: (error: NodeJS.ErrnoException | null, addresses: LookupRecord[]) => void) => void;
 /**
  * True if `rawUrl`'s host is loopback, used to decide `allowLoopback` grants
  * from the URL the caller configured, not remote-supplied data. Fails closed on an unparseable URL.
@@ -13,15 +22,25 @@ export interface DiscoveryFetchOptions {
      */
     allowLoopback?: boolean;
     /**
-     * Per-request connect/read timeout in ms. Defaults to `DEFAULT_TIMEOUT_MS`;
-     * overridable so tests can bound slow-failure cases.
+     * Per-hop timeout in ms, applied to both the DNS resolution and the request.
+     * Defaults to `DEFAULT_TIMEOUT_MS`; overridable so tests can bound slow-failure cases.
      */
     timeoutMs?: number;
+    /**
+     * DNS implementation used for the pre-request resolution, injectable for
+     * deterministic tests. Defaults to `dns.lookup`.
+     */
+    lookup?: Lookup;
 }
 /**
  * Fetches an OAuth-discovery URL with SSRF mitigations applied to the
  * initial URL and every redirect hop; redirects are validated, not auto-followed.
  *
+ * The hostname is resolved once, every returned address is validated, and the
+ * validated set is pinned into the request through a custom `lookup`, so the
+ * request cannot resolve the hostname a second time and cannot be steered to
+ * a different address by a DNS-rebinding answer.
+ *
  * @param rawUrl - URL to fetch; may be remote-server-supplied (the threat this guards against).
  * @param init - Standard fetch options; `redirect` is always forced to `'manual'`.
  * @param context - Short label used only in error messages, never echoing the URL.
@@ -33,3 +52,4 @@ export declare function discoveryFetch(rawUrl: string, init?: RequestInit, conte
  * while reading (not after buffering the whole thing).
  */
 export declare function readDiscoveryJson<T>(response: Response, context: string): Promise<T>;
+export {};

package/dist/esm/auth/discovery-fetch.js

@@ -1,7 +1,9 @@
 /**
  * Hardened fetch for OAuth discovery URLs, which the remote MCP server
  * controls (SSRF mitigation). See ARCHITECTURE.md's "SSRF mitigation" section for the threat model.
- */ import dns from 'node:dns/promises';
+ */ import dns from 'node:dns';
+import http from 'node:http';
+import https from 'node:https';
 import { isIP } from 'node:net';
 import ipaddr from 'ipaddr.js';
 export class DiscoveryFetchError extends Error {
@@ -46,6 +48,13 @@ function stripBrackets(hostname) {
         return true; // unparseable - fail closed
     }
 }
+function isLoopbackAddress(address) {
+    try {
+        return ipaddr.process(address).range() === 'loopback';
+    } catch  {
+        return false;
+    }
+}
 /**
  * Validates scheme and, for literal-IP hosts, address range. `allowLoopback`
  * reflects trust in the calling server, never in `rawUrl` itself.
@@ -70,88 +79,227 @@ function stripBrackets(hostname) {
     }
     return url;
 }
+function lookupAll(hostname, lookup, timeoutMs) {
+    return new Promise((resolve, reject)=>{
+        let settled = false;
+        const deadline = setTimeout(()=>{
+            if (!settled) {
+                settled = true;
+                reject(new Error('DNS resolution timed out'));
+            }
+        }, timeoutMs);
+        try {
+            lookup(hostname, {
+                all: true,
+                verbatim: true
+            }, (error, addresses)=>{
+                if (settled) return;
+                settled = true;
+                clearTimeout(deadline);
+                if (error || addresses.length === 0) reject(new Error('DNS resolution failed'));
+                else resolve(addresses);
+            });
+        } catch  {
+            if (!settled) {
+                settled = true;
+                clearTimeout(deadline);
+                reject(new Error('DNS resolution failed'));
+            }
+        }
+    });
+}
 /**
- * Resolves the hostname and rejects it if any address is private/reserved.
- * Does not close the DNS-rebinding TOCTOU race against `fetch`'s own resolution a moment later.
- */ async function assertResolvesToSafeAddress(url, context, allowLoopback) {
+ * Resolves the hostname once, rejects it unless every returned address is
+ * acceptable, and returns the validated set. The set is pinned into the
+ * request itself (see `requestOnce`), which is what closes the DNS-rebinding
+ * TOCTOU: the transport can only dial addresses that were already validated,
+ * and it never resolves the hostname a second time.
+ */ async function resolveSafeAddresses(url, context, allowLoopback, lookup, timeoutMs) {
     const host = stripBrackets(url.hostname);
-    if (isIP(host)) return; // literal IP already fully checked in assertSafeUrl
-    if (allowLoopback && isLoopbackHost(host)) return; // literal "localhost" under a trusted-loopback grant
+    if (isIP(host)) return [
+        {
+            address: host,
+            family: host.includes(':') ? 6 : 4
+        }
+    ]; // literal IP already fully checked in assertSafeUrl
+    // Literal `localhost` under a trusted-loopback grant: still resolved, and the
+    // answers must be loopback - the grant covers loopback, not "wherever
+    // localhost happens to point".
+    const loopbackGrant = allowLoopback && isLoopbackHost(host);
     let addresses;
     try {
-        const records = await dns.lookup(host, {
-            all: true,
-            verbatim: true
-        });
-        addresses = records.map((record)=>record.address);
+        addresses = await lookupAll(host, lookup, timeoutMs);
     } catch  {
         throw new DiscoveryFetchError(`Refusing to fetch ${context}: host could not be resolved`);
     }
-    if (addresses.length === 0 || addresses.some((address)=>isBlockedAddress(address))) {
+    if (loopbackGrant) {
+        if (!addresses.every((record)=>isLoopbackAddress(record.address))) {
+            throw new DiscoveryFetchError(`Refusing to fetch ${context}: host does not resolve to a loopback address`);
+        }
+    } else if (addresses.some((record)=>isBlockedAddress(record.address))) {
         throw new DiscoveryFetchError(`Refusing to fetch ${context}: host resolves to an address that is not publicly routable`);
     }
+    return addresses;
 }
-async function readLimited(response, context, maxBytes) {
-    var _response_body;
-    const contentLength = response.headers.get('content-length');
-    if (contentLength && Number(contentLength) > maxBytes) {
-        throw new DiscoveryFetchError(`Refusing to read ${context}: response too large`);
-    }
-    const reader = (_response_body = response.body) === null || _response_body === void 0 ? void 0 : _response_body.getReader();
-    if (!reader) {
-        const text = await response.text();
-        if (Buffer.byteLength(text, 'utf8') > maxBytes) {
-            throw new DiscoveryFetchError(`Refusing to read ${context}: response too large`);
+/**
+ * A `net` lookup that can only ever answer with `addresses` - the set already
+ * validated for this URL. The request is built against the original URL (so
+ * SNI and certificate verification still see the hostname), but the
+ * connection can only land on a validated address.
+ */ function pinnedLookup(addresses) {
+    return (_hostname, options, callback)=>{
+        if (typeof options === 'object' && options.all === true) {
+            callback(null, addresses);
+            return;
         }
-        return text;
-    }
-    const chunks = [];
-    let total = 0;
-    try {
-        for(;;){
-            const { done, value } = await reader.read();
-            if (done) break;
-            if (!value) continue;
-            total += value.byteLength;
-            if (total > maxBytes) {
-                throw new DiscoveryFetchError(`Refusing to read ${context}: response too large`);
+        const first = addresses[0];
+        if (!first) {
+            callback(Object.assign(new Error('no validated address'), {
+                code: 'ENOTFOUND'
+            }), '', 0);
+            return;
+        }
+        callback(null, first.address, first.family);
+    };
+}
+function toRequestHeaders(init) {
+    const headers = new Headers(init.headers);
+    const out = {};
+    for (const [name, value] of headers)out[name] = value;
+    return out;
+}
+async function toRequestBody(body) {
+    if (body === undefined || body === null) return undefined;
+    if (typeof body === 'string') return Buffer.from(body);
+    if (body instanceof URLSearchParams) return Buffer.from(body.toString());
+    if (body instanceof Blob) return Buffer.from(await body.arrayBuffer());
+    if (body instanceof ArrayBuffer) return Buffer.from(body);
+    if (ArrayBuffer.isView(body)) return Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+    if (typeof ReadableStream !== 'undefined' && body instanceof ReadableStream) {
+        const reader = body.getReader();
+        const chunks = [];
+        try {
+            for(;;){
+                const { done, value } = await reader.read();
+                if (done) break;
+                if (value) chunks.push(value);
             }
-            chunks.push(value);
+        } finally{
+            reader.releaseLock();
         }
-    } finally{
-        reader.releaseLock();
+        return Buffer.concat(chunks.map((chunk)=>Buffer.from(chunk)));
     }
-    return Buffer.concat(chunks.map((chunk)=>Buffer.from(chunk))).toString('utf8');
+    throw new Error('unsupported request body');
+}
+function toResponse(status, statusText, headers, body) {
+    const responseHeaders = new Headers();
+    for (const [name, value] of Object.entries(headers)){
+        if (value === undefined) continue;
+        if (Array.isArray(value)) {
+            for (const entry of value)responseHeaders.append(name, entry);
+        } else {
+            responseHeaders.append(name, value);
+        }
+    }
+    // The fetch spec gives these statuses a null body, and the Response
+    // constructor rejects a body for them.
+    const nullBody = status === 204 || status === 205 || status === 304;
+    return new Response(nullBody ? null : body, {
+        status,
+        statusText,
+        headers: responseHeaders
+    });
 }
-async function fetchOnce(url, init, context, allowLoopback, timeoutMs) {
-    await assertResolvesToSafeAddress(url, context, allowLoopback);
-    const controller = new AbortController();
-    const timeout = setTimeout(()=>controller.abort(), timeoutMs);
+async function requestOnce(url, init, context, addresses, timeoutMs) {
+    var _init_method;
+    let body;
     try {
-        return await fetch(url, {
-            ...init,
-            redirect: 'manual',
-            signal: controller.signal
-        });
+        body = await toRequestBody(init.body);
     } catch  {
-        // Never surface the underlying error (ECONNREFUSED host/port, DNS detail, etc.)
         throw new DiscoveryFetchError(`Failed to fetch ${context}`);
-    } finally{
-        clearTimeout(timeout);
     }
+    const transport = url.protocol === 'https:' ? https : http;
+    const options = {
+        method: ((_init_method = init.method) !== null && _init_method !== void 0 ? _init_method : 'GET').toUpperCase(),
+        headers: toRequestHeaders(init),
+        agent: false,
+        lookup: pinnedLookup(addresses)
+    };
+    return new Promise((resolve, reject)=>{
+        let settled = false;
+        let req;
+        let res;
+        const fail = (message)=>{
+            if (!settled) {
+                settled = true;
+                clearTimeout(deadline);
+                reject(new DiscoveryFetchError(message));
+            }
+        };
+        const deadline = setTimeout(()=>{
+            res === null || res === void 0 ? void 0 : res.destroy();
+            req === null || req === void 0 ? void 0 : req.destroy();
+            fail(`Failed to fetch ${context}`);
+        }, timeoutMs);
+        try {
+            req = transport.request(url, options, (response)=>{
+                var _response_statusMessage;
+                res = response;
+                const status = response.statusCode;
+                const statusText = (_response_statusMessage = response.statusMessage) !== null && _response_statusMessage !== void 0 ? _response_statusMessage : '';
+                if (status === undefined || status < 200 || status > 599) {
+                    response.destroy();
+                    fail(`Failed to fetch ${context}`);
+                    return;
+                }
+                const chunks = [];
+                let total = 0;
+                response.on('data', (chunk)=>{
+                    total += chunk.length;
+                    if (total > MAX_BODY_BYTES) {
+                        response.destroy();
+                        fail(`Refusing to read ${context}: response too large`);
+                        return;
+                    }
+                    chunks.push(chunk);
+                });
+                response.once('error', ()=>fail(`Failed to fetch ${context}`));
+                response.once('end', ()=>{
+                    if (settled) return;
+                    settled = true;
+                    clearTimeout(deadline);
+                    resolve(toResponse(status, statusText, response.headers, Buffer.concat(chunks)));
+                });
+            });
+        } catch  {
+            fail(`Failed to fetch ${context}`);
+            return;
+        }
+        req.once('error', ()=>fail(`Failed to fetch ${context}`));
+        req.end(body);
+    });
+}
+async function fetchOnce(url, init, context, allowLoopback, timeoutMs, lookup) {
+    const addresses = await resolveSafeAddresses(url, context, allowLoopback, lookup, timeoutMs);
+    return requestOnce(url, init, context, addresses, timeoutMs);
 }
 /**
  * Fetches an OAuth-discovery URL with SSRF mitigations applied to the
  * initial URL and every redirect hop; redirects are validated, not auto-followed.
  *
+ * The hostname is resolved once, every returned address is validated, and the
+ * validated set is pinned into the request through a custom `lookup`, so the
+ * request cannot resolve the hostname a second time and cannot be steered to
+ * a different address by a DNS-rebinding answer.
+ *
  * @param rawUrl - URL to fetch; may be remote-server-supplied (the threat this guards against).
  * @param init - Standard fetch options; `redirect` is always forced to `'manual'`.
  * @param context - Short label used only in error messages, never echoing the URL.
  * @param options - See `DiscoveryFetchOptions`.
  */ export async function discoveryFetch(rawUrl, init = {}, context = 'discovery URL', options = {}) {
-    const { allowLoopback = false, timeoutMs = DEFAULT_TIMEOUT_MS } = options;
+    const { allowLoopback = false, timeoutMs = DEFAULT_TIMEOUT_MS, lookup = dns.lookup } = options;
     let url = assertSafeUrl(rawUrl, context, allowLoopback);
-    let response = await fetchOnce(url, init, context, allowLoopback, timeoutMs);
+    let response = await fetchOnce(url, init, context, allowLoopback, timeoutMs, lookup);
     let redirectsLeft = MAX_REDIRECTS;
     while(response.status >= 300 && response.status < 400){
         const location = response.headers.get('location');
@@ -167,7 +315,7 @@ async function fetchOnce(url, init, context, allowLoopback, timeoutMs) {
             throw new DiscoveryFetchError(`Refusing to fetch ${context}: invalid redirect target`);
         }
         url = assertSafeUrl(nextUrl.toString(), context, allowLoopback);
-        response = await fetchOnce(url, init, context, allowLoopback, timeoutMs);
+        response = await fetchOnce(url, init, context, allowLoopback, timeoutMs, lookup);
     }
     return response;
 }
@@ -182,3 +330,35 @@ async function fetchOnce(url, init, context, allowLoopback, timeoutMs) {
         throw new DiscoveryFetchError(`Refusing to parse ${context}: invalid JSON`);
     }
 }
+async function readLimited(response, context, maxBytes) {
+    var _response_body;
+    const contentLength = response.headers.get('content-length');
+    if (contentLength && Number(contentLength) > maxBytes) {
+        throw new DiscoveryFetchError(`Refusing to read ${context}: response too large`);
+    }
+    const reader = (_response_body = response.body) === null || _response_body === void 0 ? void 0 : _response_body.getReader();
+    if (!reader) {
+        const text = await response.text();
+        if (Buffer.byteLength(text, 'utf8') > maxBytes) {
+            throw new DiscoveryFetchError(`Refusing to read ${context}: response too large`);
+        }
+        return text;
+    }
+    const chunks = [];
+    let total = 0;
+    try {
+        for(;;){
+            const { done, value } = await reader.read();
+            if (done) break;
+            if (!value) continue;
+            total += value.byteLength;
+            if (total > maxBytes) {
+                throw new DiscoveryFetchError(`Refusing to read ${context}: response too large`);
+            }
+            chunks.push(value);
+        }
+    } finally{
+        reader.releaseLock();
+    }
+    return Buffer.concat(chunks.map((chunk)=>Buffer.from(chunk))).toString('utf8');
+}

package/dist/esm/auth/discovery-fetch.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/mcp-z/client/src/auth/discovery-fetch.ts"],"sourcesContent":["/**\n * Hardened fetch for OAuth discovery URLs, which the remote MCP server\n * controls (SSRF mitigation). See ARCHITECTURE.md's \"SSRF mitigation\" section for the threat model.\n */\nimport dns from 'node:dns/promises';\nimport { isIP } from 'node:net';\nimport ipaddr from 'ipaddr.js';\n\nexport class DiscoveryFetchError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'DiscoveryFetchError';\n  }\n}\n\nconst DEFAULT_TIMEOUT_MS = 10_000;\nconst MAX_REDIRECTS = 5;\nconst MAX_BODY_BYTES = 1_000_000; // 1 MB - discovery documents are small JSON\n\nfunction stripBrackets(hostname: string): string {\n  return hostname.startsWith('[') && hostname.endsWith(']') ? hostname.slice(1, -1) : hostname;\n}\n\n/** True for the literal hostname `localhost` or an IP literal in the loopback range. */\nfunction isLoopbackHost(hostname: string): boolean {\n  const host = stripBrackets(hostname).toLowerCase();\n  if (host === 'localhost') return true;\n  if (isIP(host)) {\n    try {\n      return ipaddr.process(host).range() === 'loopback';\n    } catch {\n      return false;\n    }\n  }\n  return false;\n}\n\n/**\n * True if `rawUrl`'s host is loopback, used to decide `allowLoopback` grants\n * from the URL the caller configured, not remote-supplied data. Fails closed on an unparseable URL.\n */\nexport function isLoopbackUrl(rawUrl: string): boolean {\n  try {\n    return isLoopbackHost(new URL(rawUrl).hostname);\n  } catch {\n    return false;\n  }\n}\n\n/** True when the address is anything other than ordinary public unicast space. */\nfunction isBlockedAddress(address: string): boolean {\n  try {\n    // ipaddr.process() normalizes IPv4-mapped IPv6 (::ffff:a.b.c.d) to IPv4 first.\n    return ipaddr.process(address).range() !== 'unicast';\n  } catch {\n    return true; // unparseable - fail closed\n  }\n}\n\n/**\n * Validates scheme and, for literal-IP hosts, address range. `allowLoopback`\n * reflects trust in the calling server, never in `rawUrl` itself.\n */\nfunction assertSafeUrl(rawUrl: string, context: string, allowLoopback: boolean): URL {\n  let url: URL;\n  try {\n    url = new URL(rawUrl);\n  } catch {\n    throw new DiscoveryFetchError(`Refusing to fetch ${context}: invalid URL`);\n  }\n\n  if (url.protocol !== 'https:' && url.protocol !== 'http:') {\n    throw new DiscoveryFetchError(`Refusing to fetch ${context}: unsupported scheme`);\n  }\n\n  const host = stripBrackets(url.hostname);\n  const trustedLoopback = allowLoopback && isLoopbackHost(host);\n  if (trustedLoopback) return url; // this call's own grant covers it, regardless of scheme\n\n  if (url.protocol === 'http:') {\n    throw new DiscoveryFetchError(`Refusing to fetch ${context}: http:// is only allowed for a trusted loopback origin`);\n  }\n\n  if (isIP(host) && isBlockedAddress(host)) {\n    throw new DiscoveryFetchError(`Refusing to fetch ${context}: address is not publicly routable`);\n  }\n\n  return url;\n}\n\n/**\n * Resolves the hostname and rejects it if any address is private/reserved.\n * Does not close the DNS-rebinding TOCTOU race against `fetch`'s own resolution a moment later.\n */\nasync function assertResolvesToSafeAddress(url: URL, context: string, allowLoopback: boolean): Promise<void> {\n  const host = stripBrackets(url.hostname);\n  if (isIP(host)) return; // literal IP already fully checked in assertSafeUrl\n  if (allowLoopback && isLoopbackHost(host)) return; // literal \"localhost\" under a trusted-loopback grant\n\n  let addresses: string[];\n  try {\n    const records = await dns.lookup(host, { all: true, verbatim: true });\n    addresses = records.map((record) => record.address);\n  } catch {\n    throw new DiscoveryFetchError(`Refusing to fetch ${context}: host could not be resolved`);\n  }\n\n  if (addresses.length === 0 || addresses.some((address) => isBlockedAddress(address))) {\n    throw new DiscoveryFetchError(`Refusing to fetch ${context}: host resolves to an address that is not publicly routable`);\n  }\n}\n\nasync function readLimited(response: Response, context: string, maxBytes: number): Promise<string> {\n  const contentLength = response.headers.get('content-length');\n  if (contentLength && Number(contentLength) > maxBytes) {\n    throw new DiscoveryFetchError(`Refusing to read ${context}: response too large`);\n  }\n\n  const reader = response.body?.getReader();\n  if (!reader) {\n    const text = await response.text();\n    if (Buffer.byteLength(text, 'utf8') > maxBytes) {\n      throw new DiscoveryFetchError(`Refusing to read ${context}: response too large`);\n    }\n    return text;\n  }\n\n  const chunks: Uint8Array[] = [];\n  let total = 0;\n  try {\n    for (;;) {\n      const { done, value } = await reader.read();\n      if (done) break;\n      if (!value) continue;\n      total += value.byteLength;\n      if (total > maxBytes) {\n        throw new DiscoveryFetchError(`Refusing to read ${context}: response too large`);\n      }\n      chunks.push(value);\n    }\n  } finally {\n    reader.releaseLock();\n  }\n\n  return Buffer.concat(chunks.map((chunk) => Buffer.from(chunk))).toString('utf8');\n}\n\nasync function fetchOnce(url: URL, init: RequestInit, context: string, allowLoopback: boolean, timeoutMs: number): Promise<Response> {\n  await assertResolvesToSafeAddress(url, context, allowLoopback);\n\n  const controller = new AbortController();\n  const timeout = setTimeout(() => controller.abort(), timeoutMs);\n  try {\n    return await fetch(url, { ...init, redirect: 'manual', signal: controller.signal });\n  } catch {\n    // Never surface the underlying error (ECONNREFUSED host/port, DNS detail, etc.)\n    throw new DiscoveryFetchError(`Failed to fetch ${context}`);\n  } finally {\n    clearTimeout(timeout);\n  }\n}\n\nexport interface DiscoveryFetchOptions {\n  /**\n   * Loopback trust grant for this fetch, computed from the server the caller\n   * is actually talking to - never from the URL being fetched. Defaults to `false`.\n   */\n  allowLoopback?: boolean;\n  /**\n   * Per-request connect/read timeout in ms. Defaults to `DEFAULT_TIMEOUT_MS`;\n   * overridable so tests can bound slow-failure cases.\n   */\n  timeoutMs?: number;\n}\n\n/**\n * Fetches an OAuth-discovery URL with SSRF mitigations applied to the\n * initial URL and every redirect hop; redirects are validated, not auto-followed.\n *\n * @param rawUrl - URL to fetch; may be remote-server-supplied (the threat this guards against).\n * @param init - Standard fetch options; `redirect` is always forced to `'manual'`.\n * @param context - Short label used only in error messages, never echoing the URL.\n * @param options - See `DiscoveryFetchOptions`.\n */\nexport async function discoveryFetch(rawUrl: string, init: RequestInit = {}, context = 'discovery URL', options: DiscoveryFetchOptions = {}): Promise<Response> {\n  const { allowLoopback = false, timeoutMs = DEFAULT_TIMEOUT_MS } = options;\n\n  let url = assertSafeUrl(rawUrl, context, allowLoopback);\n  let response = await fetchOnce(url, init, context, allowLoopback, timeoutMs);\n\n  let redirectsLeft = MAX_REDIRECTS;\n  while (response.status >= 300 && response.status < 400) {\n    const location = response.headers.get('location');\n    if (!location) break;\n    if (redirectsLeft <= 0) {\n      throw new DiscoveryFetchError(`Refusing to fetch ${context}: too many redirects`);\n    }\n    redirectsLeft -= 1;\n\n    let nextUrl: URL;\n    try {\n      nextUrl = new URL(location, url);\n    } catch {\n      throw new DiscoveryFetchError(`Refusing to fetch ${context}: invalid redirect target`);\n    }\n    url = assertSafeUrl(nextUrl.toString(), context, allowLoopback);\n    response = await fetchOnce(url, init, context, allowLoopback, timeoutMs);\n  }\n\n  return response;\n}\n\n/**\n * Parse a `discoveryFetch` response body as JSON, enforcing `MAX_BODY_BYTES`\n * while reading (not after buffering the whole thing).\n */\nexport async function readDiscoveryJson<T>(response: Response, context: string): Promise<T> {\n  const text = await readLimited(response, context, MAX_BODY_BYTES);\n  try {\n    return JSON.parse(text) as T;\n  } catch {\n    throw new DiscoveryFetchError(`Refusing to parse ${context}: invalid JSON`);\n  }\n}\n"],"names":["dns","isIP","ipaddr","DiscoveryFetchError","Error","message","name","DEFAULT_TIMEOUT_MS","MAX_REDIRECTS","MAX_BODY_BYTES","stripBrackets","hostname","startsWith","endsWith","slice","isLoopbackHost","host","toLowerCase","process","range","isLoopbackUrl","rawUrl","URL","isBlockedAddress","address","assertSafeUrl","context","allowLoopback","url","protocol","trustedLoopback","assertResolvesToSafeAddress","addresses","records","lookup","all","verbatim","map","record","length","some","readLimited","response","maxBytes","contentLength","headers","get","Number","reader","body","getReader","text","Buffer","byteLength","chunks","total","done","value","read","push","releaseLock","concat","chunk","from","toString","fetchOnce","init","timeoutMs","controller","AbortController","timeout","setTimeout","abort","fetch","redirect","signal","clearTimeout","discoveryFetch","options","redirectsLeft","status","location","nextUrl","readDiscoveryJson","JSON","parse"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/mcp-z/client/src/auth/discovery-fetch.ts"],"sourcesContent":["/**\n * Hardened fetch for OAuth discovery URLs, which the remote MCP server\n * controls (SSRF mitigation). See ARCHITECTURE.md's \"SSRF mitigation\" section for the threat model.\n */\nimport dns from 'node:dns';\nimport http from 'node:http';\nimport https from 'node:https';\nimport { isIP, type LookupFunction } from 'node:net';\nimport ipaddr from 'ipaddr.js';\n\nexport class DiscoveryFetchError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'DiscoveryFetchError';\n  }\n}\n\nconst DEFAULT_TIMEOUT_MS = 10_000;\nconst MAX_REDIRECTS = 5;\nconst MAX_BODY_BYTES = 1_000_000; // 1 MB - discovery documents are small JSON\n\ntype LookupRecord = { address: string; family: number };\n/** DNS implementation, injectable for deterministic tests. Same contract as `dns.lookup` with `{ all: true, verbatim: true }`. */\ntype Lookup = (hostname: string, options: { all: true; verbatim: true }, callback: (error: NodeJS.ErrnoException | null, addresses: LookupRecord[]) => void) => void;\n\nfunction stripBrackets(hostname: string): string {\n  return hostname.startsWith('[') && hostname.endsWith(']') ? hostname.slice(1, -1) : hostname;\n}\n\n/** True for the literal hostname `localhost` or an IP literal in the loopback range. */\nfunction isLoopbackHost(hostname: string): boolean {\n  const host = stripBrackets(hostname).toLowerCase();\n  if (host === 'localhost') return true;\n  if (isIP(host)) {\n    try {\n      return ipaddr.process(host).range() === 'loopback';\n    } catch {\n      return false;\n    }\n  }\n  return false;\n}\n\n/**\n * True if `rawUrl`'s host is loopback, used to decide `allowLoopback` grants\n * from the URL the caller configured, not remote-supplied data. Fails closed on an unparseable URL.\n */\nexport function isLoopbackUrl(rawUrl: string): boolean {\n  try {\n    return isLoopbackHost(new URL(rawUrl).hostname);\n  } catch {\n    return false;\n  }\n}\n\n/** True when the address is anything other than ordinary public unicast space. */\nfunction isBlockedAddress(address: string): boolean {\n  try {\n    // ipaddr.process() normalizes IPv4-mapped IPv6 (::ffff:a.b.c.d) to IPv4 first.\n    return ipaddr.process(address).range() !== 'unicast';\n  } catch {\n    return true; // unparseable - fail closed\n  }\n}\n\nfunction isLoopbackAddress(address: string): boolean {\n  try {\n    return ipaddr.process(address).range() === 'loopback';\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Validates scheme and, for literal-IP hosts, address range. `allowLoopback`\n * reflects trust in the calling server, never in `rawUrl` itself.\n */\nfunction assertSafeUrl(rawUrl: string, context: string, allowLoopback: boolean): URL {\n  let url: URL;\n  try {\n    url = new URL(rawUrl);\n  } catch {\n    throw new DiscoveryFetchError(`Refusing to fetch ${context}: invalid URL`);\n  }\n\n  if (url.protocol !== 'https:' && url.protocol !== 'http:') {\n    throw new DiscoveryFetchError(`Refusing to fetch ${context}: unsupported scheme`);\n  }\n\n  const host = stripBrackets(url.hostname);\n  const trustedLoopback = allowLoopback && isLoopbackHost(host);\n  if (trustedLoopback) return url; // this call's own grant covers it, regardless of scheme\n\n  if (url.protocol === 'http:') {\n    throw new DiscoveryFetchError(`Refusing to fetch ${context}: http:// is only allowed for a trusted loopback origin`);\n  }\n\n  if (isIP(host) && isBlockedAddress(host)) {\n    throw new DiscoveryFetchError(`Refusing to fetch ${context}: address is not publicly routable`);\n  }\n\n  return url;\n}\n\nfunction lookupAll(hostname: string, lookup: Lookup, timeoutMs: number): Promise<LookupRecord[]> {\n  return new Promise((resolve, reject) => {\n    let settled = false;\n    const deadline = setTimeout(() => {\n      if (!settled) {\n        settled = true;\n        reject(new Error('DNS resolution timed out'));\n      }\n    }, timeoutMs);\n    try {\n      lookup(hostname, { all: true, verbatim: true }, (error, addresses) => {\n        if (settled) return;\n        settled = true;\n        clearTimeout(deadline);\n        if (error || addresses.length === 0) reject(new Error('DNS resolution failed'));\n        else resolve(addresses);\n      });\n    } catch {\n      if (!settled) {\n        settled = true;\n        clearTimeout(deadline);\n        reject(new Error('DNS resolution failed'));\n      }\n    }\n  });\n}\n\n/**\n * Resolves the hostname once, rejects it unless every returned address is\n * acceptable, and returns the validated set. The set is pinned into the\n * request itself (see `requestOnce`), which is what closes the DNS-rebinding\n * TOCTOU: the transport can only dial addresses that were already validated,\n * and it never resolves the hostname a second time.\n */\nasync function resolveSafeAddresses(url: URL, context: string, allowLoopback: boolean, lookup: Lookup, timeoutMs: number): Promise<LookupRecord[]> {\n  const host = stripBrackets(url.hostname);\n  if (isIP(host)) return [{ address: host, family: host.includes(':') ? 6 : 4 }]; // literal IP already fully checked in assertSafeUrl\n\n  // Literal `localhost` under a trusted-loopback grant: still resolved, and the\n  // answers must be loopback - the grant covers loopback, not \"wherever\n  // localhost happens to point\".\n  const loopbackGrant = allowLoopback && isLoopbackHost(host);\n\n  let addresses: LookupRecord[];\n  try {\n    addresses = await lookupAll(host, lookup, timeoutMs);\n  } catch {\n    throw new DiscoveryFetchError(`Refusing to fetch ${context}: host could not be resolved`);\n  }\n\n  if (loopbackGrant) {\n    if (!addresses.every((record) => isLoopbackAddress(record.address))) {\n      throw new DiscoveryFetchError(`Refusing to fetch ${context}: host does not resolve to a loopback address`);\n    }\n  } else if (addresses.some((record) => isBlockedAddress(record.address))) {\n    throw new DiscoveryFetchError(`Refusing to fetch ${context}: host resolves to an address that is not publicly routable`);\n  }\n\n  return addresses;\n}\n\n/**\n * A `net` lookup that can only ever answer with `addresses` - the set already\n * validated for this URL. The request is built against the original URL (so\n * SNI and certificate verification still see the hostname), but the\n * connection can only land on a validated address.\n */\nfunction pinnedLookup(addresses: LookupRecord[]): LookupFunction {\n  return (_hostname, options, callback) => {\n    if (typeof options === 'object' && options.all === true) {\n      callback(null, addresses);\n      return;\n    }\n    const first = addresses[0];\n    if (!first) {\n      callback(Object.assign(new Error('no validated address'), { code: 'ENOTFOUND' }) as NodeJS.ErrnoException, '', 0);\n      return;\n    }\n    callback(null, first.address, first.family);\n  };\n}\n\nfunction toRequestHeaders(init: RequestInit): Record<string, string> {\n  const headers = new Headers(init.headers);\n  const out: Record<string, string> = {};\n  for (const [name, value] of headers) out[name] = value;\n  return out;\n}\n\nasync function toRequestBody(body: RequestInit['body']): Promise<Buffer | undefined> {\n  if (body === undefined || body === null) return undefined;\n  if (typeof body === 'string') return Buffer.from(body);\n  if (body instanceof URLSearchParams) return Buffer.from(body.toString());\n  if (body instanceof Blob) return Buffer.from(await body.arrayBuffer());\n  if (body instanceof ArrayBuffer) return Buffer.from(body);\n  if (ArrayBuffer.isView(body)) return Buffer.from(body.buffer, body.byteOffset, body.byteLength);\n  if (typeof ReadableStream !== 'undefined' && body instanceof ReadableStream) {\n    const reader = body.getReader();\n    const chunks: Uint8Array[] = [];\n    try {\n      for (;;) {\n        const { done, value } = await reader.read();\n        if (done) break;\n        if (value) chunks.push(value);\n      }\n    } finally {\n      reader.releaseLock();\n    }\n    return Buffer.concat(chunks.map((chunk) => Buffer.from(chunk)));\n  }\n  throw new Error('unsupported request body');\n}\n\nfunction toResponse(status: number, statusText: string, headers: http.IncomingHttpHeaders, body: Buffer): Response {\n  const responseHeaders = new Headers();\n  for (const [name, value] of Object.entries(headers)) {\n    if (value === undefined) continue;\n    if (Array.isArray(value)) {\n      for (const entry of value) responseHeaders.append(name, entry);\n    } else {\n      responseHeaders.append(name, value);\n    }\n  }\n  // The fetch spec gives these statuses a null body, and the Response\n  // constructor rejects a body for them.\n  const nullBody = status === 204 || status === 205 || status === 304;\n  return new Response(nullBody ? null : body, { status, statusText, headers: responseHeaders });\n}\n\nasync function requestOnce(url: URL, init: RequestInit, context: string, addresses: LookupRecord[], timeoutMs: number): Promise<Response> {\n  let body: Buffer | undefined;\n  try {\n    body = await toRequestBody(init.body);\n  } catch {\n    throw new DiscoveryFetchError(`Failed to fetch ${context}`);\n  }\n\n  const transport = url.protocol === 'https:' ? https : http;\n  const options: http.RequestOptions = { method: (init.method ?? 'GET').toUpperCase(), headers: toRequestHeaders(init), agent: false, lookup: pinnedLookup(addresses) };\n\n  return new Promise<Response>((resolve, reject) => {\n    let settled = false;\n    let req: http.ClientRequest | undefined;\n    let res: http.IncomingMessage | undefined;\n    const fail = (message: string): void => {\n      if (!settled) {\n        settled = true;\n        clearTimeout(deadline);\n        reject(new DiscoveryFetchError(message));\n      }\n    };\n    const deadline = setTimeout(() => {\n      res?.destroy();\n      req?.destroy();\n      fail(`Failed to fetch ${context}`);\n    }, timeoutMs);\n\n    try {\n      req = transport.request(url, options, (response) => {\n        res = response;\n        const status = response.statusCode;\n        const statusText = response.statusMessage ?? '';\n        if (status === undefined || status < 200 || status > 599) {\n          response.destroy();\n          fail(`Failed to fetch ${context}`);\n          return;\n        }\n        const chunks: Buffer[] = [];\n        let total = 0;\n        response.on('data', (chunk: Buffer) => {\n          total += chunk.length;\n          if (total > MAX_BODY_BYTES) {\n            response.destroy();\n            fail(`Refusing to read ${context}: response too large`);\n            return;\n          }\n          chunks.push(chunk);\n        });\n        response.once('error', () => fail(`Failed to fetch ${context}`));\n        response.once('end', () => {\n          if (settled) return;\n          settled = true;\n          clearTimeout(deadline);\n          resolve(toResponse(status, statusText, response.headers, Buffer.concat(chunks)));\n        });\n      });\n    } catch {\n      fail(`Failed to fetch ${context}`);\n      return;\n    }\n\n    req.once('error', () => fail(`Failed to fetch ${context}`));\n    req.end(body);\n  });\n}\n\nasync function fetchOnce(url: URL, init: RequestInit, context: string, allowLoopback: boolean, timeoutMs: number, lookup: Lookup): Promise<Response> {\n  const addresses = await resolveSafeAddresses(url, context, allowLoopback, lookup, timeoutMs);\n  return requestOnce(url, init, context, addresses, timeoutMs);\n}\n\nexport interface DiscoveryFetchOptions {\n  /**\n   * Loopback trust grant for this fetch, computed from the server the caller\n   * is actually talking to - never from the URL being fetched. Defaults to `false`.\n   */\n  allowLoopback?: boolean;\n  /**\n   * Per-hop timeout in ms, applied to both the DNS resolution and the request.\n   * Defaults to `DEFAULT_TIMEOUT_MS`; overridable so tests can bound slow-failure cases.\n   */\n  timeoutMs?: number;\n  /**\n   * DNS implementation used for the pre-request resolution, injectable for\n   * deterministic tests. Defaults to `dns.lookup`.\n   */\n  lookup?: Lookup;\n}\n\n/**\n * Fetches an OAuth-discovery URL with SSRF mitigations applied to the\n * initial URL and every redirect hop; redirects are validated, not auto-followed.\n *\n * The hostname is resolved once, every returned address is validated, and the\n * validated set is pinned into the request through a custom `lookup`, so the\n * request cannot resolve the hostname a second time and cannot be steered to\n * a different address by a DNS-rebinding answer.\n *\n * @param rawUrl - URL to fetch; may be remote-server-supplied (the threat this guards against).\n * @param init - Standard fetch options; `redirect` is always forced to `'manual'`.\n * @param context - Short label used only in error messages, never echoing the URL.\n * @param options - See `DiscoveryFetchOptions`.\n */\nexport async function discoveryFetch(rawUrl: string, init: RequestInit = {}, context = 'discovery URL', options: DiscoveryFetchOptions = {}): Promise<Response> {\n  const { allowLoopback = false, timeoutMs = DEFAULT_TIMEOUT_MS, lookup = dns.lookup as unknown as Lookup } = options;\n\n  let url = assertSafeUrl(rawUrl, context, allowLoopback);\n  let response = await fetchOnce(url, init, context, allowLoopback, timeoutMs, lookup);\n\n  let redirectsLeft = MAX_REDIRECTS;\n  while (response.status >= 300 && response.status < 400) {\n    const location = response.headers.get('location');\n    if (!location) break;\n    if (redirectsLeft <= 0) {\n      throw new DiscoveryFetchError(`Refusing to fetch ${context}: too many redirects`);\n    }\n    redirectsLeft -= 1;\n\n    let nextUrl: URL;\n    try {\n      nextUrl = new URL(location, url);\n    } catch {\n      throw new DiscoveryFetchError(`Refusing to fetch ${context}: invalid redirect target`);\n    }\n    url = assertSafeUrl(nextUrl.toString(), context, allowLoopback);\n    response = await fetchOnce(url, init, context, allowLoopback, timeoutMs, lookup);\n  }\n\n  return response;\n}\n\n/**\n * Parse a `discoveryFetch` response body as JSON, enforcing `MAX_BODY_BYTES`\n * while reading (not after buffering the whole thing).\n */\nexport async function readDiscoveryJson<T>(response: Response, context: string): Promise<T> {\n  const text = await readLimited(response, context, MAX_BODY_BYTES);\n  try {\n    return JSON.parse(text) as T;\n  } catch {\n    throw new DiscoveryFetchError(`Refusing to parse ${context}: invalid JSON`);\n  }\n}\n\nasync function readLimited(response: Response, context: string, maxBytes: number): Promise<string> {\n  const contentLength = response.headers.get('content-length');\n  if (contentLength && Number(contentLength) > maxBytes) {\n    throw new DiscoveryFetchError(`Refusing to read ${context}: response too large`);\n  }\n\n  const reader = response.body?.getReader();\n  if (!reader) {\n    const text = await response.text();\n    if (Buffer.byteLength(text, 'utf8') > maxBytes) {\n      throw new DiscoveryFetchError(`Refusing to read ${context}: response too large`);\n    }\n    return text;\n  }\n\n  const chunks: Uint8Array[] = [];\n  let total = 0;\n  try {\n    for (;;) {\n      const { done, value } = await reader.read();\n      if (done) break;\n      if (!value) continue;\n      total += value.byteLength;\n      if (total > maxBytes) {\n        throw new DiscoveryFetchError(`Refusing to read ${context}: response too large`);\n      }\n      chunks.push(value);\n    }\n  } finally {\n    reader.releaseLock();\n  }\n\n  return Buffer.concat(chunks.map((chunk) => Buffer.from(chunk))).toString('utf8');\n}\n"],"names":["dns","http","https","isIP","ipaddr","DiscoveryFetchError","Error","message","name","DEFAULT_TIMEOUT_MS","MAX_REDIRECTS","MAX_BODY_BYTES","stripBrackets","hostname","startsWith","endsWith","slice","isLoopbackHost","host","toLowerCase","process","range","isLoopbackUrl","rawUrl","URL","isBlockedAddress","address","isLoopbackAddress","assertSafeUrl","context","allowLoopback","url","protocol","trustedLoopback","lookupAll","lookup","timeoutMs","Promise","resolve","reject","settled","deadline","setTimeout","all","verbatim","error","addresses","clearTimeout","length","resolveSafeAddresses","family","includes","loopbackGrant","every","record","some","pinnedLookup","_hostname","options","callback","first","Object","assign","code","toRequestHeaders","init","headers","Headers","out","value","toRequestBody","body","undefined","Buffer","from","URLSearchParams","toString","Blob","arrayBuffer","ArrayBuffer","isView","buffer","byteOffset","byteLength","ReadableStream","reader","getReader","chunks","done","read","push","releaseLock","concat","map","chunk","toResponse","status","statusText","responseHeaders","entries","Array","isArray","entry","append","nullBody","Response","requestOnce","transport","method","toUpperCase","agent","req","res","fail","destroy","request","response","statusCode","statusMessage","total","on","once","end","fetchOnce","discoveryFetch","redirectsLeft","location","get","nextUrl","readDiscoveryJson","text","readLimited","JSON","parse","maxBytes","contentLength","Number"],"mappings":"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"}

package/dist/esm/auth/interactive-oauth-flow.d.ts

@@ -29,12 +29,18 @@ export declare class InteractiveOAuthFlow {
      *   'https://example.com/oauth/token',
      *   'client-id',
      *   'client-secret',
-     *   { port, scopes: ['read', 'write'] }
+     *   { port, issuer: 'https://example.com', resource: 'https://example.com/mcp', scopes: ['read', 'write'] }
      * );
      */
     performAuthFlow(authorizationEndpoint: string, tokenEndpoint: string, clientId: string, clientSecret: string, options: OAuthFlowOptions): Promise<TokenSet>;
+    /**
+     * Rejects an authorization response that was not minted by the issuer
+     * discovered before the flow started (RFC 9207 authorization-server mix-up).
+     */
+    private assertResponseIssuer;
     /**
      * Exchanges an authorization code for access and refresh tokens.
+     * @param resource - Canonical resource server URI, audience-binding the token (RFC 8707).
      * @param allowLoopback - Loopback trust grant computed by the caller from the server it is actually talking to, never from `tokenEndpoint`.
      * @param codeVerifier - Optional PKCE code verifier (RFC 7636).
      */
@@ -45,11 +51,12 @@ export declare class InteractiveOAuthFlow {
      * @param refreshToken - Refresh token from a previous token set.
      * @param clientId - OAuth client ID.
      * @param clientSecret - OAuth client secret.
+     * @param resource - Canonical resource server URI, audience-binding the token (RFC 8707).
      * @param allowLoopback - Loopback trust grant computed by the caller from the server it is actually talking to, never from `tokenEndpoint`. Defaults to `false`.
      * @returns New token set with a refreshed access token.
      * @throws Error if refresh fails.
      */
-    refreshTokens(tokenEndpoint: string, refreshToken: string, clientId: string, clientSecret: string, allowLoopback?: boolean): Promise<TokenSet>;
+    refreshTokens(tokenEndpoint: string, refreshToken: string, clientId: string, clientSecret: string, resource: string, allowLoopback?: boolean): Promise<TokenSet>;
     /**
      * Open browser to authorization URL
      * Uses platform-specific command to open default browser