@mcp-z/client 2.2.4 → 2.3.0

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/mcp-z/client/src/connection/connect-client.ts"],"sourcesContent":["/**\n * connect-mcp-client.ts\n *\n * Helper to connect MCP SDK clients to servers with intelligent transport inference.\n * Automatically detects transport type from URL protocol or type field.\n */\n\nimport type { ClientOptions, Transport, VersionNegotiationOptions } from '@modelcontextprotocol/client';\nimport { Client, SSEClientTransport, StreamableHTTPClientTransport } from '@modelcontextprotocol/client';\nimport { StdioClientTransport } from '@modelcontextprotocol/client/stdio';\nimport getPort from 'get-port';\nimport { probeAuthCapabilities } from '../auth/index.ts';\nimport { DCR_CAPABILTY_DISCOVERY_TIMEOUT } from '../constants.ts';\nimport { DcrAuthenticator, type DcrAuthenticatorOptions } from '../dcr/index.ts';\nimport { normalizeUrl } from '../lib/url-utils.ts';\nimport type { ServerProcess } from '../spawn/spawn-server.ts';\nimport type { ServersConfig } from '../spawn/spawn-servers.ts';\n\n/**\n * Minimal interface for connecting to servers.\n * Only needs config and servers map for connection logic.\n */\ninterface RegistryLike {\n  config: ServersConfig;\n  servers: Map<string, ServerProcess>;\n}\n\nimport type { McpServerEntry, TransportType } from '../types.ts';\nimport { logger as defaultLogger, type Logger } from '../utils/logger.ts';\nimport { ExistingProcessTransport } from './existing-process-transport.ts';\nimport { waitForHttpReady } from './wait-for-http-ready.ts';\n\n/**\n * Wrap promise with timeout - throws if promise takes too long\n * Clears timeout when promise completes to prevent hanging event loop\n * @param promise - Promise to wrap\n * @param ms - Timeout in milliseconds\n * @param operation - Description of operation for error message\n * @returns Promise result or timeout error\n */\nasync function withTimeout<T>(promise: Promise<T>, ms: number, operation: string): Promise<T> {\n  let timeoutId: NodeJS.Timeout;\n\n  return Promise.race([\n    promise.finally(() => clearTimeout(timeoutId)),\n    new Promise<T>((_, reject) => {\n      timeoutId = setTimeout(() => reject(new Error(`Timeout after ${ms}ms: ${operation}`)), ms);\n    }),\n  ]);\n}\n\n/**\n * Infer transport type from server configuration with validation.\n *\n * Priority:\n * 1. Explicit type field (if present)\n * 2. URL protocol (if URL present): http://, https://\n * 3. Default to 'stdio' (if neither present)\n *\n * @param config - Server configuration\n * @returns Transport type\n * @throws Error if configuration is invalid or has conflicts\n */\nfunction inferTransportType(config: McpServerEntry): TransportType {\n  // Priority 1: Explicit type field\n  if (config.type) {\n    // Validate consistency with URL if both present\n    if (config.url) {\n      const url = new URL(config.url);\n      const protocol = url.protocol;\n\n      if ((protocol === 'http:' || protocol === 'https:') && config.type !== 'http' && config.type !== 'sse-ide') {\n        throw new Error(`Conflicting transport: URL protocol '${protocol}' requires type 'http', but got '${config.type}'`);\n      }\n    }\n\n    // Return normalized type\n    if (config.type === 'http' || config.type === 'sse-ide') return 'http';\n    if (config.type === 'stdio') return 'stdio';\n\n    throw new Error(`Unsupported transport type: ${config.type}`);\n  }\n\n  // Priority 2: Infer from URL protocol\n  if (config.url) {\n    const url = new URL(config.url);\n    const protocol = url.protocol;\n\n    if (protocol === 'http:' || protocol === 'https:') {\n      return 'http';\n    }\n    throw new Error(`Unsupported URL protocol: ${protocol}`);\n  }\n\n  // Priority 3: Default to stdio\n  return 'stdio';\n}\n\n/**\n * Connect MCP SDK client to server with full readiness handling.\n * @internal - Use registry.connect() instead\n *\n * **Completely handles readiness**: transport availability + MCP protocol handshake.\n *\n * Transport is intelligently inferred and handled:\n * - **Stdio servers**: Direct MCP connect (fast for spawned processes)\n * - **HTTP servers**: Transport polling (/mcp endpoint) + MCP connect\n * - **Registry result**: Handles both spawned and external servers\n *\n * Returns only when server is fully MCP-ready (initialize handshake complete).\n *\n * @param registryOrConfig - Result from createServerRegistry() or servers config object\n * @param serverName - Server name from servers config\n * @param options - Connection options (see below)\n * @param options.dcrAuthenticator - DCR authenticator options\n * @param options.logger - Logger for connection diagnostics\n * @param options.versionNegotiation - SDK protocol version negotiation (protocol revision\n *   2026-07-28 and later). Omitted by default, which keeps the SDK's `'legacy'` mode:\n *   the plain 2025 connect sequence. Pass `{ mode: 'auto' }` to probe the server and\n *   fall back to 2025 when it cannot serve the modern era, or `{ mode: { pin: '2026-07-28' } }`\n *   to require the pinned revision (a server that cannot serve it fails the connect with\n *   a typed era-negotiation error).\n * @returns Connected MCP SDK Client (guaranteed ready)\n *\n * @example\n * // Using registry (recommended)\n * const registry = createServerRegistry({ echo: { command: 'node', args: ['server.ts'] } });\n * const client = await registry.connect('echo');\n * // Server is fully ready - transport available + MCP handshake complete\n *\n * @example\n * // HTTP server readiness (waits for /mcp polling + MCP handshake)\n * const registry = createServerRegistry(\n *   { http: { type: 'http', url: 'http://localhost:3000/mcp', start: {...} } },\n *   { dialects: ['start'] }\n * );\n * const client = await registry.connect('http');\n * // 1. Waits for HTTP server to respond on /mcp\n * // 2. Performs MCP initialize handshake\n * // 3. Returns ready client\n */\nexport async function connectMcpClient(\n  registryOrConfig: RegistryLike | ServersConfig,\n  serverName: string,\n  options?: {\n    dcrAuthenticator?: Partial<DcrAuthenticatorOptions>;\n    logger?: Logger;\n    versionNegotiation?: VersionNegotiationOptions;\n  }\n): Promise<Client> {\n  // Detect whether we have a RegistryLike instance or just config\n  const isRegistry = 'servers' in registryOrConfig && registryOrConfig.servers instanceof Map;\n  const serversConfig: ServersConfig = isRegistry ? (registryOrConfig as RegistryLike).config : (registryOrConfig as ServersConfig);\n  const registry = isRegistry ? (registryOrConfig as RegistryLike) : undefined;\n  const logger = options?.logger ?? defaultLogger;\n\n  const serverConfig = serversConfig[serverName];\n\n  if (!serverConfig) {\n    const available = Object.keys(serversConfig).join(', ');\n    throw new Error(`Server '${serverName}' not found in config. Available servers: ${available || 'none'}`);\n  }\n\n  // Infer transport type with validation\n  const transportType = inferTransportType(serverConfig);\n\n  // SDK client options for both transports (main + SSE fallback). versionNegotiation is\n  // omitted rather than set to undefined so the default stays the SDK's 'legacy' mode —\n  // the plain 2025 connect sequence — for callers that do not pass it.\n  const clientOptions: ClientOptions = { capabilities: {} };\n  if (options?.versionNegotiation !== undefined) {\n    clientOptions.versionNegotiation = options.versionNegotiation;\n  }\n\n  // Create MCP client\n  const client = new Client({ name: 'mcp-cli-client', version: '1.0.0' }, clientOptions);\n\n  // Connect based on inferred transport\n  if (transportType === 'stdio') {\n    // Check if we have a spawned process in the registry\n    const serverHandle = registry?.servers.get(serverName);\n\n    if (serverHandle) {\n      // Reuse the already-spawned process\n      const transport = new ExistingProcessTransport(serverHandle.process);\n      await client.connect(transport);\n    } else {\n      // No registry or server not in registry - spawn new process directly\n      // This is the standard fallback when process management is not used\n      if (!serverConfig.command) {\n        throw new Error(`Server '${serverName}' has stdio transport but missing 'command' field`);\n      }\n\n      const transport = new StdioClientTransport({\n        command: serverConfig.command,\n        args: serverConfig.args || [],\n        env: serverConfig.env || {},\n      });\n\n      // client.connect() performs initialize handshake - when it resolves, server is ready\n      await client.connect(transport);\n    }\n  } else if (transportType === 'http') {\n    if (!('url' in serverConfig) || !serverConfig.url) {\n      throw new Error(`Server '${serverName}' has http transport but missing 'url' field`);\n    }\n\n    // Check if this is a freshly spawned HTTP server (from registry)\n    // that might not be ready yet - transport readiness check needed\n    const isSpawnedHttp = registry?.servers.has(serverName);\n\n    if (isSpawnedHttp) {\n      logger.debug(`[connectMcpClient] waiting for HTTP server '${serverName}' at ${serverConfig.url}`);\n      await waitForHttpReady(serverConfig.url);\n      logger.debug(`[connectMcpClient] HTTP server '${serverName}' ready`);\n    }\n\n    const url = new URL(serverConfig.url);\n\n    // Check for DCR support and handle authentication automatically\n    // The canonical MCP server URI, path segment and all. Both calls below need\n    // the server's identity, not its deployment root: discovery uses the path to\n    // find resource-specific metadata (RFC 9728 sub-path), and the authenticator\n    // audience-binds tokens to it (RFC 8707). Handing either the `/mcp`-stripped\n    // base names a different resource, which authorization servers that validate\n    // the `resource` indicator reject as `invalid_target`.\n    const mcpServerUrl = normalizeUrl(serverConfig.url);\n    const capabilities = await withTimeout(probeAuthCapabilities(mcpServerUrl), DCR_CAPABILTY_DISCOVERY_TIMEOUT, 'DCR capability discovery');\n\n    let authToken: string | undefined;\n\n    if (capabilities.supportsDcr) {\n      logger.debug(`🔐 Server '${serverName}' supports DCR authentication`);\n\n      // Get available port and create the exact redirect URI to use\n      const port = await getPort();\n      const redirectUri = `http://localhost:${port}/callback`;\n\n      // Handle authentication using DcrAuthenticator with fully resolved redirectUri\n      const authenticator = new DcrAuthenticator({\n        headless: false,\n        redirectUri,\n        logger,\n        ...options?.dcrAuthenticator,\n      });\n\n      // Ensure we have valid tokens (performs DCR + OAuth if needed)\n      const tokens = await authenticator.ensureAuthenticated(mcpServerUrl, capabilities);\n      authToken = tokens.accessToken;\n\n      logger.debug(`✅ Authentication complete for '${serverName}'`);\n    } else {\n      logger.debug(`ℹ️  Server '${serverName}' does not support DCR - connecting without authentication`);\n    }\n\n    try {\n      // Try modern Streamable HTTP first (protocol version 2025-03-26)\n      // Merge static headers from config with DCR auth headers (DCR Authorization takes precedence)\n      const staticHeaders = serverConfig.headers || {};\n      const dcrHeaders = authToken ? { Authorization: `Bearer ${authToken}` } : {};\n      const mergedHeaders = { ...staticHeaders, ...dcrHeaders };\n\n      const transportOptions =\n        Object.keys(mergedHeaders).length > 0\n          ? {\n              requestInit: {\n                headers: mergedHeaders,\n              },\n            }\n          : undefined;\n\n      const transport = new StreamableHTTPClientTransport(url, transportOptions);\n      // Type assertion: SDK transport has sessionId: string | undefined but Transport expects string\n      // This is safe at runtime - the undefined is valid per MCP spec\n      await withTimeout(client.connect(transport as unknown as Transport), 30000, 'StreamableHTTP connection');\n    } catch (error) {\n      // Fall back to SSE transport (MCP protocol version 2024-11-05)\n      // SSE is a standard MCP transport used by many servers (e.g., FastMCP ecosystem)\n      const errorMessage = error instanceof Error ? error.message : String(error);\n\n      // Fast-fail: Don't try SSE if connection was refused (server not running)\n      // Check error.cause.code for ECONNREFUSED (fetch errors wrap the actual error in cause)\n      const cause = error instanceof Error ? (error as Error & { cause?: { code?: string } }).cause : undefined;\n      const isConnectionRefused = cause?.code === 'ECONNREFUSED' || errorMessage.includes('Connection refused');\n\n      if (isConnectionRefused) {\n        // Clean up client resources before throwing\n        await client.close().catch(() => {});\n        throw new Error(`Server not running at ${url}`);\n      }\n\n      // Check for known errors that indicate SSE fallback is needed\n      const shouldFallback =\n        errorMessage.includes('Missing session ID') || // FastMCP specific\n        errorMessage.includes('404') || // Server doesn't have streamable HTTP endpoint\n        errorMessage.includes('405'); // Method not allowed\n\n      if (shouldFallback) {\n        logger.warn(`Streamable HTTP failed (${errorMessage}), falling back to SSE transport`);\n      } else {\n        logger.warn('Streamable HTTP connection failed, trying SSE transport as fallback');\n      }\n\n      // Create new client for SSE transport (required per SDK pattern)\n      const sseClient = new Client({ name: 'mcp-cli-client', version: '1.0.0' }, clientOptions);\n\n      // SSE transport with merged headers (static + DCR auth)\n      // Reuse the same header merging logic as Streamable HTTP\n      const staticHeaders = serverConfig.headers || {};\n      const dcrHeaders = authToken ? { Authorization: `Bearer ${authToken}` } : {};\n      const mergedHeaders = { ...staticHeaders, ...dcrHeaders };\n\n      const sseTransportOptions =\n        Object.keys(mergedHeaders).length > 0\n          ? {\n              requestInit: {\n                headers: mergedHeaders,\n              },\n            }\n          : undefined;\n\n      const sseTransport = new SSEClientTransport(url, sseTransportOptions);\n\n      try {\n        await withTimeout(sseClient.connect(sseTransport), 30000, 'SSE connection');\n        // Return SSE client instead of original\n        return sseClient;\n      } catch (sseError) {\n        // SSE connection failed - clean up both clients before throwing\n        await Promise.all([client.close().catch(() => {}), sseClient.close().catch(() => {})]);\n        throw sseError;\n      }\n    }\n  }\n\n  return client; // Guaranteed ready when returned\n}\n"],"names":["Client","SSEClientTransport","StreamableHTTPClientTransport","StdioClientTransport","getPort","probeAuthCapabilities","DCR_CAPABILTY_DISCOVERY_TIMEOUT","DcrAuthenticator","normalizeUrl","logger","defaultLogger","ExistingProcessTransport","waitForHttpReady","withTimeout","promise","ms","operation","timeoutId","Promise","race","finally","clearTimeout","_","reject","setTimeout","Error","inferTransportType","config","type","url","URL","protocol","connectMcpClient","registryOrConfig","serverName","options","isRegistry","servers","Map","serversConfig","registry","undefined","serverConfig","available","Object","keys","join","transportType","clientOptions","capabilities","versionNegotiation","client","name","version","serverHandle","get","transport","process","connect","command","args","env","isSpawnedHttp","has","debug","mcpServerUrl","authToken","supportsDcr","port","redirectUri","authenticator","headless","dcrAuthenticator","tokens","ensureAuthenticated","accessToken","staticHeaders","headers","dcrHeaders","Authorization","mergedHeaders","transportOptions","length","requestInit","error","errorMessage","message","String","cause","isConnectionRefused","code","includes","close","catch","shouldFallback","warn","sseClient","sseTransportOptions","sseTransport","sseError","all"],"mappings":"AAAA;;;;;CAKC,GAGD,SAASA,MAAM,EAAEC,kBAAkB,EAAEC,6BAA6B,QAAQ,+BAA+B;AACzG,SAASC,oBAAoB,QAAQ,qCAAqC;AAC1E,OAAOC,aAAa,WAAW;AAC/B,SAASC,qBAAqB,QAAQ,mBAAmB;AACzD,SAASC,+BAA+B,QAAQ,kBAAkB;AAClE,SAASC,gBAAgB,QAAsC,kBAAkB;AACjF,SAASC,YAAY,QAAQ,sBAAsB;AAcnD,SAASC,UAAUC,aAAa,QAAqB,qBAAqB;AAC1E,SAASC,wBAAwB,QAAQ,kCAAkC;AAC3E,SAASC,gBAAgB,QAAQ,2BAA2B;AAE5D;;;;;;;CAOC,GACD,eAAeC,YAAeC,OAAmB,EAAEC,EAAU,EAAEC,SAAiB;IAC9E,IAAIC;IAEJ,OAAOC,QAAQC,IAAI,CAAC;QAClBL,QAAQM,OAAO,CAAC,IAAMC,aAAaJ;QACnC,IAAIC,QAAW,CAACI,GAAGC;YACjBN,YAAYO,WAAW,IAAMD,OAAO,IAAIE,MAAM,CAAC,cAAc,EAAEV,GAAG,IAAI,EAAEC,WAAW,IAAID;QACzF;KACD;AACH;AAEA;;;;;;;;;;;CAWC,GACD,SAASW,mBAAmBC,MAAsB;IAChD,kCAAkC;IAClC,IAAIA,OAAOC,IAAI,EAAE;QACf,gDAAgD;QAChD,IAAID,OAAOE,GAAG,EAAE;YACd,MAAMA,MAAM,IAAIC,IAAIH,OAAOE,GAAG;YAC9B,MAAME,WAAWF,IAAIE,QAAQ;YAE7B,IAAI,AAACA,CAAAA,aAAa,WAAWA,aAAa,QAAO,KAAMJ,OAAOC,IAAI,KAAK,UAAUD,OAAOC,IAAI,KAAK,WAAW;gBAC1G,MAAM,IAAIH,MAAM,CAAC,qCAAqC,EAAEM,SAAS,iCAAiC,EAAEJ,OAAOC,IAAI,CAAC,CAAC,CAAC;YACpH;QACF;QAEA,yBAAyB;QACzB,IAAID,OAAOC,IAAI,KAAK,UAAUD,OAAOC,IAAI,KAAK,WAAW,OAAO;QAChE,IAAID,OAAOC,IAAI,KAAK,SAAS,OAAO;QAEpC,MAAM,IAAIH,MAAM,CAAC,4BAA4B,EAAEE,OAAOC,IAAI,EAAE;IAC9D;IAEA,sCAAsC;IACtC,IAAID,OAAOE,GAAG,EAAE;QACd,MAAMA,MAAM,IAAIC,IAAIH,OAAOE,GAAG;QAC9B,MAAME,WAAWF,IAAIE,QAAQ;QAE7B,IAAIA,aAAa,WAAWA,aAAa,UAAU;YACjD,OAAO;QACT;QACA,MAAM,IAAIN,MAAM,CAAC,0BAA0B,EAAEM,UAAU;IACzD;IAEA,+BAA+B;IAC/B,OAAO;AACT;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0CC,GACD,OAAO,eAAeC,iBACpBC,gBAA8C,EAC9CC,UAAkB,EAClBC,OAIC;;IAED,gEAAgE;IAChE,MAAMC,aAAa,aAAaH,oBAAoBA,iBAAiBI,OAAO,YAAYC;IACxF,MAAMC,gBAA+BH,aAAa,AAACH,iBAAkCN,MAAM,GAAIM;IAC/F,MAAMO,WAAWJ,aAAcH,mBAAoCQ;IACnE,MAAMhC,iBAAS0B,oBAAAA,8BAAAA,QAAS1B,MAAM,uCAAIC;IAElC,MAAMgC,eAAeH,aAAa,CAACL,WAAW;IAE9C,IAAI,CAACQ,cAAc;QACjB,MAAMC,YAAYC,OAAOC,IAAI,CAACN,eAAeO,IAAI,CAAC;QAClD,MAAM,IAAIrB,MAAM,CAAC,QAAQ,EAAES,WAAW,0CAA0C,EAAES,aAAa,QAAQ;IACzG;IAEA,uCAAuC;IACvC,MAAMI,gBAAgBrB,mBAAmBgB;IAEzC,sFAAsF;IACtF,sFAAsF;IACtF,qEAAqE;IACrE,MAAMM,gBAA+B;QAAEC,cAAc,CAAC;IAAE;IACxD,IAAId,CAAAA,oBAAAA,8BAAAA,QAASe,kBAAkB,MAAKT,WAAW;QAC7CO,cAAcE,kBAAkB,GAAGf,QAAQe,kBAAkB;IAC/D;IAEA,oBAAoB;IACpB,MAAMC,SAAS,IAAInD,OAAO;QAAEoD,MAAM;QAAkBC,SAAS;IAAQ,GAAGL;IAExE,sCAAsC;IACtC,IAAID,kBAAkB,SAAS;QAC7B,qDAAqD;QACrD,MAAMO,eAAed,qBAAAA,+BAAAA,SAAUH,OAAO,CAACkB,GAAG,CAACrB;QAE3C,IAAIoB,cAAc;YAChB,oCAAoC;YACpC,MAAME,YAAY,IAAI7C,yBAAyB2C,aAAaG,OAAO;YACnE,MAAMN,OAAOO,OAAO,CAACF;QACvB,OAAO;YACL,qEAAqE;YACrE,oEAAoE;YACpE,IAAI,CAACd,aAAaiB,OAAO,EAAE;gBACzB,MAAM,IAAIlC,MAAM,CAAC,QAAQ,EAAES,WAAW,iDAAiD,CAAC;YAC1F;YAEA,MAAMsB,YAAY,IAAIrD,qBAAqB;gBACzCwD,SAASjB,aAAaiB,OAAO;gBAC7BC,MAAMlB,aAAakB,IAAI,IAAI,EAAE;gBAC7BC,KAAKnB,aAAamB,GAAG,IAAI,CAAC;YAC5B;YAEA,qFAAqF;YACrF,MAAMV,OAAOO,OAAO,CAACF;QACvB;IACF,OAAO,IAAIT,kBAAkB,QAAQ;QACnC,IAAI,CAAE,CAAA,SAASL,YAAW,KAAM,CAACA,aAAab,GAAG,EAAE;YACjD,MAAM,IAAIJ,MAAM,CAAC,QAAQ,EAAES,WAAW,4CAA4C,CAAC;QACrF;QAEA,iEAAiE;QACjE,iEAAiE;QACjE,MAAM4B,gBAAgBtB,qBAAAA,+BAAAA,SAAUH,OAAO,CAAC0B,GAAG,CAAC7B;QAE5C,IAAI4B,eAAe;YACjBrD,OAAOuD,KAAK,CAAC,CAAC,4CAA4C,EAAE9B,WAAW,KAAK,EAAEQ,aAAab,GAAG,EAAE;YAChG,MAAMjB,iBAAiB8B,aAAab,GAAG;YACvCpB,OAAOuD,KAAK,CAAC,CAAC,gCAAgC,EAAE9B,WAAW,OAAO,CAAC;QACrE;QAEA,MAAML,MAAM,IAAIC,IAAIY,aAAab,GAAG;QAEpC,gEAAgE;QAChE,4EAA4E;QAC5E,6EAA6E;QAC7E,6EAA6E;QAC7E,6EAA6E;QAC7E,6EAA6E;QAC7E,uDAAuD;QACvD,MAAMoC,eAAezD,aAAakC,aAAab,GAAG;QAClD,MAAMoB,eAAe,MAAMpC,YAAYR,sBAAsB4D,eAAe3D,iCAAiC;QAE7G,IAAI4D;QAEJ,IAAIjB,aAAakB,WAAW,EAAE;YAC5B1D,OAAOuD,KAAK,CAAC,CAAC,WAAW,EAAE9B,WAAW,6BAA6B,CAAC;YAEpE,8DAA8D;YAC9D,MAAMkC,OAAO,MAAMhE;YACnB,MAAMiE,cAAc,CAAC,iBAAiB,EAAED,KAAK,SAAS,CAAC;YAEvD,+EAA+E;YAC/E,MAAME,gBAAgB,IAAI/D,iBAAiB;gBACzCgE,UAAU;gBACVF;gBACA5D;mBACG0B,oBAAAA,8BAAAA,QAASqC,gBAAgB,AAA5B;YACF;YAEA,+DAA+D;YAC/D,MAAMC,SAAS,MAAMH,cAAcI,mBAAmB,CAACT,cAAchB;YACrEiB,YAAYO,OAAOE,WAAW;YAE9BlE,OAAOuD,KAAK,CAAC,CAAC,+BAA+B,EAAE9B,WAAW,CAAC,CAAC;QAC9D,OAAO;YACLzB,OAAOuD,KAAK,CAAC,CAAC,YAAY,EAAE9B,WAAW,0DAA0D,CAAC;QACpG;QAEA,IAAI;YACF,iEAAiE;YACjE,8FAA8F;YAC9F,MAAM0C,gBAAgBlC,aAAamC,OAAO,IAAI,CAAC;YAC/C,MAAMC,aAAaZ,YAAY;gBAAEa,eAAe,CAAC,OAAO,EAAEb,WAAW;YAAC,IAAI,CAAC;YAC3E,MAAMc,gBAAgB;gBAAE,GAAGJ,aAAa;gBAAE,GAAGE,UAAU;YAAC;YAExD,MAAMG,mBACJrC,OAAOC,IAAI,CAACmC,eAAeE,MAAM,GAAG,IAChC;gBACEC,aAAa;oBACXN,SAASG;gBACX;YACF,IACAvC;YAEN,MAAMe,YAAY,IAAItD,8BAA8B2B,KAAKoD;YACzD,+FAA+F;YAC/F,gEAAgE;YAChE,MAAMpE,YAAYsC,OAAOO,OAAO,CAACF,YAAoC,OAAO;QAC9E,EAAE,OAAO4B,OAAO;YACd,+DAA+D;YAC/D,iFAAiF;YACjF,MAAMC,eAAeD,iBAAiB3D,QAAQ2D,MAAME,OAAO,GAAGC,OAAOH;YAErE,0EAA0E;YAC1E,wFAAwF;YACxF,MAAMI,QAAQJ,iBAAiB3D,QAAQ,AAAC2D,MAAgDI,KAAK,GAAG/C;YAChG,MAAMgD,sBAAsBD,CAAAA,kBAAAA,4BAAAA,MAAOE,IAAI,MAAK,kBAAkBL,aAAaM,QAAQ,CAAC;YAEpF,IAAIF,qBAAqB;gBACvB,4CAA4C;gBAC5C,MAAMtC,OAAOyC,KAAK,GAAGC,KAAK,CAAC,KAAO;gBAClC,MAAM,IAAIpE,MAAM,CAAC,sBAAsB,EAAEI,KAAK;YAChD;YAEA,8DAA8D;YAC9D,MAAMiE,iBACJT,aAAaM,QAAQ,CAAC,yBAAyB,mBAAmB;YAClEN,aAAaM,QAAQ,CAAC,UAAU,+CAA+C;YAC/EN,aAAaM,QAAQ,CAAC,QAAQ,qBAAqB;YAErD,IAAIG,gBAAgB;gBAClBrF,OAAOsF,IAAI,CAAC,CAAC,wBAAwB,EAAEV,aAAa,gCAAgC,CAAC;YACvF,OAAO;gBACL5E,OAAOsF,IAAI,CAAC;YACd;YAEA,iEAAiE;YACjE,MAAMC,YAAY,IAAIhG,OAAO;gBAAEoD,MAAM;gBAAkBC,SAAS;YAAQ,GAAGL;YAE3E,wDAAwD;YACxD,yDAAyD;YACzD,MAAM4B,gBAAgBlC,aAAamC,OAAO,IAAI,CAAC;YAC/C,MAAMC,aAAaZ,YAAY;gBAAEa,eAAe,CAAC,OAAO,EAAEb,WAAW;YAAC,IAAI,CAAC;YAC3E,MAAMc,gBAAgB;gBAAE,GAAGJ,aAAa;gBAAE,GAAGE,UAAU;YAAC;YAExD,MAAMmB,sBACJrD,OAAOC,IAAI,CAACmC,eAAeE,MAAM,GAAG,IAChC;gBACEC,aAAa;oBACXN,SAASG;gBACX;YACF,IACAvC;YAEN,MAAMyD,eAAe,IAAIjG,mBAAmB4B,KAAKoE;YAEjD,IAAI;gBACF,MAAMpF,YAAYmF,UAAUtC,OAAO,CAACwC,eAAe,OAAO;gBAC1D,wCAAwC;gBACxC,OAAOF;YACT,EAAE,OAAOG,UAAU;gBACjB,gEAAgE;gBAChE,MAAMjF,QAAQkF,GAAG,CAAC;oBAACjD,OAAOyC,KAAK,GAAGC,KAAK,CAAC,KAAO;oBAAIG,UAAUJ,KAAK,GAAGC,KAAK,CAAC,KAAO;iBAAG;gBACrF,MAAMM;YACR;QACF;IACF;IAEA,OAAOhD,QAAQ,iCAAiC;AAClD"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/mcp-z/client/src/connection/connect-client.ts"],"sourcesContent":["/**\n * connect-mcp-client.ts\n *\n * Helper to connect MCP SDK clients to servers with intelligent transport inference.\n * Automatically detects transport type from URL protocol or type field.\n */\n\nimport type { ClientOptions, Transport, VersionNegotiationOptions } from '@modelcontextprotocol/client';\nimport { Client, SSEClientTransport, StreamableHTTPClientTransport } from '@modelcontextprotocol/client';\nimport { StdioClientTransport } from '@modelcontextprotocol/client/stdio';\nimport getPort from 'get-port';\nimport { probeAuthCapabilities } from '../auth/index.ts';\nimport { DCR_CAPABILTY_DISCOVERY_TIMEOUT } from '../constants.ts';\nimport { DcrAuthenticator, type DcrAuthenticatorOptions } from '../dcr/index.ts';\nimport { normalizeUrl } from '../lib/url-utils.ts';\nimport type { ServerProcess } from '../spawn/spawn-server.ts';\nimport type { ServersConfig } from '../spawn/spawn-servers.ts';\n\n/**\n * Minimal interface for connecting to servers.\n * Only needs config and servers map for connection logic.\n */\ninterface RegistryLike {\n  config: ServersConfig;\n  servers: Map<string, ServerProcess>;\n}\n\nimport type { McpServerEntry, TransportType } from '../types.ts';\nimport { logger as defaultLogger, type Logger } from '../utils/logger.ts';\nimport { ExistingProcessTransport } from './existing-process-transport.ts';\nimport { waitForHttpReady } from './wait-for-http-ready.ts';\n\nconst HTTP_CONNECTION_TIMEOUT_MS = 30_000;\nconst CLIENT_CLEANUP_TIMEOUT_MS = 5_000;\n\n/** @internal - Bounds work by aborting the actual request signal at the deadline. */\nexport async function withAbortTimeout<T>(operationFn: (signal: AbortSignal) => Promise<T>, ms: number, operation: string, parentSignal?: AbortSignal): Promise<T> {\n  const controller = new AbortController();\n  const timeoutError = new Error(`Timeout after ${ms}ms: ${operation}`);\n  const abortFromParent = (): void => controller.abort(parentSignal?.reason instanceof Error ? parentSignal.reason : new Error('Connection was cancelled'));\n  parentSignal?.addEventListener('abort', abortFromParent, { once: true });\n  if (parentSignal?.aborted) abortFromParent();\n  const timeoutId = setTimeout(() => controller.abort(timeoutError), ms);\n\n  try {\n    // Preserve the operation's error unchanged: connection cleanup may have\n    // attached failures to the original cancellation or timeout.\n    return await operationFn(controller.signal);\n  } finally {\n    clearTimeout(timeoutId);\n    parentSignal?.removeEventListener('abort', abortFromParent);\n  }\n}\n\n/** @internal - Connects a transport with a deadline that aborts and cleans up the actual connection. */\nexport async function connectTransportWithTimeout(client: Client, transport: Transport, ms: number, operation: string, parentSignal?: AbortSignal): Promise<void> {\n  return withAbortTimeout((signal) => connectTransport(client, transport, signal), ms, operation, parentSignal);\n}\n\nfunction throwIfAborted(signal?: AbortSignal): void {\n  if (signal?.aborted) throw signal.reason instanceof Error ? signal.reason : new Error('Connection was cancelled');\n}\n\nasync function closeClientWithinTimeout(client: Client): Promise<void> {\n  let timeoutId: NodeJS.Timeout | undefined;\n  try {\n    await Promise.race([\n      client.close(),\n      new Promise<never>((_, reject) => {\n        timeoutId = setTimeout(() => reject(new Error(`Client cleanup did not complete within ${CLIENT_CLEANUP_TIMEOUT_MS}ms`)), CLIENT_CLEANUP_TIMEOUT_MS);\n      }),\n    ]);\n  } finally {\n    if (timeoutId) clearTimeout(timeoutId);\n  }\n}\n\nasync function rethrowAfterClientCleanup(error: unknown, clients: Client[], message: string): Promise<never> {\n  const cleanup = await Promise.allSettled(clients.map((client) => closeClientWithinTimeout(client)));\n  const cleanupErrors = cleanup.flatMap((result) => (result.status === 'rejected' ? [result.reason] : []));\n  if (cleanupErrors.length > 0) throw new AggregateError([error, ...cleanupErrors], message, { cause: error });\n  throw error;\n}\n\n/** @internal - Connects one client/transport pair and reports any failed cleanup. */\nexport async function connectTransport(client: Client, transport: Transport, signal?: AbortSignal): Promise<void> {\n  let abortHandler: (() => void) | undefined;\n  try {\n    throwIfAborted(signal);\n    const connecting = client.connect(transport);\n    if (signal) {\n      const aborted = new Promise<never>((_, reject) => {\n        abortHandler = () => reject(signal.reason instanceof Error ? signal.reason : new Error('Connection was cancelled'));\n        signal.addEventListener('abort', abortHandler, { once: true });\n      });\n      await Promise.race([connecting, aborted]);\n    } else {\n      await connecting;\n    }\n  } catch (error) {\n    await rethrowAfterClientCleanup(error, [client], 'MCP connection failed and client cleanup also failed');\n  } finally {\n    if (signal && abortHandler) signal.removeEventListener('abort', abortHandler);\n  }\n}\n\n/**\n * Infer transport type from server configuration with validation.\n *\n * Priority:\n * 1. Explicit type field (if present)\n * 2. URL protocol (if URL present): http://, https://\n * 3. Default to 'stdio' (if neither present)\n *\n * @param config - Server configuration\n * @returns Transport type\n * @throws Error if configuration is invalid or has conflicts\n */\nfunction inferTransportType(config: McpServerEntry): TransportType {\n  // Priority 1: Explicit type field\n  if (config.type) {\n    // Validate consistency with URL if both present\n    if (config.url) {\n      const url = new URL(config.url);\n      const protocol = url.protocol;\n\n      if ((protocol === 'http:' || protocol === 'https:') && config.type !== 'http' && config.type !== 'sse-ide') {\n        throw new Error(`Conflicting transport: URL protocol '${protocol}' requires type 'http', but got '${config.type}'`);\n      }\n    }\n\n    // Return normalized type\n    if (config.type === 'http' || config.type === 'sse-ide') return 'http';\n    if (config.type === 'stdio') return 'stdio';\n\n    throw new Error(`Unsupported transport type: ${config.type}`);\n  }\n\n  // Priority 2: Infer from URL protocol\n  if (config.url) {\n    const url = new URL(config.url);\n    const protocol = url.protocol;\n\n    if (protocol === 'http:' || protocol === 'https:') {\n      return 'http';\n    }\n    throw new Error(`Unsupported URL protocol: ${protocol}`);\n  }\n\n  // Priority 3: Default to stdio\n  return 'stdio';\n}\n\n/**\n * Connect MCP SDK client to server with full readiness handling.\n * @internal - Use registry.connect() instead\n *\n * **Completely handles readiness**: transport availability + MCP protocol handshake.\n *\n * Transport is intelligently inferred and handled:\n * - **Stdio servers**: Direct MCP connect (fast for spawned processes)\n * - **HTTP servers**: Transport polling (/mcp endpoint) + MCP connect\n * - **Registry result**: Handles both spawned and external servers\n *\n * Returns only when server is fully MCP-ready (initialize handshake complete).\n *\n * @param registryOrConfig - Result from createServerRegistry() or servers config object\n * @param serverName - Server name from servers config\n * @param options - Connection options (see below)\n * @param options.dcrAuthenticator - DCR authenticator options\n * @param options.logger - Logger for connection diagnostics\n * @param options.versionNegotiation - SDK protocol version negotiation (protocol revision\n *   2026-07-28 and later). Omitted by default, which keeps the SDK's `'legacy'` mode:\n *   the plain 2025 connect sequence. Pass `{ mode: 'auto' }` to probe the server and\n *   fall back to 2025 when it cannot serve the modern era, or `{ mode: { pin: '2026-07-28' } }`\n *   to require the pinned revision (a server that cannot serve it fails the connect with\n *   a typed era-negotiation error).\n * @returns Connected MCP SDK Client (guaranteed ready)\n *\n * @example\n * // Using registry (recommended)\n * const registry = createServerRegistry({ echo: { command: 'node', args: ['server.ts'] } });\n * const client = await registry.connect('echo');\n * // Server is fully ready - transport available + MCP handshake complete\n *\n * @example\n * // HTTP server readiness (waits for /mcp polling + MCP handshake)\n * const registry = createServerRegistry(\n *   { http: { type: 'http', url: 'http://localhost:3000/mcp', start: {...} } },\n *   { dialects: ['start'] }\n * );\n * const client = await registry.connect('http');\n * // 1. Waits for HTTP server to respond on /mcp\n * // 2. Performs MCP initialize handshake\n * // 3. Returns ready client\n */\nexport async function connectMcpClient(\n  registryOrConfig: RegistryLike | ServersConfig,\n  serverName: string,\n  options?: {\n    dcrAuthenticator?: Partial<DcrAuthenticatorOptions>;\n    logger?: Logger;\n    versionNegotiation?: VersionNegotiationOptions;\n    /** Cancels readiness, authentication, and transport connection work. */\n    signal?: AbortSignal;\n  }\n): Promise<Client> {\n  // Detect whether we have a RegistryLike instance or just config\n  const isRegistry = 'servers' in registryOrConfig && registryOrConfig.servers instanceof Map;\n  const serversConfig: ServersConfig = isRegistry ? (registryOrConfig as RegistryLike).config : (registryOrConfig as ServersConfig);\n  const registry = isRegistry ? (registryOrConfig as RegistryLike) : undefined;\n  const logger = options?.logger ?? defaultLogger;\n  throwIfAborted(options?.signal);\n\n  const serverConfig = serversConfig[serverName];\n\n  if (!serverConfig) {\n    const available = Object.keys(serversConfig).join(', ');\n    throw new Error(`Server '${serverName}' not found in config. Available servers: ${available || 'none'}`);\n  }\n\n  // Infer transport type with validation\n  const transportType = inferTransportType(serverConfig);\n\n  // SDK client options for both transports (main + SSE fallback). versionNegotiation is\n  // omitted rather than set to undefined so the default stays the SDK's 'legacy' mode —\n  // the plain 2025 connect sequence — for callers that do not pass it.\n  const clientOptions: ClientOptions = { capabilities: {} };\n  if (options?.versionNegotiation !== undefined) {\n    clientOptions.versionNegotiation = options.versionNegotiation;\n  }\n\n  // Create MCP client\n  const client = new Client({ name: 'mcp-cli-client', version: '1.0.0' }, clientOptions);\n\n  // Connect based on inferred transport\n  if (transportType === 'stdio') {\n    // Check if we have a spawned process in the registry\n    const serverHandle = registry?.servers.get(serverName);\n\n    if (serverHandle) {\n      // Reuse the already-spawned process\n      const transport = new ExistingProcessTransport(serverHandle.process);\n      await connectTransport(client, transport, options?.signal);\n    } else {\n      // No registry or server not in registry - spawn new process directly\n      // This is the standard fallback when process management is not used\n      if (!serverConfig.command) {\n        throw new Error(`Server '${serverName}' has stdio transport but missing 'command' field`);\n      }\n\n      const transport = new StdioClientTransport({\n        command: serverConfig.command,\n        args: serverConfig.args || [],\n        env: serverConfig.env || {},\n      });\n\n      // client.connect() performs initialize handshake - when it resolves, server is ready\n      await connectTransport(client, transport, options?.signal);\n    }\n  } else if (transportType === 'http') {\n    if (!('url' in serverConfig) || !serverConfig.url) {\n      throw new Error(`Server '${serverName}' has http transport but missing 'url' field`);\n    }\n\n    // Check if this is a freshly spawned HTTP server (from registry)\n    // that might not be ready yet - transport readiness check needed\n    const isSpawnedHttp = registry?.servers.has(serverName);\n\n    if (isSpawnedHttp) {\n      logger.debug(`[connectMcpClient] waiting for HTTP server '${serverName}' at ${serverConfig.url}`);\n      await waitForHttpReady(serverConfig.url, 30000, options?.signal);\n      logger.debug(`[connectMcpClient] HTTP server '${serverName}' ready`);\n    }\n\n    const url = new URL(serverConfig.url);\n\n    // Check for DCR support and handle authentication automatically\n    // The canonical MCP server URI, path segment and all. Both calls below need\n    // the server's identity, not its deployment root: discovery uses the path to\n    // find resource-specific metadata (RFC 9728 sub-path), and the authenticator\n    // audience-binds tokens to it (RFC 8707). Handing either the `/mcp`-stripped\n    // base names a different resource, which authorization servers that validate\n    // the `resource` indicator reject as `invalid_target`.\n    const mcpServerUrl = normalizeUrl(serverConfig.url);\n    const capabilities = await withAbortTimeout((signal) => probeAuthCapabilities(mcpServerUrl, { signal }), DCR_CAPABILTY_DISCOVERY_TIMEOUT, 'DCR capability discovery', options?.signal);\n\n    let authToken: string | undefined;\n\n    if (capabilities.supportsDcr) {\n      logger.debug(`🔐 Server '${serverName}' supports DCR authentication`);\n\n      // Get available port and create the exact redirect URI to use\n      const port = await getPort();\n      const redirectUri = `http://localhost:${port}/callback`;\n\n      // Handle authentication using DcrAuthenticator with fully resolved redirectUri\n      const authenticator = new DcrAuthenticator({\n        headless: false,\n        redirectUri,\n        logger,\n        ...options?.dcrAuthenticator,\n      });\n\n      // Ensure we have valid tokens (performs DCR + OAuth if needed)\n      const tokens = await authenticator.ensureAuthenticated(mcpServerUrl, capabilities, options?.signal);\n      authToken = tokens.accessToken;\n\n      logger.debug(`✅ Authentication complete for '${serverName}'`);\n    } else {\n      logger.debug(`ℹ️  Server '${serverName}' does not support DCR - connecting without authentication`);\n    }\n\n    try {\n      // Try modern Streamable HTTP first (protocol version 2025-03-26)\n      // Merge static headers from config with DCR auth headers (DCR Authorization takes precedence)\n      const staticHeaders = serverConfig.headers || {};\n      const dcrHeaders = authToken ? { Authorization: `Bearer ${authToken}` } : {};\n      const mergedHeaders = { ...staticHeaders, ...dcrHeaders };\n\n      const transportOptions =\n        Object.keys(mergedHeaders).length > 0\n          ? {\n              requestInit: {\n                headers: mergedHeaders,\n              },\n            }\n          : undefined;\n\n      const transport = new StreamableHTTPClientTransport(url, transportOptions);\n      // Type assertion: SDK transport has sessionId: string | undefined but Transport expects string\n      // This is safe at runtime - the undefined is valid per MCP spec\n      await connectTransportWithTimeout(client, transport as unknown as Transport, HTTP_CONNECTION_TIMEOUT_MS, 'StreamableHTTP connection', options?.signal);\n    } catch (error) {\n      // Cancellation and cleanup failures must reach the caller; neither can\n      // safely be converted into an SSE fallback attempt.\n      if (options?.signal?.aborted || error instanceof AggregateError) throw error;\n      // Fall back to SSE transport (MCP protocol version 2024-11-05)\n      // SSE is a standard MCP transport used by many servers (e.g., FastMCP ecosystem)\n      const errorMessage = error instanceof Error ? error.message : String(error);\n\n      // Fast-fail: Don't try SSE if connection was refused (server not running)\n      // Check error.cause.code for ECONNREFUSED (fetch errors wrap the actual error in cause)\n      const cause = error instanceof Error ? (error as Error & { cause?: { code?: string } }).cause : undefined;\n      const isConnectionRefused = cause?.code === 'ECONNREFUSED' || errorMessage.includes('Connection refused');\n\n      if (isConnectionRefused) {\n        const unavailable = new Error(`Server not running at ${url}`, { cause: error });\n        throw unavailable;\n      }\n\n      // Check for known errors that indicate SSE fallback is needed\n      const shouldFallback =\n        errorMessage.includes('Missing session ID') || // FastMCP specific\n        errorMessage.includes('404') || // Server doesn't have streamable HTTP endpoint\n        errorMessage.includes('405'); // Method not allowed\n\n      if (shouldFallback) {\n        logger.warn(`Streamable HTTP failed (${errorMessage}), falling back to SSE transport`);\n      } else {\n        logger.warn('Streamable HTTP connection failed, trying SSE transport as fallback');\n      }\n\n      // Create new client for SSE transport (required per SDK pattern)\n      const sseClient = new Client({ name: 'mcp-cli-client', version: '1.0.0' }, clientOptions);\n\n      // SSE transport with merged headers (static + DCR auth)\n      // Reuse the same header merging logic as Streamable HTTP\n      const staticHeaders = serverConfig.headers || {};\n      const dcrHeaders = authToken ? { Authorization: `Bearer ${authToken}` } : {};\n      const mergedHeaders = { ...staticHeaders, ...dcrHeaders };\n\n      const sseTransportOptions =\n        Object.keys(mergedHeaders).length > 0\n          ? {\n              requestInit: {\n                headers: mergedHeaders,\n              },\n            }\n          : undefined;\n\n      const sseTransport = new SSEClientTransport(url, sseTransportOptions);\n\n      await connectTransportWithTimeout(sseClient, sseTransport, HTTP_CONNECTION_TIMEOUT_MS, 'SSE connection', options?.signal);\n      // Return SSE client instead of original\n      return sseClient;\n    }\n  }\n\n  return client; // Guaranteed ready when returned\n}\n"],"names":["Client","SSEClientTransport","StreamableHTTPClientTransport","StdioClientTransport","getPort","probeAuthCapabilities","DCR_CAPABILTY_DISCOVERY_TIMEOUT","DcrAuthenticator","normalizeUrl","logger","defaultLogger","ExistingProcessTransport","waitForHttpReady","HTTP_CONNECTION_TIMEOUT_MS","CLIENT_CLEANUP_TIMEOUT_MS","withAbortTimeout","operationFn","ms","operation","parentSignal","controller","AbortController","timeoutError","Error","abortFromParent","abort","reason","addEventListener","once","aborted","timeoutId","setTimeout","signal","clearTimeout","removeEventListener","connectTransportWithTimeout","client","transport","connectTransport","throwIfAborted","closeClientWithinTimeout","Promise","race","close","_","reject","rethrowAfterClientCleanup","error","clients","message","cleanup","allSettled","map","cleanupErrors","flatMap","result","status","length","AggregateError","cause","abortHandler","connecting","connect","inferTransportType","config","type","url","URL","protocol","connectMcpClient","registryOrConfig","serverName","options","isRegistry","servers","Map","serversConfig","registry","undefined","serverConfig","available","Object","keys","join","transportType","clientOptions","capabilities","versionNegotiation","name","version","serverHandle","get","process","command","args","env","isSpawnedHttp","has","debug","mcpServerUrl","authToken","supportsDcr","port","redirectUri","authenticator","headless","dcrAuthenticator","tokens","ensureAuthenticated","accessToken","staticHeaders","headers","dcrHeaders","Authorization","mergedHeaders","transportOptions","requestInit","errorMessage","String","isConnectionRefused","code","includes","unavailable","shouldFallback","warn","sseClient","sseTransportOptions","sseTransport"],"mappings":"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"}

package/dist/esm/connection/existing-process-transport.d.ts

@@ -2,38 +2,38 @@
  * existing-process-transport.ts
  *
  * MCP transport that wraps an existing child process for stdio communication.
- * Used when connecting to servers already spawned by initServers().
+ * Used when connecting to already-started processes.
  */
 import type { JSONRPCMessage, Transport } from '@modelcontextprotocol/client';
 import type { ChildProcess } from 'child_process';
 /**
  * Transport that communicates with an existing child process via stdio.
- * Does NOT spawn a new process - uses the one provided.
+ * Closing the transport releases only its listeners; process ownership stays with the registry.
  */
 export declare class ExistingProcessTransport implements Transport {
-    private _process;
-    private _readBuffer;
+    private readonly _process;
+    private readonly _readBuffer;
     private _dataHandler;
-    private _errorHandler;
+    private _stdinErrorHandler;
+    private _stdoutErrorHandler;
+    private _stdinCloseHandler;
+    private _processErrorHandler;
+    private _processCloseHandler;
+    private _started;
+    private _closed;
+    private readonly _pendingSends;
+    private _pendingWrites;
+    private _stdinErrorObserved;
     onclose?: () => void;
     onerror?: (error: Error) => void;
     onmessage?: (message: JSONRPCMessage) => void;
     constructor(process: ChildProcess);
-    /**
-     * Start the transport - sets up stdio listeners on existing process.
-     */
     start(): Promise<void>;
-    /**
-     * Process buffered messages from stdout.
-     */
     private processReadBuffer;
-    /**
-     * Close the transport - close without killing the shared process.
-     * The process is managed by the cluster and may have other active connections.
-     */
+    private detachListeners;
+    private detachPendingWriteErrorListener;
+    private retainStdinErrorListenerUntilClose;
+    private finish;
     close(): Promise<void>;
-    /**
-     * Send a message to the server via stdin.
-     */
     send(message: JSONRPCMessage): Promise<void>;
 }

package/dist/esm/connection/existing-process-transport.js

@@ -2,98 +2,160 @@
  * existing-process-transport.ts
  *
  * MCP transport that wraps an existing child process for stdio communication.
- * Used when connecting to servers already spawned by initServers().
+ * Used when connecting to already-started processes.
  */ import { ReadBuffer, serializeMessage } from '@modelcontextprotocol/client';
 /**
  * Transport that communicates with an existing child process via stdio.
- * Does NOT spawn a new process - uses the one provided.
+ * Closing the transport releases only its listeners; process ownership stays with the registry.
  */ export class ExistingProcessTransport {
-    /**
-   * Start the transport - sets up stdio listeners on existing process.
-   */ async start() {
-        return new Promise((resolve, reject)=>{
-            var // Listen for stdout data (MCP messages)
-            _this__process_stdout, _this__process_stdout1, _this__process_stdin;
-            // Listen for process events
-            this._process.on('error', (error)=>{
-                var _this_onerror, _this;
-                (_this_onerror = (_this = this).onerror) === null || _this_onerror === void 0 ? void 0 : _this_onerror.call(_this, error);
-                reject(error);
-            });
-            this._process.on('close', ()=>{
-                var _this_onclose, _this;
-                (_this_onclose = (_this = this).onclose) === null || _this_onclose === void 0 ? void 0 : _this_onclose.call(_this);
-            });
-            // Create and save data handler for close
-            this._dataHandler = (chunk)=>{
-                this._readBuffer.append(chunk);
-                this.processReadBuffer();
-            };
-            // Create and save error handler for close
-            this._errorHandler = (error)=>{
-                var _this_onerror, _this;
-                (_this_onerror = (_this = this).onerror) === null || _this_onerror === void 0 ? void 0 : _this_onerror.call(_this, error);
-            };
-            (_this__process_stdout = this._process.stdout) === null || _this__process_stdout === void 0 ? void 0 : _this__process_stdout.on('data', this._dataHandler);
-            (_this__process_stdout1 = this._process.stdout) === null || _this__process_stdout1 === void 0 ? void 0 : _this__process_stdout1.on('error', this._errorHandler);
-            (_this__process_stdin = this._process.stdin) === null || _this__process_stdin === void 0 ? void 0 : _this__process_stdin.on('error', this._errorHandler);
-            // Process is already running - resolve immediately
-            resolve();
-        });
+    async start() {
+        if (this._closed) throw new Error('Transport is closed');
+        if (this._started) return;
+        const { stdin, stdout } = this._process;
+        if (!stdin || !stdout) throw new Error('Child process must have stdin and stdout pipes');
+        if (this._process.exitCode !== null || this._process.signalCode !== null) {
+            this.finish();
+            throw new Error('Cannot start transport because the child process has already exited');
+        }
+        this._started = true;
+        this._dataHandler = (chunk)=>{
+            this._readBuffer.append(chunk);
+            this.processReadBuffer();
+        };
+        this._stdinErrorHandler = (error)=>{
+            this._stdinErrorObserved = true;
+            this.retainStdinErrorListenerUntilClose();
+            this.finish(error);
+        };
+        this._stdoutErrorHandler = (error)=>this.finish(error);
+        this._processErrorHandler = (error)=>this.finish(error);
+        this._processCloseHandler = ()=>this.finish();
+        stdout.on('data', this._dataHandler);
+        stdout.on('error', this._stdoutErrorHandler);
+        stdin.on('error', this._stdinErrorHandler);
+        this._process.on('error', this._processErrorHandler);
+        this._process.on('close', this._processCloseHandler);
     }
-    /**
-   * Process buffered messages from stdout.
-   */ processReadBuffer() {
-        while(true){
+    processReadBuffer() {
+        while(!this._closed){
             try {
                 var _this_onmessage, _this;
                 const message = this._readBuffer.readMessage();
-                if (message === null) {
-                    break;
-                }
+                if (message === null) return;
                 (_this_onmessage = (_this = this).onmessage) === null || _this_onmessage === void 0 ? void 0 : _this_onmessage.call(_this, message);
             } catch (error) {
-                var _this_onerror, _this1;
-                (_this_onerror = (_this1 = this).onerror) === null || _this_onerror === void 0 ? void 0 : _this_onerror.call(_this1, error);
+                this.finish(error instanceof Error ? error : new Error(String(error)));
             }
         }
     }
-    /**
-   * Close the transport - close without killing the shared process.
-   * The process is managed by the cluster and may have other active connections.
-   */ async close() {
-        if (this._dataHandler) {
-            var _this__process_stdout;
-            (_this__process_stdout = this._process.stdout) === null || _this__process_stdout === void 0 ? void 0 : _this__process_stdout.off('data', this._dataHandler);
-            this._dataHandler = null;
+    detachListeners() {
+        const { stdout } = this._process;
+        if (this._dataHandler) stdout === null || stdout === void 0 ? void 0 : stdout.off('data', this._dataHandler);
+        if (this._stdoutErrorHandler) stdout === null || stdout === void 0 ? void 0 : stdout.off('error', this._stdoutErrorHandler);
+        this._stdoutErrorHandler = null;
+        if (this._processErrorHandler) this._process.off('error', this._processErrorHandler);
+        if (this._processCloseHandler) this._process.off('close', this._processCloseHandler);
+        this._dataHandler = null;
+        this._processErrorHandler = null;
+        this._processCloseHandler = null;
+        this.detachPendingWriteErrorListener();
+    }
+    detachPendingWriteErrorListener() {
+        const stdin = this._process.stdin;
+        if (!this._closed || this._pendingWrites > 0 || !this._stdinErrorHandler) return;
+        if (this._stdinErrorObserved) {
+            this.retainStdinErrorListenerUntilClose();
+            return;
         }
-        if (this._errorHandler) {
-            var _this__process_stdout1, _this__process_stdin;
-            (_this__process_stdout1 = this._process.stdout) === null || _this__process_stdout1 === void 0 ? void 0 : _this__process_stdout1.off('error', this._errorHandler);
-            (_this__process_stdin = this._process.stdin) === null || _this__process_stdin === void 0 ? void 0 : _this__process_stdin.off('error', this._errorHandler);
-            this._errorHandler = null;
+        stdin === null || stdin === void 0 ? void 0 : stdin.off('error', this._stdinErrorHandler);
+        if (this._stdinCloseHandler) stdin === null || stdin === void 0 ? void 0 : stdin.off('close', this._stdinCloseHandler);
+        this._stdinErrorHandler = null;
+        this._stdinCloseHandler = null;
+    }
+    retainStdinErrorListenerUntilClose() {
+        const stdin = this._process.stdin;
+        const errorHandler = this._stdinErrorHandler;
+        if (!stdin || !errorHandler) return;
+        if (stdin.closed) {
+            stdin.off('error', errorHandler);
+            this._stdinErrorHandler = null;
+            return;
         }
+        if (this._stdinCloseHandler) return;
+        this._stdinCloseHandler = ()=>{
+            stdin.off('error', errorHandler);
+            this._stdinErrorHandler = null;
+            this._stdinCloseHandler = null;
+        };
+        stdin.once('close', this._stdinCloseHandler);
+    }
+    finish(error) {
+        if (this._closed) return;
+        this._closed = true;
+        this.detachListeners();
         this._readBuffer.clear();
+        for (const reject of this._pendingSends)reject(error !== null && error !== void 0 ? error : new Error('Transport is closed'));
+        this._pendingSends.clear();
+        try {
+            var _this_onerror, _this;
+            if (error) (_this_onerror = (_this = this).onerror) === null || _this_onerror === void 0 ? void 0 : _this_onerror.call(_this, error);
+        } finally{
+            var _this_onclose, _this1;
+            (_this_onclose = (_this1 = this).onclose) === null || _this_onclose === void 0 ? void 0 : _this_onclose.call(_this1);
+        }
     }
-    /**
-   * Send a message to the server via stdin.
-   */ async send(message) {
-        return new Promise((resolve, reject)=>{
-            if (!this._process.stdin) {
-                reject(new Error('stdin is not available'));
-                return;
-            }
-            const json = serializeMessage(message);
-            if (this._process.stdin.write(json)) {
-                resolve();
-            } else {
-                this._process.stdin.once('drain', resolve);
+    async close() {
+        this.finish();
+    }
+    async send(message) {
+        if (this._closed) throw new Error('Transport is closed');
+        const stdin = this._process.stdin;
+        if (!stdin || stdin.destroyed || stdin.writableEnded) throw new Error('Child process stdin is not writable');
+        const json = serializeMessage(message);
+        await new Promise((resolve, reject)=>{
+            let settled = false;
+            const settle = (error)=>{
+                if (settled) return;
+                settled = true;
+                this._pendingSends.delete(rejectPending);
+                if (error) reject(error);
+                else resolve();
+            };
+            const rejectPending = (error)=>settle(error);
+            this._pendingSends.add(rejectPending);
+            this._pendingWrites += 1;
+            try {
+                stdin.write(json, (error)=>{
+                    this._pendingWrites -= 1;
+                    if (error) {
+                        this._stdinErrorObserved = true;
+                        this.retainStdinErrorListenerUntilClose();
+                        if (this._closed) settle(error);
+                        else this.finish(error);
+                    } else {
+                        settle();
+                    }
+                    this.detachPendingWriteErrorListener();
+                });
+            } catch (error) {
+                this._pendingWrites -= 1;
+                settle(error instanceof Error ? error : new Error(String(error)));
+                this.detachPendingWriteErrorListener();
             }
         });
     }
     constructor(process){
         this._dataHandler = null;
-        this._errorHandler = null;
+        this._stdinErrorHandler = null;
+        this._stdoutErrorHandler = null;
+        this._stdinCloseHandler = null;
+        this._processErrorHandler = null;
+        this._processCloseHandler = null;
+        this._started = false;
+        this._closed = false;
+        this._pendingSends = new Set();
+        this._pendingWrites = 0;
+        this._stdinErrorObserved = false;
         if (!process.stdin || !process.stdout) {
             throw new Error('Child process must have stdin and stdout pipes');
         }

package/dist/esm/connection/existing-process-transport.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/mcp-z/client/src/connection/existing-process-transport.ts"],"sourcesContent":["/**\n * existing-process-transport.ts\n *\n * MCP transport that wraps an existing child process for stdio communication.\n * Used when connecting to servers already spawned by initServers().\n */\n\nimport type { JSONRPCMessage, Transport } from '@modelcontextprotocol/client';\nimport { ReadBuffer, serializeMessage } from '@modelcontextprotocol/client';\nimport type { ChildProcess } from 'child_process';\n\n/**\n * Transport that communicates with an existing child process via stdio.\n * Does NOT spawn a new process - uses the one provided.\n */\nexport class ExistingProcessTransport implements Transport {\n  private _process: ChildProcess;\n  private _readBuffer: ReadBuffer;\n  private _dataHandler: ((chunk: Buffer) => void) | null = null;\n  private _errorHandler: ((error: Error) => void) | null = null;\n\n  // Transport interface callbacks\n  onclose?: () => void;\n  onerror?: (error: Error) => void;\n  onmessage?: (message: JSONRPCMessage) => void;\n\n  constructor(process: ChildProcess) {\n    if (!process.stdin || !process.stdout) {\n      throw new Error('Child process must have stdin and stdout pipes');\n    }\n\n    this._process = process;\n    this._readBuffer = new ReadBuffer();\n  }\n\n  /**\n   * Start the transport - sets up stdio listeners on existing process.\n   */\n  async start(): Promise<void> {\n    return new Promise((resolve, reject) => {\n      // Listen for process events\n      this._process.on('error', (error) => {\n        this.onerror?.(error);\n        reject(error);\n      });\n\n      this._process.on('close', () => {\n        this.onclose?.();\n      });\n\n      // Create and save data handler for close\n      this._dataHandler = (chunk: Buffer) => {\n        this._readBuffer.append(chunk);\n        this.processReadBuffer();\n      };\n\n      // Create and save error handler for close\n      this._errorHandler = (error: Error) => {\n        this.onerror?.(error);\n      };\n\n      // Listen for stdout data (MCP messages)\n      this._process.stdout?.on('data', this._dataHandler);\n      this._process.stdout?.on('error', this._errorHandler);\n      this._process.stdin?.on('error', this._errorHandler);\n\n      // Process is already running - resolve immediately\n      resolve();\n    });\n  }\n\n  /**\n   * Process buffered messages from stdout.\n   */\n  private processReadBuffer(): void {\n    while (true) {\n      try {\n        const message = this._readBuffer.readMessage();\n        if (message === null) {\n          break;\n        }\n        this.onmessage?.(message);\n      } catch (error) {\n        this.onerror?.(error as Error);\n      }\n    }\n  }\n\n  /**\n   * Close the transport - close without killing the shared process.\n   * The process is managed by the cluster and may have other active connections.\n   */\n  async close(): Promise<void> {\n    if (this._dataHandler) {\n      this._process.stdout?.off('data', this._dataHandler);\n      this._dataHandler = null;\n    }\n\n    if (this._errorHandler) {\n      this._process.stdout?.off('error', this._errorHandler);\n      this._process.stdin?.off('error', this._errorHandler);\n      this._errorHandler = null;\n    }\n\n    this._readBuffer.clear();\n  }\n\n  /**\n   * Send a message to the server via stdin.\n   */\n  async send(message: JSONRPCMessage): Promise<void> {\n    return new Promise((resolve, reject) => {\n      if (!this._process.stdin) {\n        reject(new Error('stdin is not available'));\n        return;\n      }\n\n      const json = serializeMessage(message);\n\n      if (this._process.stdin.write(json)) {\n        resolve();\n      } else {\n        this._process.stdin.once('drain', resolve);\n      }\n    });\n  }\n}\n"],"names":["ReadBuffer","serializeMessage","ExistingProcessTransport","start","Promise","resolve","reject","_process","on","error","onerror","onclose","_dataHandler","chunk","_readBuffer","append","processReadBuffer","_errorHandler","stdout","stdin","message","readMessage","onmessage","close","off","clear","send","Error","json","write","once","process"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/mcp-z/client/src/connection/existing-process-transport.ts"],"sourcesContent":["/**\n * existing-process-transport.ts\n *\n * MCP transport that wraps an existing child process for stdio communication.\n * Used when connecting to already-started processes.\n */\n\nimport type { JSONRPCMessage, Transport } from '@modelcontextprotocol/client';\nimport { ReadBuffer, serializeMessage } from '@modelcontextprotocol/client';\nimport type { ChildProcess } from 'child_process';\n\n/**\n * Transport that communicates with an existing child process via stdio.\n * Closing the transport releases only its listeners; process ownership stays with the registry.\n */\nexport class ExistingProcessTransport implements Transport {\n  private readonly _process: ChildProcess;\n  private readonly _readBuffer: ReadBuffer;\n  private _dataHandler: ((chunk: Buffer) => void) | null = null;\n  private _stdinErrorHandler: ((error: Error) => void) | null = null;\n  private _stdoutErrorHandler: ((error: Error) => void) | null = null;\n  private _stdinCloseHandler: (() => void) | null = null;\n  private _processErrorHandler: ((error: Error) => void) | null = null;\n  private _processCloseHandler: (() => void) | null = null;\n  private _started = false;\n  private _closed = false;\n  private readonly _pendingSends = new Set<(error: Error) => void>();\n  private _pendingWrites = 0;\n  private _stdinErrorObserved = false;\n\n  onclose?: () => void;\n  onerror?: (error: Error) => void;\n  onmessage?: (message: JSONRPCMessage) => void;\n\n  constructor(process: ChildProcess) {\n    if (!process.stdin || !process.stdout) {\n      throw new Error('Child process must have stdin and stdout pipes');\n    }\n\n    this._process = process;\n    this._readBuffer = new ReadBuffer();\n  }\n\n  async start(): Promise<void> {\n    if (this._closed) throw new Error('Transport is closed');\n    if (this._started) return;\n\n    const { stdin, stdout } = this._process;\n    if (!stdin || !stdout) throw new Error('Child process must have stdin and stdout pipes');\n    if (this._process.exitCode !== null || this._process.signalCode !== null) {\n      this.finish();\n      throw new Error('Cannot start transport because the child process has already exited');\n    }\n\n    this._started = true;\n    this._dataHandler = (chunk: Buffer) => {\n      this._readBuffer.append(chunk);\n      this.processReadBuffer();\n    };\n    this._stdinErrorHandler = (error: Error) => {\n      this._stdinErrorObserved = true;\n      this.retainStdinErrorListenerUntilClose();\n      this.finish(error);\n    };\n    this._stdoutErrorHandler = (error: Error) => this.finish(error);\n    this._processErrorHandler = (error: Error) => this.finish(error);\n    this._processCloseHandler = () => this.finish();\n\n    stdout.on('data', this._dataHandler);\n    stdout.on('error', this._stdoutErrorHandler);\n    stdin.on('error', this._stdinErrorHandler);\n    this._process.on('error', this._processErrorHandler);\n    this._process.on('close', this._processCloseHandler);\n  }\n\n  private processReadBuffer(): void {\n    while (!this._closed) {\n      try {\n        const message = this._readBuffer.readMessage();\n        if (message === null) return;\n        this.onmessage?.(message);\n      } catch (error) {\n        this.finish(error instanceof Error ? error : new Error(String(error)));\n      }\n    }\n  }\n\n  private detachListeners(): void {\n    const { stdout } = this._process;\n    if (this._dataHandler) stdout?.off('data', this._dataHandler);\n    if (this._stdoutErrorHandler) stdout?.off('error', this._stdoutErrorHandler);\n    this._stdoutErrorHandler = null;\n    if (this._processErrorHandler) this._process.off('error', this._processErrorHandler);\n    if (this._processCloseHandler) this._process.off('close', this._processCloseHandler);\n    this._dataHandler = null;\n    this._processErrorHandler = null;\n    this._processCloseHandler = null;\n    this.detachPendingWriteErrorListener();\n  }\n\n  private detachPendingWriteErrorListener(): void {\n    const stdin = this._process.stdin;\n    if (!this._closed || this._pendingWrites > 0 || !this._stdinErrorHandler) return;\n\n    if (this._stdinErrorObserved) {\n      this.retainStdinErrorListenerUntilClose();\n      return;\n    }\n\n    stdin?.off('error', this._stdinErrorHandler);\n    if (this._stdinCloseHandler) stdin?.off('close', this._stdinCloseHandler);\n    this._stdinErrorHandler = null;\n    this._stdinCloseHandler = null;\n  }\n\n  private retainStdinErrorListenerUntilClose(): void {\n    const stdin = this._process.stdin;\n    const errorHandler = this._stdinErrorHandler;\n    if (!stdin || !errorHandler) return;\n    if (stdin.closed) {\n      stdin.off('error', errorHandler);\n      this._stdinErrorHandler = null;\n      return;\n    }\n    if (this._stdinCloseHandler) return;\n\n    this._stdinCloseHandler = () => {\n      stdin.off('error', errorHandler);\n      this._stdinErrorHandler = null;\n      this._stdinCloseHandler = null;\n    };\n    stdin.once('close', this._stdinCloseHandler);\n  }\n\n  private finish(error?: Error): void {\n    if (this._closed) return;\n    this._closed = true;\n    this.detachListeners();\n    this._readBuffer.clear();\n\n    for (const reject of this._pendingSends) reject(error ?? new Error('Transport is closed'));\n    this._pendingSends.clear();\n\n    try {\n      if (error) this.onerror?.(error);\n    } finally {\n      this.onclose?.();\n    }\n  }\n\n  async close(): Promise<void> {\n    this.finish();\n  }\n\n  async send(message: JSONRPCMessage): Promise<void> {\n    if (this._closed) throw new Error('Transport is closed');\n    const stdin = this._process.stdin;\n    if (!stdin || stdin.destroyed || stdin.writableEnded) throw new Error('Child process stdin is not writable');\n\n    const json = serializeMessage(message);\n    await new Promise<void>((resolve, reject) => {\n      let settled = false;\n      const settle = (error?: Error | null) => {\n        if (settled) return;\n        settled = true;\n        this._pendingSends.delete(rejectPending);\n        if (error) reject(error);\n        else resolve();\n      };\n      const rejectPending = (error: Error) => settle(error);\n      this._pendingSends.add(rejectPending);\n      this._pendingWrites += 1;\n\n      try {\n        stdin.write(json, (error) => {\n          this._pendingWrites -= 1;\n          if (error) {\n            this._stdinErrorObserved = true;\n            this.retainStdinErrorListenerUntilClose();\n            if (this._closed) settle(error);\n            else this.finish(error);\n          } else {\n            settle();\n          }\n          this.detachPendingWriteErrorListener();\n        });\n      } catch (error) {\n        this._pendingWrites -= 1;\n        settle(error instanceof Error ? error : new Error(String(error)));\n        this.detachPendingWriteErrorListener();\n      }\n    });\n  }\n}\n"],"names":["ReadBuffer","serializeMessage","ExistingProcessTransport","start","_closed","Error","_started","stdin","stdout","_process","exitCode","signalCode","finish","_dataHandler","chunk","_readBuffer","append","processReadBuffer","_stdinErrorHandler","error","_stdinErrorObserved","retainStdinErrorListenerUntilClose","_stdoutErrorHandler","_processErrorHandler","_processCloseHandler","on","message","readMessage","onmessage","String","detachListeners","off","detachPendingWriteErrorListener","_pendingWrites","_stdinCloseHandler","errorHandler","closed","once","clear","reject","_pendingSends","onerror","onclose","close","send","destroyed","writableEnded","json","Promise","resolve","settled","settle","delete","rejectPending","add","write","process","Set"],"mappings":"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"}

package/dist/esm/connection/wait-for-http-ready.d.ts

@@ -12,4 +12,4 @@
  * @returns Promise that resolves when server is ready
  * @throws Error if server doesn't become ready within timeout
  */
-export declare function waitForHttpReady(url: string, timeoutMs?: number): Promise<void>;
+export declare function waitForHttpReady(url: string, timeoutMs?: number, signal?: AbortSignal): Promise<void>;

package/dist/esm/connection/wait-for-http-ready.js

@@ -10,19 +10,20 @@
  * @param timeoutMs - Maximum time to wait in milliseconds (default: 30000)
  * @returns Promise that resolves when server is ready
  * @throws Error if server doesn't become ready within timeout
- */ export async function waitForHttpReady(url, timeoutMs = 30000) {
+ */ export async function waitForHttpReady(url, timeoutMs = 30000, signal) {
     const start = Date.now();
     const maxRetries = Math.ceil(timeoutMs / 100); // Check every 100ms
     for(let i = 0; i < maxRetries; i++){
+        throwIfAborted(signal);
         try {
             // Use HEAD request to check server is responding
-            const response = await fetch(url, {
+            const response = await awaitWithSignal(fetch(url, {
                 method: 'HEAD',
                 headers: {
                     Connection: 'close'
                 },
                 signal: AbortSignal.timeout(500)
-            });
+            }), signal);
             // Server is responding if we get any HTTP status
             if (response.status >= 200 && response.status < 500) {
                 return;
@@ -37,7 +38,21 @@
             }
         }
         // Wait before retry
-        await new Promise((resolve)=>setTimeout(resolve, 100));
+        await awaitWithSignal(new Promise((resolve)=>setTimeout(resolve, 100)), signal);
     }
     throw new Error(`HTTP server ${url} not ready after ${timeoutMs}ms`);
 }
+function throwIfAborted(signal) {
+    if (signal === null || signal === void 0 ? void 0 : signal.aborted) throw signal.reason instanceof Error ? signal.reason : new Error('HTTP readiness check was cancelled');
+}
+function awaitWithSignal(promise, signal) {
+    if (!signal) return promise;
+    if (signal.aborted) return Promise.reject(signal.reason instanceof Error ? signal.reason : new Error('HTTP readiness check was cancelled'));
+    return new Promise((resolve, reject)=>{
+        const onAbort = ()=>reject(signal.reason instanceof Error ? signal.reason : new Error('HTTP readiness check was cancelled'));
+        signal.addEventListener('abort', onAbort, {
+            once: true
+        });
+        promise.then(resolve, reject).finally(()=>signal.removeEventListener('abort', onAbort));
+    });
+}

package/dist/esm/connection/wait-for-http-ready.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/mcp-z/client/src/connection/wait-for-http-ready.ts"],"sourcesContent":["/**\n * wait-for-http-ready.ts\n *\n * Utility for waiting for HTTP servers to become ready.\n */\n\n/**\n * Wait for HTTP server to be ready by checking endpoint accessibility.\n * Used to handle HTTP servers that need time to start listening.\n *\n * @param url - URL to check for server readiness\n * @param timeoutMs - Maximum time to wait in milliseconds (default: 30000)\n * @returns Promise that resolves when server is ready\n * @throws Error if server doesn't become ready within timeout\n */\nexport async function waitForHttpReady(url: string, timeoutMs = 30000): Promise<void> {\n  const start = Date.now();\n  const maxRetries = Math.ceil(timeoutMs / 100); // Check every 100ms\n\n  for (let i = 0; i < maxRetries; i++) {\n    try {\n      // Use HEAD request to check server is responding\n      const response = await fetch(url, {\n        method: 'HEAD',\n        headers: { Connection: 'close' },\n        signal: AbortSignal.timeout(500), // 500ms per attempt\n      });\n\n      // Server is responding if we get any HTTP status\n      if (response.status >= 200 && response.status < 500) {\n        return;\n      }\n\n      // Server error (5xx) - keep trying as it might still be starting\n    } catch (_error) {\n      // Connection refused, timeout, or network error\n      // Server not ready yet, continue polling\n      if (i === maxRetries - 1) {\n        const elapsed = Date.now() - start;\n        throw new Error(`HTTP server ${url} not ready after ${elapsed}ms`);\n      }\n    }\n\n    // Wait before retry\n    await new Promise((resolve) => setTimeout(resolve, 100));\n  }\n\n  throw new Error(`HTTP server ${url} not ready after ${timeoutMs}ms`);\n}\n"],"names":["waitForHttpReady","url","timeoutMs","start","Date","now","maxRetries","Math","ceil","i","response","fetch","method","headers","Connection","signal","AbortSignal","timeout","status","_error","elapsed","Error","Promise","resolve","setTimeout"],"mappings":"AAAA;;;;CAIC,GAED;;;;;;;;CAQC,GACD,OAAO,eAAeA,iBAAiBC,GAAW,EAAEC,YAAY,KAAK;IACnE,MAAMC,QAAQC,KAAKC,GAAG;IACtB,MAAMC,aAAaC,KAAKC,IAAI,CAACN,YAAY,MAAM,oBAAoB;IAEnE,IAAK,IAAIO,IAAI,GAAGA,IAAIH,YAAYG,IAAK;QACnC,IAAI;YACF,iDAAiD;YACjD,MAAMC,WAAW,MAAMC,MAAMV,KAAK;gBAChCW,QAAQ;gBACRC,SAAS;oBAAEC,YAAY;gBAAQ;gBAC/BC,QAAQC,YAAYC,OAAO,CAAC;YAC9B;YAEA,iDAAiD;YACjD,IAAIP,SAASQ,MAAM,IAAI,OAAOR,SAASQ,MAAM,GAAG,KAAK;gBACnD;YACF;QAEA,iEAAiE;QACnE,EAAE,OAAOC,QAAQ;YACf,gDAAgD;YAChD,yCAAyC;YACzC,IAAIV,MAAMH,aAAa,GAAG;gBACxB,MAAMc,UAAUhB,KAAKC,GAAG,KAAKF;gBAC7B,MAAM,IAAIkB,MAAM,CAAC,YAAY,EAAEpB,IAAI,iBAAiB,EAAEmB,QAAQ,EAAE,CAAC;YACnE;QACF;QAEA,oBAAoB;QACpB,MAAM,IAAIE,QAAQ,CAACC,UAAYC,WAAWD,SAAS;IACrD;IAEA,MAAM,IAAIF,MAAM,CAAC,YAAY,EAAEpB,IAAI,iBAAiB,EAAEC,UAAU,EAAE,CAAC;AACrE"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/mcp-z/client/src/connection/wait-for-http-ready.ts"],"sourcesContent":["/**\n * wait-for-http-ready.ts\n *\n * Utility for waiting for HTTP servers to become ready.\n */\n\n/**\n * Wait for HTTP server to be ready by checking endpoint accessibility.\n * Used to handle HTTP servers that need time to start listening.\n *\n * @param url - URL to check for server readiness\n * @param timeoutMs - Maximum time to wait in milliseconds (default: 30000)\n * @returns Promise that resolves when server is ready\n * @throws Error if server doesn't become ready within timeout\n */\nexport async function waitForHttpReady(url: string, timeoutMs = 30000, signal?: AbortSignal): Promise<void> {\n  const start = Date.now();\n  const maxRetries = Math.ceil(timeoutMs / 100); // Check every 100ms\n\n  for (let i = 0; i < maxRetries; i++) {\n    throwIfAborted(signal);\n    try {\n      // Use HEAD request to check server is responding\n      const response = await awaitWithSignal(\n        fetch(url, {\n          method: 'HEAD',\n          headers: { Connection: 'close' },\n          signal: AbortSignal.timeout(500), // 500ms per attempt\n        }),\n        signal\n      );\n\n      // Server is responding if we get any HTTP status\n      if (response.status >= 200 && response.status < 500) {\n        return;\n      }\n\n      // Server error (5xx) - keep trying as it might still be starting\n    } catch (_error) {\n      // Connection refused, timeout, or network error\n      // Server not ready yet, continue polling\n      if (i === maxRetries - 1) {\n        const elapsed = Date.now() - start;\n        throw new Error(`HTTP server ${url} not ready after ${elapsed}ms`);\n      }\n    }\n\n    // Wait before retry\n    await awaitWithSignal(new Promise<void>((resolve) => setTimeout(resolve, 100)), signal);\n  }\n\n  throw new Error(`HTTP server ${url} not ready after ${timeoutMs}ms`);\n}\n\nfunction throwIfAborted(signal?: AbortSignal): void {\n  if (signal?.aborted) throw signal.reason instanceof Error ? signal.reason : new Error('HTTP readiness check was cancelled');\n}\n\nfunction awaitWithSignal<T>(promise: Promise<T>, signal?: AbortSignal): Promise<T> {\n  if (!signal) return promise;\n  if (signal.aborted) return Promise.reject(signal.reason instanceof Error ? signal.reason : new Error('HTTP readiness check was cancelled'));\n  return new Promise<T>((resolve, reject) => {\n    const onAbort = () => reject(signal.reason instanceof Error ? signal.reason : new Error('HTTP readiness check was cancelled'));\n    signal.addEventListener('abort', onAbort, { once: true });\n    promise.then(resolve, reject).finally(() => signal.removeEventListener('abort', onAbort));\n  });\n}\n"],"names":["waitForHttpReady","url","timeoutMs","signal","start","Date","now","maxRetries","Math","ceil","i","throwIfAborted","response","awaitWithSignal","fetch","method","headers","Connection","AbortSignal","timeout","status","_error","elapsed","Error","Promise","resolve","setTimeout","aborted","reason","promise","reject","onAbort","addEventListener","once","then","finally","removeEventListener"],"mappings":"AAAA;;;;CAIC,GAED;;;;;;;;CAQC,GACD,OAAO,eAAeA,iBAAiBC,GAAW,EAAEC,YAAY,KAAK,EAAEC,MAAoB;IACzF,MAAMC,QAAQC,KAAKC,GAAG;IACtB,MAAMC,aAAaC,KAAKC,IAAI,CAACP,YAAY,MAAM,oBAAoB;IAEnE,IAAK,IAAIQ,IAAI,GAAGA,IAAIH,YAAYG,IAAK;QACnCC,eAAeR;QACf,IAAI;YACF,iDAAiD;YACjD,MAAMS,WAAW,MAAMC,gBACrBC,MAAMb,KAAK;gBACTc,QAAQ;gBACRC,SAAS;oBAAEC,YAAY;gBAAQ;gBAC/Bd,QAAQe,YAAYC,OAAO,CAAC;YAC9B,IACAhB;YAGF,iDAAiD;YACjD,IAAIS,SAASQ,MAAM,IAAI,OAAOR,SAASQ,MAAM,GAAG,KAAK;gBACnD;YACF;QAEA,iEAAiE;QACnE,EAAE,OAAOC,QAAQ;YACf,gDAAgD;YAChD,yCAAyC;YACzC,IAAIX,MAAMH,aAAa,GAAG;gBACxB,MAAMe,UAAUjB,KAAKC,GAAG,KAAKF;gBAC7B,MAAM,IAAImB,MAAM,CAAC,YAAY,EAAEtB,IAAI,iBAAiB,EAAEqB,QAAQ,EAAE,CAAC;YACnE;QACF;QAEA,oBAAoB;QACpB,MAAMT,gBAAgB,IAAIW,QAAc,CAACC,UAAYC,WAAWD,SAAS,OAAOtB;IAClF;IAEA,MAAM,IAAIoB,MAAM,CAAC,YAAY,EAAEtB,IAAI,iBAAiB,EAAEC,UAAU,EAAE,CAAC;AACrE;AAEA,SAASS,eAAeR,MAAoB;IAC1C,IAAIA,mBAAAA,6BAAAA,OAAQwB,OAAO,EAAE,MAAMxB,OAAOyB,MAAM,YAAYL,QAAQpB,OAAOyB,MAAM,GAAG,IAAIL,MAAM;AACxF;AAEA,SAASV,gBAAmBgB,OAAmB,EAAE1B,MAAoB;IACnE,IAAI,CAACA,QAAQ,OAAO0B;IACpB,IAAI1B,OAAOwB,OAAO,EAAE,OAAOH,QAAQM,MAAM,CAAC3B,OAAOyB,MAAM,YAAYL,QAAQpB,OAAOyB,MAAM,GAAG,IAAIL,MAAM;IACrG,OAAO,IAAIC,QAAW,CAACC,SAASK;QAC9B,MAAMC,UAAU,IAAMD,OAAO3B,OAAOyB,MAAM,YAAYL,QAAQpB,OAAOyB,MAAM,GAAG,IAAIL,MAAM;QACxFpB,OAAO6B,gBAAgB,CAAC,SAASD,SAAS;YAAEE,MAAM;QAAK;QACvDJ,QAAQK,IAAI,CAACT,SAASK,QAAQK,OAAO,CAAC,IAAMhC,OAAOiC,mBAAmB,CAAC,SAASL;IAClF;AACF"}

package/dist/esm/dcr/dcr-authenticator.d.ts

@@ -54,7 +54,7 @@ export declare class DcrAuthenticator {
      *   capabilities
      * );
      */
-    ensureAuthenticated(mcpServerUrl: string, capabilities: AuthCapabilities): Promise<TokenSet>;
+    ensureAuthenticated(mcpServerUrl: string, capabilities: AuthCapabilities, signal?: AbortSignal): Promise<TokenSet>;
     /**
      * The three things a server URL is used for here, kept apart on purpose.
      *