@mcp-z/client 2.2.4 → 2.3.0

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

@@ -2,7 +2,7 @@
  * RFC 9728 Protected Resource Metadata Discovery
  * Probes .well-known/oauth-protected-resource endpoint
  */ import { joinWellKnown, normalizeUrl } from '../lib/url-utils.js';
-import { discoveryFetch, isLoopbackUrl, readDiscoveryJson } from './discovery-fetch.js';
+import { discoveryFetch, isLoopbackUrl, readDiscoveryJson, throwIfAborted } from './discovery-fetch.js';
 /** Returns `url`'s origin (protocol + host), or the original string if it doesn't parse. */ function getOrigin(url) {
     try {
         return new URL(url).origin;
@@ -24,13 +24,15 @@ import { discoveryFetch, isLoopbackUrl, readDiscoveryJson } from './discovery-fe
  *
  * @param resourceUrl - URL of the protected resource (e.g. `https://ai.todoist.net/mcp`).
  * @returns Discovered metadata, or `null` if none is found.
- */ export async function discoverProtectedResourceMetadata(resourceUrl) {
+ */ export async function discoverProtectedResourceMetadata(resourceUrl, options = {}) {
+    const { signal } = options;
     try {
+        throwIfAborted(signal);
         const normalizedResourceUrl = normalizeUrl(resourceUrl);
         // resourceUrl is the server the caller configured (never remote-supplied);
         // its loopback-ness is the trust signal every fetch below relies on.
         const allowLoopback = isLoopbackUrl(normalizedResourceUrl);
-        const headerMetadata = await discoverProtectedResourceMetadataFromHeader(normalizedResourceUrl, allowLoopback);
+        const headerMetadata = await discoverProtectedResourceMetadataFromHeader(normalizedResourceUrl, allowLoopback, signal);
         if (headerMetadata) return headerMetadata;
         // Strategy 0: Try path-local well-known (supports path-prefixed deployments like /outlook)
         const localWellKnownUrl = joinWellKnown(normalizedResourceUrl, '/.well-known/oauth-protected-resource');
@@ -40,7 +42,8 @@ import { discoveryFetch, isLoopbackUrl, readDiscoveryJson } from './discovery-fe
                 headers: {
                     Accept: 'application/json',
                     Connection: 'close'
-                }
+                },
+                signal
             }, 'protected resource metadata (path-local)', {
                 allowLoopback
             });
@@ -48,6 +51,7 @@ import { discoveryFetch, isLoopbackUrl, readDiscoveryJson } from './discovery-fe
                 return await readDiscoveryJson(response, 'protected resource metadata (path-local)');
             }
         } catch  {
+            throwIfAborted(signal);
         // Continue to origin-based discovery
         }
         const origin = getOrigin(normalizedResourceUrl);
@@ -60,7 +64,8 @@ import { discoveryFetch, isLoopbackUrl, readDiscoveryJson } from './discovery-fe
                 headers: {
                     Accept: 'application/json',
                     Connection: 'close'
-                }
+                },
+                signal
             }, 'protected resource metadata (root)', {
                 allowLoopback
             });
@@ -89,7 +94,8 @@ import { discoveryFetch, isLoopbackUrl, readDiscoveryJson } from './discovery-fe
                             headers: {
                                 Accept: 'application/json',
                                 Connection: 'close'
-                            }
+                            },
+                            signal
                         }, 'protected resource metadata (sub-path)', {
                             allowLoopback
                         });
@@ -97,6 +103,7 @@ import { discoveryFetch, isLoopbackUrl, readDiscoveryJson } from './discovery-fe
                             return await readDiscoveryJson(subPathResponse, 'protected resource metadata (sub-path)');
                         }
                     } catch  {
+                        throwIfAborted(signal);
                     // Sub-path failed, use root metadata
                     }
                     // Return root metadata as it applies to this resource
@@ -105,6 +112,7 @@ import { discoveryFetch, isLoopbackUrl, readDiscoveryJson } from './discovery-fe
             // Otherwise, try sub-path location before giving up
             }
         } catch  {
+            throwIfAborted(signal);
         // Continue to sub-path location
         }
         // Strategy 2: Try sub-path location (MCP spec extension)
@@ -117,7 +125,8 @@ import { discoveryFetch, isLoopbackUrl, readDiscoveryJson } from './discovery-fe
                     headers: {
                         Accept: 'application/json',
                         Connection: 'close'
-                    }
+                    },
+                    signal
                 }, 'protected resource metadata (sub-path)', {
                     allowLoopback
                 });
@@ -125,24 +134,28 @@ import { discoveryFetch, isLoopbackUrl, readDiscoveryJson } from './discovery-fe
                     return await readDiscoveryJson(response, 'protected resource metadata (sub-path)');
                 }
             } catch  {
+                throwIfAborted(signal);
             // Fall through to return null
             }
         }
         // Neither location found or resource didn't match
         return null;
     } catch (_error) {
+        throwIfAborted(signal);
         // Network error, invalid URL, or other failure
         return null;
     }
 }
-async function discoverProtectedResourceMetadataFromHeader(resourceUrl, allowLoopback) {
+async function discoverProtectedResourceMetadataFromHeader(resourceUrl, allowLoopback, signal) {
     try {
+        throwIfAborted(signal);
         const response = await fetch(resourceUrl, {
             method: 'GET',
             headers: {
                 Accept: 'application/json',
                 Connection: 'close'
-            }
+            },
+            signal
         });
         let header = response.headers.get('www-authenticate');
         if (!header) {
@@ -153,7 +166,8 @@ async function discoverProtectedResourceMetadataFromHeader(resourceUrl, allowLoo
                     Connection: 'close',
                     'Content-Type': 'application/json'
                 },
-                body: '{}'
+                body: '{}',
+                signal
             });
             header = postResponse.headers.get('www-authenticate');
         }
@@ -168,7 +182,8 @@ async function discoverProtectedResourceMetadataFromHeader(resourceUrl, allowLoo
             headers: {
                 Accept: 'application/json',
                 Connection: 'close'
-            }
+            },
+            signal
         }, 'resource_metadata URL', {
             allowLoopback
         });
@@ -177,6 +192,7 @@ async function discoverProtectedResourceMetadataFromHeader(resourceUrl, allowLoo
         }
         return await readDiscoveryJson(metadataResponse, 'resource_metadata URL');
     } catch (_error) {
+        throwIfAborted(signal);
         return null;
     }
 }
@@ -188,8 +204,9 @@ async function discoverProtectedResourceMetadataFromHeader(resourceUrl, allowLoo
  * @param options.allowLoopback - Loopback trust grant computed from the server the caller is actually talking to, never from `authServerUrl` itself. Defaults to `false`.
  * @returns Discovered metadata, or `null` if none is found.
  */ export async function discoverAuthorizationServerMetadata(authServerUrl, options = {}) {
-    const { allowLoopback = false } = options;
+    const { allowLoopback = false, signal } = options;
     try {
+        throwIfAborted(signal);
         const normalizedAuthServerUrl = normalizeUrl(authServerUrl);
         const localWellKnownUrl = joinWellKnown(normalizedAuthServerUrl, '/.well-known/oauth-authorization-server');
         const localResponse = await discoveryFetch(localWellKnownUrl, {
@@ -197,7 +214,8 @@ async function discoverProtectedResourceMetadataFromHeader(resourceUrl, allowLoo
             headers: {
                 Accept: 'application/json',
                 Connection: 'close'
-            }
+            },
+            signal
         }, 'authorization server metadata (path-local)', {
             allowLoopback
         });
@@ -211,7 +229,8 @@ async function discoverProtectedResourceMetadataFromHeader(resourceUrl, allowLoo
             headers: {
                 Accept: 'application/json',
                 Connection: 'close'
-            }
+            },
+            signal
         }, 'authorization server metadata', {
             allowLoopback
         });
@@ -220,6 +239,7 @@ async function discoverProtectedResourceMetadataFromHeader(resourceUrl, allowLoo
         }
         return await readDiscoveryJson(response, 'authorization server metadata');
     } catch (_error) {
+        throwIfAborted(signal);
         return null;
     }
 }
@@ -228,15 +248,18 @@ async function discoverProtectedResourceMetadataFromHeader(resourceUrl, allowLoo
  *
  * @param resourceUrl - URL of the protected resource
  * @returns Issuer URL if present in WWW-Authenticate header, null otherwise
- */ export async function discoverAuthorizationServerIssuer(resourceUrl) {
+ */ export async function discoverAuthorizationServerIssuer(resourceUrl, options = {}) {
+    const { signal } = options;
     try {
         var _match_;
+        throwIfAborted(signal);
         const response = await fetch(resourceUrl, {
             method: 'GET',
             headers: {
                 Accept: 'application/json',
                 Connection: 'close'
-            }
+            },
+            signal
         });
         const header = response.headers.get('www-authenticate');
         if (!header) return null;
@@ -244,6 +267,7 @@ async function discoverProtectedResourceMetadataFromHeader(resourceUrl, allowLoo
         if (!match) return null;
         return (_match_ = match[1]) !== null && _match_ !== void 0 ? _match_ : null;
     } catch (_error) {
+        throwIfAborted(signal);
         return null;
     }
 }

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/mcp-z/client/src/auth/rfc9728-discovery.ts"],"sourcesContent":["/**\n * RFC 9728 Protected Resource Metadata Discovery\n * Probes .well-known/oauth-protected-resource endpoint\n */\n\nimport { joinWellKnown, normalizeUrl } from '../lib/url-utils.ts';\nimport { discoveryFetch, isLoopbackUrl, readDiscoveryJson } from './discovery-fetch.ts';\nimport type { AuthorizationServerMetadata, ProtectedResourceMetadata } from './types.ts';\n\n/** Returns `url`'s origin (protocol + host), or the original string if it doesn't parse. */\nfunction getOrigin(url: string): string {\n  try {\n    return new URL(url).origin;\n  } catch {\n    return url;\n  }\n}\n\n/** Returns `url`'s pathname, or `''` for the root path or an unparseable URL. */\nfunction getPath(url: string): string {\n  try {\n    const parsed = new URL(url);\n    return parsed.pathname === '/' ? '' : parsed.pathname;\n  } catch {\n    return '';\n  }\n}\n\n/**\n * Discovers RFC 9728 Protected Resource Metadata: the `WWW-Authenticate`\n * header first, then `.well-known/oauth-protected-resource` at the origin root and, for a path-prefixed resource, its sub-path variant.\n *\n * @param resourceUrl - URL of the protected resource (e.g. `https://ai.todoist.net/mcp`).\n * @returns Discovered metadata, or `null` if none is found.\n */\nexport async function discoverProtectedResourceMetadata(resourceUrl: string): Promise<ProtectedResourceMetadata | null> {\n  try {\n    const normalizedResourceUrl = normalizeUrl(resourceUrl);\n    // resourceUrl is the server the caller configured (never remote-supplied);\n    // its loopback-ness is the trust signal every fetch below relies on.\n    const allowLoopback = isLoopbackUrl(normalizedResourceUrl);\n    const headerMetadata = await discoverProtectedResourceMetadataFromHeader(normalizedResourceUrl, allowLoopback);\n    if (headerMetadata) return headerMetadata;\n\n    // Strategy 0: Try path-local well-known (supports path-prefixed deployments like /outlook)\n    const localWellKnownUrl = joinWellKnown(normalizedResourceUrl, '/.well-known/oauth-protected-resource');\n    try {\n      const response = await discoveryFetch(\n        localWellKnownUrl,\n        {\n          method: 'GET',\n          headers: { Accept: 'application/json', Connection: 'close' },\n        },\n        'protected resource metadata (path-local)',\n        { allowLoopback }\n      );\n      if (response.ok) {\n        return await readDiscoveryJson<ProtectedResourceMetadata>(response, 'protected resource metadata (path-local)');\n      }\n    } catch {\n      // Continue to origin-based discovery\n    }\n\n    const origin = getOrigin(normalizedResourceUrl);\n    const path = getPath(normalizedResourceUrl);\n\n    // Strategy 1: Try root location (REQUIRED by RFC 9728)\n    const rootUrl = `${origin}/.well-known/oauth-protected-resource`;\n\n    try {\n      const response = await discoveryFetch(\n        rootUrl,\n        {\n          method: 'GET',\n          headers: { Accept: 'application/json', Connection: 'close' },\n        },\n        'protected resource metadata (root)',\n        { allowLoopback }\n      );\n\n      if (response.ok) {\n        const metadata = await readDiscoveryJson<ProtectedResourceMetadata>(response, 'protected resource metadata (root)');\n        // Check if the discovered resource matches what we're looking for\n        if (metadata.resource === normalizedResourceUrl) {\n          return metadata;\n        }\n        // If there's no path component, return root metadata\n        // (e.g., looking for http://example.com and found it)\n        if (!path) {\n          return metadata;\n        }\n        // If requested URL starts with metadata.resource, the root metadata applies to sub-paths\n        // (e.g., looking for http://example.com/api/v1/mcp, found http://example.com)\n        if (normalizedResourceUrl.startsWith(metadata.resource)) {\n          // Still try sub-path location to see if there's more specific metadata\n          // But save root metadata as fallback\n          const rootMetadata = metadata;\n\n          // Try sub-path location for more specific metadata\n          const subPathUrl = `${origin}/.well-known/oauth-protected-resource${path}`;\n          try {\n            const subPathResponse = await discoveryFetch(\n              subPathUrl,\n              {\n                method: 'GET',\n                headers: { Accept: 'application/json', Connection: 'close' },\n              },\n              'protected resource metadata (sub-path)',\n              { allowLoopback }\n            );\n            if (subPathResponse.ok) {\n              return await readDiscoveryJson<ProtectedResourceMetadata>(subPathResponse, 'protected resource metadata (sub-path)');\n            }\n          } catch {\n            // Sub-path failed, use root metadata\n          }\n\n          // Return root metadata as it applies to this resource\n          return rootMetadata;\n        }\n        // Otherwise, try sub-path location before giving up\n      }\n    } catch {\n      // Continue to sub-path location\n    }\n\n    // Strategy 2: Try sub-path location (MCP spec extension)\n    // Only try if there's a path component\n    if (path) {\n      const subPathUrl = `${origin}/.well-known/oauth-protected-resource${path}`;\n\n      try {\n        const response = await discoveryFetch(\n          subPathUrl,\n          {\n            method: 'GET',\n            headers: { Accept: 'application/json', Connection: 'close' },\n          },\n          'protected resource metadata (sub-path)',\n          { allowLoopback }\n        );\n\n        if (response.ok) {\n          return await readDiscoveryJson<ProtectedResourceMetadata>(response, 'protected resource metadata (sub-path)');\n        }\n      } catch {\n        // Fall through to return null\n      }\n    }\n\n    // Neither location found or resource didn't match\n    return null;\n  } catch (_error) {\n    // Network error, invalid URL, or other failure\n    return null;\n  }\n}\n\nasync function discoverProtectedResourceMetadataFromHeader(resourceUrl: string, allowLoopback: boolean): Promise<ProtectedResourceMetadata | null> {\n  try {\n    const response = await fetch(resourceUrl, {\n      method: 'GET',\n      headers: { Accept: 'application/json', Connection: 'close' },\n    });\n\n    let header = response.headers.get('www-authenticate');\n    if (!header) {\n      const postResponse = await fetch(resourceUrl, {\n        method: 'POST',\n        headers: { Accept: 'application/json', Connection: 'close', 'Content-Type': 'application/json' },\n        body: '{}',\n      });\n      header = postResponse.headers.get('www-authenticate');\n    }\n\n    if (!header) return null;\n\n    const match = header.match(/resource_metadata=\"([^\"]+)\"/i);\n    if (!match || !match[1]) return null;\n\n    // metadataUrl is remote-server-chosen (the primary SSRF vector here);\n    // allowLoopback reflects trust in resourceUrl, not in metadataUrl.\n    const metadataUrl = match[1];\n    const metadataResponse = await discoveryFetch(\n      metadataUrl,\n      {\n        method: 'GET',\n        headers: { Accept: 'application/json', Connection: 'close' },\n      },\n      'resource_metadata URL',\n      { allowLoopback }\n    );\n\n    if (!metadataResponse.ok) {\n      return null;\n    }\n\n    return await readDiscoveryJson<ProtectedResourceMetadata>(metadataResponse, 'resource_metadata URL');\n  } catch (_error) {\n    return null;\n  }\n}\n\n/**\n * Discovers RFC 8414 Authorization Server Metadata at\n * `.well-known/oauth-authorization-server`, path-local variant first.\n *\n * @param authServerUrl - URL of the authorization server (typically from RFC 9728 discovery).\n * @param options.allowLoopback - Loopback trust grant computed from the server the caller is actually talking to, never from `authServerUrl` itself. Defaults to `false`.\n * @returns Discovered metadata, or `null` if none is found.\n */\nexport async function discoverAuthorizationServerMetadata(authServerUrl: string, options: { allowLoopback?: boolean } = {}): Promise<AuthorizationServerMetadata | null> {\n  const { allowLoopback = false } = options;\n  try {\n    const normalizedAuthServerUrl = normalizeUrl(authServerUrl);\n    const localWellKnownUrl = joinWellKnown(normalizedAuthServerUrl, '/.well-known/oauth-authorization-server');\n    const localResponse = await discoveryFetch(\n      localWellKnownUrl,\n      {\n        method: 'GET',\n        headers: { Accept: 'application/json', Connection: 'close' },\n      },\n      'authorization server metadata (path-local)',\n      { allowLoopback }\n    );\n\n    if (localResponse.ok) {\n      return await readDiscoveryJson<AuthorizationServerMetadata>(localResponse, 'authorization server metadata (path-local)');\n    }\n\n    const origin = getOrigin(normalizedAuthServerUrl);\n    const wellKnownUrl = `${origin}/.well-known/oauth-authorization-server`;\n\n    const response = await discoveryFetch(\n      wellKnownUrl,\n      {\n        method: 'GET',\n        headers: { Accept: 'application/json', Connection: 'close' },\n      },\n      'authorization server metadata',\n      { allowLoopback }\n    );\n\n    if (!response.ok) {\n      return null;\n    }\n\n    return await readDiscoveryJson<AuthorizationServerMetadata>(response, 'authorization server metadata');\n  } catch (_error) {\n    return null;\n  }\n}\n\n/**\n * Discover OAuth Authorization Server Issuer from resource response (RFC 9207)\n *\n * @param resourceUrl - URL of the protected resource\n * @returns Issuer URL if present in WWW-Authenticate header, null otherwise\n */\nexport async function discoverAuthorizationServerIssuer(resourceUrl: string): Promise<string | null> {\n  try {\n    const response = await fetch(resourceUrl, {\n      method: 'GET',\n      headers: { Accept: 'application/json', Connection: 'close' },\n    });\n\n    const header = response.headers.get('www-authenticate');\n    if (!header) return null;\n\n    const match = header.match(/(?:authorization_server|issuer)=\"([^\"]+)\"/i);\n    if (!match) return null;\n\n    return match[1] ?? null;\n  } catch (_error) {\n    return null;\n  }\n}\n"],"names":["joinWellKnown","normalizeUrl","discoveryFetch","isLoopbackUrl","readDiscoveryJson","getOrigin","url","URL","origin","getPath","parsed","pathname","discoverProtectedResourceMetadata","resourceUrl","normalizedResourceUrl","allowLoopback","headerMetadata","discoverProtectedResourceMetadataFromHeader","localWellKnownUrl","response","method","headers","Accept","Connection","ok","path","rootUrl","metadata","resource","startsWith","rootMetadata","subPathUrl","subPathResponse","_error","fetch","header","get","postResponse","body","match","metadataUrl","metadataResponse","discoverAuthorizationServerMetadata","authServerUrl","options","normalizedAuthServerUrl","localResponse","wellKnownUrl","discoverAuthorizationServerIssuer"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/mcp-z/client/src/auth/rfc9728-discovery.ts"],"sourcesContent":["/**\n * RFC 9728 Protected Resource Metadata Discovery\n * Probes .well-known/oauth-protected-resource endpoint\n */\n\nimport { joinWellKnown, normalizeUrl } from '../lib/url-utils.ts';\nimport { discoveryFetch, isLoopbackUrl, readDiscoveryJson, throwIfAborted } from './discovery-fetch.ts';\nimport type { AuthorizationServerMetadata, ProtectedResourceMetadata } from './types.ts';\n\n/** Returns `url`'s origin (protocol + host), or the original string if it doesn't parse. */\nfunction getOrigin(url: string): string {\n  try {\n    return new URL(url).origin;\n  } catch {\n    return url;\n  }\n}\n\n/** Returns `url`'s pathname, or `''` for the root path or an unparseable URL. */\nfunction getPath(url: string): string {\n  try {\n    const parsed = new URL(url);\n    return parsed.pathname === '/' ? '' : parsed.pathname;\n  } catch {\n    return '';\n  }\n}\n\n/**\n * Discovers RFC 9728 Protected Resource Metadata: the `WWW-Authenticate`\n * header first, then `.well-known/oauth-protected-resource` at the origin root and, for a path-prefixed resource, its sub-path variant.\n *\n * @param resourceUrl - URL of the protected resource (e.g. `https://ai.todoist.net/mcp`).\n * @returns Discovered metadata, or `null` if none is found.\n */\nexport async function discoverProtectedResourceMetadata(resourceUrl: string, options: { signal?: AbortSignal } = {}): Promise<ProtectedResourceMetadata | null> {\n  const { signal } = options;\n  try {\n    throwIfAborted(signal);\n    const normalizedResourceUrl = normalizeUrl(resourceUrl);\n    // resourceUrl is the server the caller configured (never remote-supplied);\n    // its loopback-ness is the trust signal every fetch below relies on.\n    const allowLoopback = isLoopbackUrl(normalizedResourceUrl);\n    const headerMetadata = await discoverProtectedResourceMetadataFromHeader(normalizedResourceUrl, allowLoopback, signal);\n    if (headerMetadata) return headerMetadata;\n\n    // Strategy 0: Try path-local well-known (supports path-prefixed deployments like /outlook)\n    const localWellKnownUrl = joinWellKnown(normalizedResourceUrl, '/.well-known/oauth-protected-resource');\n    try {\n      const response = await discoveryFetch(\n        localWellKnownUrl,\n        {\n          method: 'GET',\n          headers: { Accept: 'application/json', Connection: 'close' },\n          signal,\n        },\n        'protected resource metadata (path-local)',\n        { allowLoopback }\n      );\n      if (response.ok) {\n        return await readDiscoveryJson<ProtectedResourceMetadata>(response, 'protected resource metadata (path-local)');\n      }\n    } catch {\n      throwIfAborted(signal);\n      // Continue to origin-based discovery\n    }\n\n    const origin = getOrigin(normalizedResourceUrl);\n    const path = getPath(normalizedResourceUrl);\n\n    // Strategy 1: Try root location (REQUIRED by RFC 9728)\n    const rootUrl = `${origin}/.well-known/oauth-protected-resource`;\n\n    try {\n      const response = await discoveryFetch(\n        rootUrl,\n        {\n          method: 'GET',\n          headers: { Accept: 'application/json', Connection: 'close' },\n          signal,\n        },\n        'protected resource metadata (root)',\n        { allowLoopback }\n      );\n\n      if (response.ok) {\n        const metadata = await readDiscoveryJson<ProtectedResourceMetadata>(response, 'protected resource metadata (root)');\n        // Check if the discovered resource matches what we're looking for\n        if (metadata.resource === normalizedResourceUrl) {\n          return metadata;\n        }\n        // If there's no path component, return root metadata\n        // (e.g., looking for http://example.com and found it)\n        if (!path) {\n          return metadata;\n        }\n        // If requested URL starts with metadata.resource, the root metadata applies to sub-paths\n        // (e.g., looking for http://example.com/api/v1/mcp, found http://example.com)\n        if (normalizedResourceUrl.startsWith(metadata.resource)) {\n          // Still try sub-path location to see if there's more specific metadata\n          // But save root metadata as fallback\n          const rootMetadata = metadata;\n\n          // Try sub-path location for more specific metadata\n          const subPathUrl = `${origin}/.well-known/oauth-protected-resource${path}`;\n          try {\n            const subPathResponse = await discoveryFetch(\n              subPathUrl,\n              {\n                method: 'GET',\n                headers: { Accept: 'application/json', Connection: 'close' },\n                signal,\n              },\n              'protected resource metadata (sub-path)',\n              { allowLoopback }\n            );\n            if (subPathResponse.ok) {\n              return await readDiscoveryJson<ProtectedResourceMetadata>(subPathResponse, 'protected resource metadata (sub-path)');\n            }\n          } catch {\n            throwIfAborted(signal);\n            // Sub-path failed, use root metadata\n          }\n\n          // Return root metadata as it applies to this resource\n          return rootMetadata;\n        }\n        // Otherwise, try sub-path location before giving up\n      }\n    } catch {\n      throwIfAborted(signal);\n      // Continue to sub-path location\n    }\n\n    // Strategy 2: Try sub-path location (MCP spec extension)\n    // Only try if there's a path component\n    if (path) {\n      const subPathUrl = `${origin}/.well-known/oauth-protected-resource${path}`;\n\n      try {\n        const response = await discoveryFetch(\n          subPathUrl,\n          {\n            method: 'GET',\n            headers: { Accept: 'application/json', Connection: 'close' },\n            signal,\n          },\n          'protected resource metadata (sub-path)',\n          { allowLoopback }\n        );\n\n        if (response.ok) {\n          return await readDiscoveryJson<ProtectedResourceMetadata>(response, 'protected resource metadata (sub-path)');\n        }\n      } catch {\n        throwIfAborted(signal);\n        // Fall through to return null\n      }\n    }\n\n    // Neither location found or resource didn't match\n    return null;\n  } catch (_error) {\n    throwIfAborted(signal);\n    // Network error, invalid URL, or other failure\n    return null;\n  }\n}\n\nasync function discoverProtectedResourceMetadataFromHeader(resourceUrl: string, allowLoopback: boolean, signal?: AbortSignal): Promise<ProtectedResourceMetadata | null> {\n  try {\n    throwIfAborted(signal);\n    const response = await fetch(resourceUrl, {\n      method: 'GET',\n      headers: { Accept: 'application/json', Connection: 'close' },\n      signal,\n    });\n\n    let header = response.headers.get('www-authenticate');\n    if (!header) {\n      const postResponse = await fetch(resourceUrl, {\n        method: 'POST',\n        headers: { Accept: 'application/json', Connection: 'close', 'Content-Type': 'application/json' },\n        body: '{}',\n        signal,\n      });\n      header = postResponse.headers.get('www-authenticate');\n    }\n\n    if (!header) return null;\n\n    const match = header.match(/resource_metadata=\"([^\"]+)\"/i);\n    if (!match || !match[1]) return null;\n\n    // metadataUrl is remote-server-chosen (the primary SSRF vector here);\n    // allowLoopback reflects trust in resourceUrl, not in metadataUrl.\n    const metadataUrl = match[1];\n    const metadataResponse = await discoveryFetch(\n      metadataUrl,\n      {\n        method: 'GET',\n        headers: { Accept: 'application/json', Connection: 'close' },\n        signal,\n      },\n      'resource_metadata URL',\n      { allowLoopback }\n    );\n\n    if (!metadataResponse.ok) {\n      return null;\n    }\n\n    return await readDiscoveryJson<ProtectedResourceMetadata>(metadataResponse, 'resource_metadata URL');\n  } catch (_error) {\n    throwIfAborted(signal);\n    return null;\n  }\n}\n\n/**\n * Discovers RFC 8414 Authorization Server Metadata at\n * `.well-known/oauth-authorization-server`, path-local variant first.\n *\n * @param authServerUrl - URL of the authorization server (typically from RFC 9728 discovery).\n * @param options.allowLoopback - Loopback trust grant computed from the server the caller is actually talking to, never from `authServerUrl` itself. Defaults to `false`.\n * @returns Discovered metadata, or `null` if none is found.\n */\nexport async function discoverAuthorizationServerMetadata(authServerUrl: string, options: { allowLoopback?: boolean; signal?: AbortSignal } = {}): Promise<AuthorizationServerMetadata | null> {\n  const { allowLoopback = false, signal } = options;\n  try {\n    throwIfAborted(signal);\n    const normalizedAuthServerUrl = normalizeUrl(authServerUrl);\n    const localWellKnownUrl = joinWellKnown(normalizedAuthServerUrl, '/.well-known/oauth-authorization-server');\n    const localResponse = await discoveryFetch(\n      localWellKnownUrl,\n      {\n        method: 'GET',\n        headers: { Accept: 'application/json', Connection: 'close' },\n        signal,\n      },\n      'authorization server metadata (path-local)',\n      { allowLoopback }\n    );\n\n    if (localResponse.ok) {\n      return await readDiscoveryJson<AuthorizationServerMetadata>(localResponse, 'authorization server metadata (path-local)');\n    }\n\n    const origin = getOrigin(normalizedAuthServerUrl);\n    const wellKnownUrl = `${origin}/.well-known/oauth-authorization-server`;\n\n    const response = await discoveryFetch(\n      wellKnownUrl,\n      {\n        method: 'GET',\n        headers: { Accept: 'application/json', Connection: 'close' },\n        signal,\n      },\n      'authorization server metadata',\n      { allowLoopback }\n    );\n\n    if (!response.ok) {\n      return null;\n    }\n\n    return await readDiscoveryJson<AuthorizationServerMetadata>(response, 'authorization server metadata');\n  } catch (_error) {\n    throwIfAborted(signal);\n    return null;\n  }\n}\n\n/**\n * Discover OAuth Authorization Server Issuer from resource response (RFC 9207)\n *\n * @param resourceUrl - URL of the protected resource\n * @returns Issuer URL if present in WWW-Authenticate header, null otherwise\n */\nexport async function discoverAuthorizationServerIssuer(resourceUrl: string, options: { signal?: AbortSignal } = {}): Promise<string | null> {\n  const { signal } = options;\n  try {\n    throwIfAborted(signal);\n    const response = await fetch(resourceUrl, {\n      method: 'GET',\n      headers: { Accept: 'application/json', Connection: 'close' },\n      signal,\n    });\n\n    const header = response.headers.get('www-authenticate');\n    if (!header) return null;\n\n    const match = header.match(/(?:authorization_server|issuer)=\"([^\"]+)\"/i);\n    if (!match) return null;\n\n    return match[1] ?? null;\n  } catch (_error) {\n    throwIfAborted(signal);\n    return null;\n  }\n}\n"],"names":["joinWellKnown","normalizeUrl","discoveryFetch","isLoopbackUrl","readDiscoveryJson","throwIfAborted","getOrigin","url","URL","origin","getPath","parsed","pathname","discoverProtectedResourceMetadata","resourceUrl","options","signal","normalizedResourceUrl","allowLoopback","headerMetadata","discoverProtectedResourceMetadataFromHeader","localWellKnownUrl","response","method","headers","Accept","Connection","ok","path","rootUrl","metadata","resource","startsWith","rootMetadata","subPathUrl","subPathResponse","_error","fetch","header","get","postResponse","body","match","metadataUrl","metadataResponse","discoverAuthorizationServerMetadata","authServerUrl","normalizedAuthServerUrl","localResponse","wellKnownUrl","discoverAuthorizationServerIssuer"],"mappings":"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"}

package/dist/esm/auth/types.d.ts

@@ -142,11 +142,15 @@ export interface DcrRegistrationOptions {
      * remote-controlled AS metadata). Defaults to `false`.
      */
     allowLoopback?: boolean;
+    /** Cancels an in-progress registration request. */
+    signal?: AbortSignal;
 }
 /**
  * Options for OAuth authorization flow
  */
 export interface OAuthFlowOptions {
+    /** Cancels an in-progress authorization and closes its callback listener. */
+    signal?: AbortSignal;
     /** Port for OAuth callback listener (required - use get-port to find available port) */
     port: number;
     /** Issuer identifier discovered before the flow starts; the `iss` in the authorization response must match it (RFC 9207) */

package/dist/esm/auth/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/mcp-z/client/src/auth/types.ts"],"sourcesContent":["/**\n * Shared types for OAuth and DCR authentication\n */\n\n/**\n * OAuth callback result from authorization server\n */\nexport interface CallbackResult {\n  /** Authorization code from OAuth server */\n  code: string;\n  /** State parameter for CSRF protection */\n  state?: string;\n  /** Issuer identifier of the authorization server that minted the response (RFC 9207) */\n  iss?: string;\n}\n\n/**\n * PKCE (Proof Key for Code Exchange) parameters (RFC 7636)\n * Used to secure OAuth 2.0 authorization code flow for public clients\n */\nexport interface PkceParams {\n  /** Code verifier - cryptographically random string (43-128 characters) */\n  codeVerifier: string;\n  /** Code challenge - derived from code verifier using challenge method */\n  codeChallenge: string;\n  /** Code challenge method - S256 (SHA-256) or plain */\n  codeChallengeMethod: 'S256' | 'plain';\n}\n\n/**\n * OAuth token set with access and refresh tokens\n */\nexport interface TokenSet {\n  /** Access token for API requests */\n  accessToken: string;\n  /** Refresh token for obtaining new access tokens */\n  refreshToken: string;\n  /** Timestamp when access token expires (milliseconds since epoch) */\n  expiresAt: number;\n  /** Scopes granted for this token set */\n  scopes?: string[];\n  /** Client ID used for DCR registration (stored for future use) */\n  clientId?: string;\n  /** Client secret used for DCR registration (stored for future use) */\n  clientSecret?: string;\n  /** Issuer identifier of the authorization server these credentials belong to (SEP-2352) */\n  issuer?: string;\n}\n\n/**\n * OAuth 2.0 Protected Resource Metadata (RFC 9728)\n * Response from .well-known/oauth-protected-resource endpoint\n */\nexport interface ProtectedResourceMetadata {\n  /** The protected resource identifier */\n  resource: string;\n  /** List of authorization server URLs that can issue tokens for this resource */\n  authorization_servers: string[];\n  /** Optional list of scopes supported by this resource */\n  scopes_supported?: string[];\n  /** Optional list of bearer token methods supported (header, query, body) */\n  bearer_methods_supported?: string[];\n}\n\n/**\n * OAuth 2.0 Authorization Server Metadata (RFC 8414)\n * Response from .well-known/oauth-authorization-server endpoint\n */\nexport interface AuthorizationServerMetadata {\n  /** The authorization server's issuer identifier */\n  issuer?: string;\n  /** URL of the authorization endpoint */\n  authorization_endpoint?: string;\n  /** URL of the token endpoint */\n  token_endpoint?: string;\n  /** URL of the client registration endpoint (DCR - RFC 7591) */\n  registration_endpoint?: string;\n  /** URL of the token introspection endpoint */\n  introspection_endpoint?: string;\n  /** List of OAuth scopes supported by the authorization server */\n  scopes_supported?: string[];\n  /** Response types supported (code, token, etc.) */\n  response_types_supported?: string[];\n  /** Grant types supported (authorization_code, refresh_token, etc.) */\n  grant_types_supported?: string[];\n  /** Token endpoint authentication methods supported */\n  token_endpoint_auth_methods_supported?: string[];\n  /** Whether the authorization response carries an `iss` parameter (RFC 9207) */\n  authorization_response_iss_parameter_supported?: boolean;\n}\n\n/**\n * OAuth server capabilities discovered from .well-known endpoint\n */\nexport interface AuthCapabilities {\n  /** Whether the server supports Dynamic Client Registration (RFC 7591) */\n  supportsDcr: boolean;\n  /** Issuer identifier from the authorization server metadata (RFC 8414) */\n  issuer?: string;\n  /**\n   * The protected resource's canonical identifier, from the RFC 9728 metadata\n   * document's `resource` field. This is what an RFC 8707 `resource` indicator\n   * must carry, and it is the resource server's own statement of its identity -\n   * not the URL we happened to dial, and never the base URL discovery was\n   * performed against, which has any `/mcp` segment stripped off it.\n   *\n   * Absent when no protected-resource metadata was published and the\n   * authorization server was reached by direct RFC 8414 discovery instead.\n   */\n  resource?: string;\n  /** Whether the authorization response carries an `iss` parameter (RFC 9207) */\n  authorizationResponseIssSupported?: boolean;\n  /** DCR client registration endpoint */\n  registrationEndpoint?: string;\n  /** OAuth authorization endpoint */\n  authorizationEndpoint?: string;\n  /** OAuth token endpoint */\n  tokenEndpoint?: string;\n  /** Token introspection endpoint */\n  introspectionEndpoint?: string;\n  /** Supported OAuth scopes */\n  scopes?: string[];\n}\n\n/**\n * Client credentials from DCR registration\n */\nexport interface ClientCredentials {\n  /** OAuth client ID */\n  clientId: string;\n  /** OAuth client secret */\n  clientSecret: string;\n  /** Timestamp when client was registered */\n  issuedAt?: number;\n}\n\n/**\n * Options for DCR client registration\n */\nexport interface DcrRegistrationOptions {\n  /** Redirect URI for OAuth callback, from the loopback listener the caller has already bound (RFC 8252) */\n  redirectUri: string;\n  /** Client name to register */\n  clientName?: string;\n  /**\n   * Loopback trust grant for the registration_endpoint fetch (SSRF\n   * mitigation - see `src/auth/discovery-fetch.ts`). Compute this from the\n   * MCP server the caller is actually talking to, never from\n   * `registrationEndpoint` itself (which is typically sourced from\n   * remote-controlled AS metadata). Defaults to `false`.\n   */\n  allowLoopback?: boolean;\n}\n\n/**\n * Options for OAuth authorization flow\n */\nexport interface OAuthFlowOptions {\n  /** Port for OAuth callback listener (required - use get-port to find available port) */\n  port: number;\n  /** Issuer identifier discovered before the flow starts; the `iss` in the authorization response must match it (RFC 9207) */\n  issuer: string;\n  /** Canonical resource server URI, sent as `resource` on the authorization, token, and refresh requests (RFC 8707) */\n  resource: string;\n  /** Redirect URI for OAuth callback (optional - will be built from port if not provided) */\n  redirectUri?: string;\n  /** OAuth scopes to request */\n  scopes?: string[];\n  /** Whether the authorization server advertises `authorization_response_iss_parameter_supported` (RFC 9207) */\n  authorizationResponseIssSupported?: boolean;\n  /** Enable PKCE (RFC 7636) - recommended for all clients, required for public clients */\n  pkce?: boolean;\n  /** Headless mode (don't open browser) */\n  headless?: boolean;\n  /** Timeout for callback (milliseconds) */\n  timeout?: number;\n  /** Optional logger for debug output (defaults to singleton logger) */\n  logger?: import('../utils/logger.ts').Logger;\n  /**\n   * Loopback trust grant for the token endpoint fetch (SSRF mitigation - see\n   * `src/auth/discovery-fetch.ts`). Compute this from the MCP server the\n   * caller is actually talking to, never from `tokenEndpoint` itself (which\n   * is typically sourced from remote-controlled AS metadata). Defaults to\n   * `false`.\n   */\n  allowLoopback?: boolean;\n}\n"],"names":[],"mappings":"AAAA;;CAEC,GAED;;CAEC,GAoJD;;CAEC,GACD,WA6BC"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/mcp-z/client/src/auth/types.ts"],"sourcesContent":["/**\n * Shared types for OAuth and DCR authentication\n */\n\n/**\n * OAuth callback result from authorization server\n */\nexport interface CallbackResult {\n  /** Authorization code from OAuth server */\n  code: string;\n  /** State parameter for CSRF protection */\n  state?: string;\n  /** Issuer identifier of the authorization server that minted the response (RFC 9207) */\n  iss?: string;\n}\n\n/**\n * PKCE (Proof Key for Code Exchange) parameters (RFC 7636)\n * Used to secure OAuth 2.0 authorization code flow for public clients\n */\nexport interface PkceParams {\n  /** Code verifier - cryptographically random string (43-128 characters) */\n  codeVerifier: string;\n  /** Code challenge - derived from code verifier using challenge method */\n  codeChallenge: string;\n  /** Code challenge method - S256 (SHA-256) or plain */\n  codeChallengeMethod: 'S256' | 'plain';\n}\n\n/**\n * OAuth token set with access and refresh tokens\n */\nexport interface TokenSet {\n  /** Access token for API requests */\n  accessToken: string;\n  /** Refresh token for obtaining new access tokens */\n  refreshToken: string;\n  /** Timestamp when access token expires (milliseconds since epoch) */\n  expiresAt: number;\n  /** Scopes granted for this token set */\n  scopes?: string[];\n  /** Client ID used for DCR registration (stored for future use) */\n  clientId?: string;\n  /** Client secret used for DCR registration (stored for future use) */\n  clientSecret?: string;\n  /** Issuer identifier of the authorization server these credentials belong to (SEP-2352) */\n  issuer?: string;\n}\n\n/**\n * OAuth 2.0 Protected Resource Metadata (RFC 9728)\n * Response from .well-known/oauth-protected-resource endpoint\n */\nexport interface ProtectedResourceMetadata {\n  /** The protected resource identifier */\n  resource: string;\n  /** List of authorization server URLs that can issue tokens for this resource */\n  authorization_servers: string[];\n  /** Optional list of scopes supported by this resource */\n  scopes_supported?: string[];\n  /** Optional list of bearer token methods supported (header, query, body) */\n  bearer_methods_supported?: string[];\n}\n\n/**\n * OAuth 2.0 Authorization Server Metadata (RFC 8414)\n * Response from .well-known/oauth-authorization-server endpoint\n */\nexport interface AuthorizationServerMetadata {\n  /** The authorization server's issuer identifier */\n  issuer?: string;\n  /** URL of the authorization endpoint */\n  authorization_endpoint?: string;\n  /** URL of the token endpoint */\n  token_endpoint?: string;\n  /** URL of the client registration endpoint (DCR - RFC 7591) */\n  registration_endpoint?: string;\n  /** URL of the token introspection endpoint */\n  introspection_endpoint?: string;\n  /** List of OAuth scopes supported by the authorization server */\n  scopes_supported?: string[];\n  /** Response types supported (code, token, etc.) */\n  response_types_supported?: string[];\n  /** Grant types supported (authorization_code, refresh_token, etc.) */\n  grant_types_supported?: string[];\n  /** Token endpoint authentication methods supported */\n  token_endpoint_auth_methods_supported?: string[];\n  /** Whether the authorization response carries an `iss` parameter (RFC 9207) */\n  authorization_response_iss_parameter_supported?: boolean;\n}\n\n/**\n * OAuth server capabilities discovered from .well-known endpoint\n */\nexport interface AuthCapabilities {\n  /** Whether the server supports Dynamic Client Registration (RFC 7591) */\n  supportsDcr: boolean;\n  /** Issuer identifier from the authorization server metadata (RFC 8414) */\n  issuer?: string;\n  /**\n   * The protected resource's canonical identifier, from the RFC 9728 metadata\n   * document's `resource` field. This is what an RFC 8707 `resource` indicator\n   * must carry, and it is the resource server's own statement of its identity -\n   * not the URL we happened to dial, and never the base URL discovery was\n   * performed against, which has any `/mcp` segment stripped off it.\n   *\n   * Absent when no protected-resource metadata was published and the\n   * authorization server was reached by direct RFC 8414 discovery instead.\n   */\n  resource?: string;\n  /** Whether the authorization response carries an `iss` parameter (RFC 9207) */\n  authorizationResponseIssSupported?: boolean;\n  /** DCR client registration endpoint */\n  registrationEndpoint?: string;\n  /** OAuth authorization endpoint */\n  authorizationEndpoint?: string;\n  /** OAuth token endpoint */\n  tokenEndpoint?: string;\n  /** Token introspection endpoint */\n  introspectionEndpoint?: string;\n  /** Supported OAuth scopes */\n  scopes?: string[];\n}\n\n/**\n * Client credentials from DCR registration\n */\nexport interface ClientCredentials {\n  /** OAuth client ID */\n  clientId: string;\n  /** OAuth client secret */\n  clientSecret: string;\n  /** Timestamp when client was registered */\n  issuedAt?: number;\n}\n\n/**\n * Options for DCR client registration\n */\nexport interface DcrRegistrationOptions {\n  /** Redirect URI for OAuth callback, from the loopback listener the caller has already bound (RFC 8252) */\n  redirectUri: string;\n  /** Client name to register */\n  clientName?: string;\n  /**\n   * Loopback trust grant for the registration_endpoint fetch (SSRF\n   * mitigation - see `src/auth/discovery-fetch.ts`). Compute this from the\n   * MCP server the caller is actually talking to, never from\n   * `registrationEndpoint` itself (which is typically sourced from\n   * remote-controlled AS metadata). Defaults to `false`.\n   */\n  allowLoopback?: boolean;\n  /** Cancels an in-progress registration request. */\n  signal?: AbortSignal;\n}\n\n/**\n * Options for OAuth authorization flow\n */\nexport interface OAuthFlowOptions {\n  /** Cancels an in-progress authorization and closes its callback listener. */\n  signal?: AbortSignal;\n  /** Port for OAuth callback listener (required - use get-port to find available port) */\n  port: number;\n  /** Issuer identifier discovered before the flow starts; the `iss` in the authorization response must match it (RFC 9207) */\n  issuer: string;\n  /** Canonical resource server URI, sent as `resource` on the authorization, token, and refresh requests (RFC 8707) */\n  resource: string;\n  /** Redirect URI for OAuth callback (optional - will be built from port if not provided) */\n  redirectUri?: string;\n  /** OAuth scopes to request */\n  scopes?: string[];\n  /** Whether the authorization server advertises `authorization_response_iss_parameter_supported` (RFC 9207) */\n  authorizationResponseIssSupported?: boolean;\n  /** Enable PKCE (RFC 7636) - recommended for all clients, required for public clients */\n  pkce?: boolean;\n  /** Headless mode (don't open browser) */\n  headless?: boolean;\n  /** Timeout for callback (milliseconds) */\n  timeout?: number;\n  /** Optional logger for debug output (defaults to singleton logger) */\n  logger?: import('../utils/logger.ts').Logger;\n  /**\n   * Loopback trust grant for the token endpoint fetch (SSRF mitigation - see\n   * `src/auth/discovery-fetch.ts`). Compute this from the MCP server the\n   * caller is actually talking to, never from `tokenEndpoint` itself (which\n   * is typically sourced from remote-controlled AS metadata). Defaults to\n   * `false`.\n   */\n  allowLoopback?: boolean;\n}\n"],"names":[],"mappings":"AAAA;;CAEC,GAED;;CAEC,GAsJD;;CAEC,GACD,WA+BC"}

package/dist/esm/connection/connect-client.d.ts

@@ -4,7 +4,7 @@
  * Helper to connect MCP SDK clients to servers with intelligent transport inference.
  * Automatically detects transport type from URL protocol or type field.
  */
-import type { VersionNegotiationOptions } from '@modelcontextprotocol/client';
+import type { Transport, VersionNegotiationOptions } from '@modelcontextprotocol/client';
 import { Client } from '@modelcontextprotocol/client';
 import { type DcrAuthenticatorOptions } from '../dcr/index.js';
 import type { ServerProcess } from '../spawn/spawn-server.js';
@@ -18,6 +18,12 @@ interface RegistryLike {
     servers: Map<string, ServerProcess>;
 }
 import { type Logger } from '../utils/logger.js';
+/** @internal - Bounds work by aborting the actual request signal at the deadline. */
+export declare function withAbortTimeout<T>(operationFn: (signal: AbortSignal) => Promise<T>, ms: number, operation: string, parentSignal?: AbortSignal): Promise<T>;
+/** @internal - Connects a transport with a deadline that aborts and cleans up the actual connection. */
+export declare function connectTransportWithTimeout(client: Client, transport: Transport, ms: number, operation: string, parentSignal?: AbortSignal): Promise<void>;
+/** @internal - Connects one client/transport pair and reports any failed cleanup. */
+export declare function connectTransport(client: Client, transport: Transport, signal?: AbortSignal): Promise<void>;
 /**
  * Connect MCP SDK client to server with full readiness handling.
  * @internal - Use registry.connect() instead
@@ -65,5 +71,7 @@ export declare function connectMcpClient(registryOrConfig: RegistryLike | Server
     dcrAuthenticator?: Partial<DcrAuthenticatorOptions>;
     logger?: Logger;
     versionNegotiation?: VersionNegotiationOptions;
+    /** Cancels readiness, authentication, and transport connection work. */
+    signal?: AbortSignal;
 }): Promise<Client>;
 export {};

package/dist/esm/connection/connect-client.js

@@ -13,21 +13,84 @@ import { normalizeUrl } from '../lib/url-utils.js';
 import { logger as defaultLogger } from '../utils/logger.js';
 import { ExistingProcessTransport } from './existing-process-transport.js';
 import { waitForHttpReady } from './wait-for-http-ready.js';
-/**
- * Wrap promise with timeout - throws if promise takes too long
- * Clears timeout when promise completes to prevent hanging event loop
- * @param promise - Promise to wrap
- * @param ms - Timeout in milliseconds
- * @param operation - Description of operation for error message
- * @returns Promise result or timeout error
- */ async function withTimeout(promise, ms, operation) {
+const HTTP_CONNECTION_TIMEOUT_MS = 30000;
+const CLIENT_CLEANUP_TIMEOUT_MS = 5000;
+/** @internal - Bounds work by aborting the actual request signal at the deadline. */ export async function withAbortTimeout(operationFn, ms, operation, parentSignal) {
+    const controller = new AbortController();
+    const timeoutError = new Error(`Timeout after ${ms}ms: ${operation}`);
+    const abortFromParent = ()=>controller.abort((parentSignal === null || parentSignal === void 0 ? void 0 : parentSignal.reason) instanceof Error ? parentSignal.reason : new Error('Connection was cancelled'));
+    parentSignal === null || parentSignal === void 0 ? void 0 : parentSignal.addEventListener('abort', abortFromParent, {
+        once: true
+    });
+    if (parentSignal === null || parentSignal === void 0 ? void 0 : parentSignal.aborted) abortFromParent();
+    const timeoutId = setTimeout(()=>controller.abort(timeoutError), ms);
+    try {
+        // Preserve the operation's error unchanged: connection cleanup may have
+        // attached failures to the original cancellation or timeout.
+        return await operationFn(controller.signal);
+    } finally{
+        clearTimeout(timeoutId);
+        parentSignal === null || parentSignal === void 0 ? void 0 : parentSignal.removeEventListener('abort', abortFromParent);
+    }
+}
+/** @internal - Connects a transport with a deadline that aborts and cleans up the actual connection. */ export async function connectTransportWithTimeout(client, transport, ms, operation, parentSignal) {
+    return withAbortTimeout((signal)=>connectTransport(client, transport, signal), ms, operation, parentSignal);
+}
+function throwIfAborted(signal) {
+    if (signal === null || signal === void 0 ? void 0 : signal.aborted) throw signal.reason instanceof Error ? signal.reason : new Error('Connection was cancelled');
+}
+async function closeClientWithinTimeout(client) {
     let timeoutId;
-    return Promise.race([
-        promise.finally(()=>clearTimeout(timeoutId)),
-        new Promise((_, reject)=>{
-            timeoutId = setTimeout(()=>reject(new Error(`Timeout after ${ms}ms: ${operation}`)), ms);
-        })
-    ]);
+    try {
+        await Promise.race([
+            client.close(),
+            new Promise((_, reject)=>{
+                timeoutId = setTimeout(()=>reject(new Error(`Client cleanup did not complete within ${CLIENT_CLEANUP_TIMEOUT_MS}ms`)), CLIENT_CLEANUP_TIMEOUT_MS);
+            })
+        ]);
+    } finally{
+        if (timeoutId) clearTimeout(timeoutId);
+    }
+}
+async function rethrowAfterClientCleanup(error, clients, message) {
+    const cleanup = await Promise.allSettled(clients.map((client)=>closeClientWithinTimeout(client)));
+    const cleanupErrors = cleanup.flatMap((result)=>result.status === 'rejected' ? [
+            result.reason
+        ] : []);
+    if (cleanupErrors.length > 0) throw new AggregateError([
+        error,
+        ...cleanupErrors
+    ], message, {
+        cause: error
+    });
+    throw error;
+}
+/** @internal - Connects one client/transport pair and reports any failed cleanup. */ export async function connectTransport(client, transport, signal) {
+    let abortHandler;
+    try {
+        throwIfAborted(signal);
+        const connecting = client.connect(transport);
+        if (signal) {
+            const aborted = new Promise((_, reject)=>{
+                abortHandler = ()=>reject(signal.reason instanceof Error ? signal.reason : new Error('Connection was cancelled'));
+                signal.addEventListener('abort', abortHandler, {
+                    once: true
+                });
+            });
+            await Promise.race([
+                connecting,
+                aborted
+            ]);
+        } else {
+            await connecting;
+        }
+    } catch (error) {
+        await rethrowAfterClientCleanup(error, [
+            client
+        ], 'MCP connection failed and client cleanup also failed');
+    } finally{
+        if (signal && abortHandler) signal.removeEventListener('abort', abortHandler);
+    }
 }
 /**
  * Infer transport type from server configuration with validation.
@@ -117,6 +180,7 @@ import { waitForHttpReady } from './wait-for-http-ready.js';
     const serversConfig = isRegistry ? registryOrConfig.config : registryOrConfig;
     const registry = isRegistry ? registryOrConfig : undefined;
     const logger = (_ref = options === null || options === void 0 ? void 0 : options.logger) !== null && _ref !== void 0 ? _ref : defaultLogger;
+    throwIfAborted(options === null || options === void 0 ? void 0 : options.signal);
     const serverConfig = serversConfig[serverName];
     if (!serverConfig) {
         const available = Object.keys(serversConfig).join(', ');
@@ -145,7 +209,7 @@ import { waitForHttpReady } from './wait-for-http-ready.js';
         if (serverHandle) {
             // Reuse the already-spawned process
             const transport = new ExistingProcessTransport(serverHandle.process);
-            await client.connect(transport);
+            await connectTransport(client, transport, options === null || options === void 0 ? void 0 : options.signal);
         } else {
             // No registry or server not in registry - spawn new process directly
             // This is the standard fallback when process management is not used
@@ -158,7 +222,7 @@ import { waitForHttpReady } from './wait-for-http-ready.js';
                 env: serverConfig.env || {}
             });
             // client.connect() performs initialize handshake - when it resolves, server is ready
-            await client.connect(transport);
+            await connectTransport(client, transport, options === null || options === void 0 ? void 0 : options.signal);
         }
     } else if (transportType === 'http') {
         if (!('url' in serverConfig) || !serverConfig.url) {
@@ -169,7 +233,7 @@ import { waitForHttpReady } from './wait-for-http-ready.js';
         const isSpawnedHttp = registry === null || registry === void 0 ? void 0 : registry.servers.has(serverName);
         if (isSpawnedHttp) {
             logger.debug(`[connectMcpClient] waiting for HTTP server '${serverName}' at ${serverConfig.url}`);
-            await waitForHttpReady(serverConfig.url);
+            await waitForHttpReady(serverConfig.url, 30000, options === null || options === void 0 ? void 0 : options.signal);
             logger.debug(`[connectMcpClient] HTTP server '${serverName}' ready`);
         }
         const url = new URL(serverConfig.url);
@@ -181,7 +245,9 @@ import { waitForHttpReady } from './wait-for-http-ready.js';
         // base names a different resource, which authorization servers that validate
         // the `resource` indicator reject as `invalid_target`.
         const mcpServerUrl = normalizeUrl(serverConfig.url);
-        const capabilities = await withTimeout(probeAuthCapabilities(mcpServerUrl), DCR_CAPABILTY_DISCOVERY_TIMEOUT, 'DCR capability discovery');
+        const capabilities = await withAbortTimeout((signal)=>probeAuthCapabilities(mcpServerUrl, {
+                signal
+            }), DCR_CAPABILTY_DISCOVERY_TIMEOUT, 'DCR capability discovery', options === null || options === void 0 ? void 0 : options.signal);
         let authToken;
         if (capabilities.supportsDcr) {
             logger.debug(`🔐 Server '${serverName}' supports DCR authentication`);
@@ -196,7 +262,7 @@ import { waitForHttpReady } from './wait-for-http-ready.js';
                 ...options === null || options === void 0 ? void 0 : options.dcrAuthenticator
             });
             // Ensure we have valid tokens (performs DCR + OAuth if needed)
-            const tokens = await authenticator.ensureAuthenticated(mcpServerUrl, capabilities);
+            const tokens = await authenticator.ensureAuthenticated(mcpServerUrl, capabilities, options === null || options === void 0 ? void 0 : options.signal);
             authToken = tokens.accessToken;
             logger.debug(`✅ Authentication complete for '${serverName}'`);
         } else {
@@ -221,8 +287,12 @@ import { waitForHttpReady } from './wait-for-http-ready.js';
             const transport = new StreamableHTTPClientTransport(url, transportOptions);
             // Type assertion: SDK transport has sessionId: string | undefined but Transport expects string
             // This is safe at runtime - the undefined is valid per MCP spec
-            await withTimeout(client.connect(transport), 30000, 'StreamableHTTP connection');
+            await connectTransportWithTimeout(client, transport, HTTP_CONNECTION_TIMEOUT_MS, 'StreamableHTTP connection', options === null || options === void 0 ? void 0 : options.signal);
         } catch (error) {
+            var _options_signal;
+            // Cancellation and cleanup failures must reach the caller; neither can
+            // safely be converted into an SSE fallback attempt.
+            if ((options === null || options === void 0 ? void 0 : (_options_signal = options.signal) === null || _options_signal === void 0 ? void 0 : _options_signal.aborted) || error instanceof AggregateError) throw error;
             // Fall back to SSE transport (MCP protocol version 2024-11-05)
             // SSE is a standard MCP transport used by many servers (e.g., FastMCP ecosystem)
             const errorMessage = error instanceof Error ? error.message : String(error);
@@ -231,9 +301,10 @@ import { waitForHttpReady } from './wait-for-http-ready.js';
             const cause = error instanceof Error ? error.cause : undefined;
             const isConnectionRefused = (cause === null || cause === void 0 ? void 0 : cause.code) === 'ECONNREFUSED' || errorMessage.includes('Connection refused');
             if (isConnectionRefused) {
-                // Clean up client resources before throwing
-                await client.close().catch(()=>{});
-                throw new Error(`Server not running at ${url}`);
+                const unavailable = new Error(`Server not running at ${url}`, {
+                    cause: error
+                });
+                throw unavailable;
             }
             // Check for known errors that indicate SSE fallback is needed
             const shouldFallback = errorMessage.includes('Missing session ID') || // FastMCP specific
@@ -265,18 +336,9 @@ import { waitForHttpReady } from './wait-for-http-ready.js';
                 }
             } : undefined;
             const sseTransport = new SSEClientTransport(url, sseTransportOptions);
-            try {
-                await withTimeout(sseClient.connect(sseTransport), 30000, 'SSE connection');
-                // Return SSE client instead of original
-                return sseClient;
-            } catch (sseError) {
-                // SSE connection failed - clean up both clients before throwing
-                await Promise.all([
-                    client.close().catch(()=>{}),
-                    sseClient.close().catch(()=>{})
-                ]);
-                throw sseError;
-            }
+            await connectTransportWithTimeout(sseClient, sseTransport, HTTP_CONNECTION_TIMEOUT_MS, 'SSE connection', options === null || options === void 0 ? void 0 : options.signal);
+            // Return SSE client instead of original
+            return sseClient;
         }
     }
     return client; // Guaranteed ready when returned