@mcp-z/client 2.2.4 → 2.3.0

package/dist/esm/spawn/spawn-servers.js

@@ -4,6 +4,7 @@
  * Supports stdio, http, and ws transports.
  * Implements Claude Code-compatible configuration with start extension support.
  */ import * as fs from 'fs';
+import * as path from 'path';
 import * as process from 'process';
 import { decorateClient } from '../client-helpers.js';
 import { validateServers } from '../config/validate-config.js';
@@ -11,6 +12,34 @@ import { connectMcpClient } from '../connection/connect-client.js';
 import { buildCapabilityIndex, searchCapabilities as executeCapabilitySearch } from '../search/index.js';
 import { logger } from '../utils/logger.js';
 import { spawnProcess } from './spawn-server.js';
+const DEFAULT_SHUTDOWN_TIMEOUT_MS = 5000;
+function asError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+function withCause(message, cause) {
+    return new Error(message, {
+        cause
+    });
+}
+async function settleWithin(promise, timeoutMs) {
+    let timer;
+    return Promise.race([
+        promise.then((value)=>({
+                settled: true,
+                value
+            }), (error)=>({
+                settled: true,
+                error
+            })),
+        new Promise((resolve)=>{
+            timer = setTimeout(()=>resolve({
+                    settled: false
+                }), timeoutMs);
+        })
+    ]).finally(()=>{
+        if (timer) clearTimeout(timer);
+    });
+}
 /**
  * Infer transport type: explicit type > URL protocol > default 'stdio'
  */ function inferTransportType(config) {
@@ -36,6 +65,30 @@ import { spawnProcess } from './spawn-server.js';
     }
     return filtered;
 }
+function getStartSpawnConfig(start, transportType, baseEnv) {
+    const stop = start.stop && (transportType === 'http' || transportType === 'sse-ide') ? {
+        ...start.stop,
+        cwd: start.stop.cwd,
+        env: filterEnv({
+            ...baseEnv,
+            ...start.env,
+            ...start.stop.env
+        })
+    } : undefined;
+    return {
+        shouldSpawn: true,
+        command: start.command,
+        args: start.args || [],
+        env: filterEnv({
+            ...baseEnv,
+            ...start.env
+        }),
+        cwd: start.cwd,
+        ...stop && {
+            stop
+        }
+    };
+}
 /**
  * Determine spawn behavior based on dialects and config structure.
  *
@@ -51,6 +104,11 @@ import { spawnProcess } from './spawn-server.js';
  * When baseEnv is not provided, process.env is used as the base.
  */ function getSpawnConfig(entry, dialects, baseEnv) {
     const transportType = inferTransportType(entry);
+    if (dialects.length === 0) {
+        return {
+            shouldSpawn: false
+        };
+    }
     const hasServers = dialects.includes('servers');
     const hasStart = dialects.includes('start');
     // If only 'servers' dialect: Claude Code compatible (ignore start blocks, stdio only)
@@ -73,15 +131,7 @@ import { spawnProcess } from './spawn-server.js';
     // If only 'start' dialect: Only spawn servers with start blocks
     if (hasStart && !hasServers) {
         if (entry.start) {
-            return {
-                shouldSpawn: true,
-                command: entry.start.command,
-                args: entry.start.args || [],
-                env: filterEnv({
-                    ...baseEnv,
-                    ...entry.start.env
-                })
-            };
+            return getStartSpawnConfig(entry.start, transportType, baseEnv);
         }
         return {
             shouldSpawn: false
@@ -90,15 +140,7 @@ import { spawnProcess } from './spawn-server.js';
     // Both dialects: Spawn both start blocks and stdio servers
     // Priority: start blocks first, then stdio
     if (entry.start) {
-        return {
-            shouldSpawn: true,
-            command: entry.start.command,
-            args: entry.start.args || [],
-            env: filterEnv({
-                ...baseEnv,
-                ...entry.start.env
-            })
-        };
+        return getStartSpawnConfig(entry.start, transportType, baseEnv);
     }
     if (transportType === 'stdio' && entry.command) {
         return {
@@ -191,6 +233,20 @@ import { spawnProcess } from './spawn-server.js';
     const servers = new Map();
     const clients = new Set();
     const sharedStdioClients = new Map();
+    const pendingConnects = new Set();
+    const closeAbortController = new AbortController();
+    const clientClosePromises = new WeakMap();
+    const closeRaceErrors = [];
+    let lifecycleState = 'open';
+    let closePromise;
+    const closeClientOnce = (client)=>{
+        let pending = clientClosePromises.get(client);
+        if (!pending) {
+            pending = Promise.resolve().then(()=>client.close());
+            clientClosePromises.set(client, pending);
+        }
+        return pending;
+    };
     // Start each server in the configuration
     for (const [name, entry] of Object.entries(serversConfig)){
         // Infer transport type from config
@@ -212,8 +268,7 @@ import { spawnProcess } from './spawn-server.js';
             if (!spawnConfig.command) {
                 throw new Error(`Server "${name}" missing command field`);
             }
-            // All servers use the same working directory (cwd from options)
-            const resolvedCwd = cwd;
+            const resolvedCwd = spawnConfig.cwd ? path.resolve(cwd, spawnConfig.cwd) : cwd;
             // Start the server
             logger.info(`[${name}] starting ${transportType} server (${spawnConfig.command} ${(spawnConfig.args || []).join(' ')})`);
             // stdio servers need 'pipe' for MCP communication over stdin/stdout
@@ -229,6 +284,13 @@ import { spawnProcess } from './spawn-server.js';
                 ...spawnConfig.env && Object.keys(spawnConfig.env).length > 0 && {
                     env: spawnConfig.env
                 },
+                inheritEnv: (options === null || options === void 0 ? void 0 : options.env) === undefined,
+                ...spawnConfig.stop && {
+                    stop: {
+                        ...spawnConfig.stop,
+                        cwd: spawnConfig.stop.cwd ? path.resolve(resolvedCwd, spawnConfig.stop.cwd) : resolvedCwd
+                    }
+                },
                 stdio
             });
             // Add server to registry (starting is fast, readiness is lazy)
@@ -238,8 +300,8 @@ import { spawnProcess } from './spawn-server.js';
             logger.info(`[${name}] start ERROR: ${e instanceof Error ? e.message : String(e)}`);
         }
     }
-    // Create connect function that tracks clients
-    const connect = async (name, options)=>{
+    // Connect internally, then track each returned lease for registry shutdown.
+    const connectInternal = async (name, options)=>{
         const serverEntry = serversConfig[name];
         if (!serverEntry) {
             const available = Object.keys(serversConfig).join(', ');
@@ -263,7 +325,10 @@ import { spawnProcess } from './spawn-server.js';
                             config: serversConfig,
                             servers
                         };
-                        const rawClient = await connectMcpClient(registryLike, name, options);
+                        const rawClient = await connectMcpClient(registryLike, name, {
+                            ...options,
+                            signal: closeAbortController.signal
+                        });
                         const decorated = decorateClient(rawClient, {
                             serverName: name
                         });
@@ -281,20 +346,24 @@ import { spawnProcess } from './spawn-server.js';
                 throw new Error(`Failed to connect to stdio server '${name}'`);
             }
             entry.refs += 1;
-            let released = false;
+            let releasePromise;
             let lease;
             lease = new Proxy(entry.client, {
                 get (target, prop) {
                     if (prop === 'close') {
-                        return async ()=>{
-                            if (released) return;
-                            released = true;
-                            clients.delete(lease);
-                            entry.refs = Math.max(0, entry.refs - 1);
-                            if (entry.refs === 0) {
-                                sharedStdioClients.delete(name);
-                                await target.close();
-                            }
+                        return ()=>{
+                            releasePromise !== null && releasePromise !== void 0 ? releasePromise : releasePromise = (async ()=>{
+                                entry.refs = Math.max(0, entry.refs - 1);
+                                try {
+                                    if (entry.refs === 0) {
+                                        sharedStdioClients.delete(name);
+                                        await target.close();
+                                    }
+                                } finally{
+                                    clients.delete(lease);
+                                }
+                            })();
+                            return releasePromise;
                         };
                     }
                     const value = Reflect.get(target, prop, target);
@@ -312,43 +381,99 @@ import { spawnProcess } from './spawn-server.js';
             config: serversConfig,
             servers
         };
-        const rawClient = await connectMcpClient(registryLike, name, options);
+        const rawClient = await connectMcpClient(registryLike, name, {
+            ...options,
+            signal: closeAbortController.signal
+        });
         const decorated = decorateClient(rawClient, {
             serverName: name
         });
         clients.add(decorated);
         return decorated;
     };
-    // Create close function that stops all clients and servers
-    const close = async (signal = 'SIGINT', opts = {})=>{
+    const connect = (name, options)=>{
+        if (lifecycleState !== 'open') {
+            return Promise.reject(new Error(`Cannot connect to server '${name}': registry is ${lifecycleState}`));
+        }
+        const pending = connectInternal(name, options).then(async (client)=>{
+            if (lifecycleState === 'open') return client;
+            const result = await settleWithin(closeClientOnce(client), DEFAULT_SHUTDOWN_TIMEOUT_MS);
+            if (!result.settled) closeRaceErrors.push(new Error(`Client for server '${name}' did not close within ${DEFAULT_SHUTDOWN_TIMEOUT_MS}ms after a connection raced registry shutdown`));
+            else if ('error' in result) closeRaceErrors.push(withCause(`Failed to close server '${name}' after a connection raced registry shutdown`, asError(result.error)));
+            throw new Error(`Connection to server '${name}' completed while the registry was closing`);
+        });
+        pendingConnects.add(pending);
+        void pending.then(()=>pendingConnects.delete(pending), ()=>pendingConnects.delete(pending));
+        return pending;
+    };
+    const closeAll = async (signal, opts)=>{
+        var _opts_timeoutMs;
         logger.info(`[registry] closing (${signal})`);
-        // First, close all tracked clients
-        const clientClosePromises = Array.from(clients).map(async (client)=>{
-            try {
-                await client.close();
-            } catch  {
-            // Ignore errors during client close
+        const timeoutMs = (_opts_timeoutMs = opts.timeoutMs) !== null && _opts_timeoutMs !== void 0 ? _opts_timeoutMs : DEFAULT_SHUTDOWN_TIMEOUT_MS;
+        const errors = [];
+        closeAbortController.abort(new Error('Server registry is closing'));
+        const pendingResult = await settleWithin(Promise.allSettled(Array.from(pendingConnects)), timeoutMs);
+        if (!pendingResult.settled) {
+            errors.push(new Error(`In-flight server connections did not settle within ${timeoutMs}ms after cancellation`));
+        }
+        errors.push(...closeRaceErrors);
+        // Client close can hang independently; bound it so every owned server still gets cleanup.
+        const clientEntries = Array.from(clients);
+        const clientResults = await Promise.all(clientEntries.map(async (client)=>({
+                client,
+                result: await settleWithin(closeClientOnce(client), timeoutMs)
+            })));
+        for (const { client, result } of clientResults){
+            if (!result.settled) {
+                errors.push(new Error(`Client${client.serverName ? ` for server '${client.serverName}'` : ''} did not close within ${timeoutMs}ms`));
+            } else if ('error' in result) {
+                errors.push(withCause(`Failed to close client${client.serverName ? ` for server '${client.serverName}'` : ''}: ${asError(result.error).message}`, asError(result.error)));
             }
-        });
-        await Promise.all(clientClosePromises);
+        }
         clients.clear();
-        // Then close all server processes
-        if (servers.size === 0) {
-            return {
-                timedOut: false,
-                killedCount: 0
-            };
+        sharedStdioClients.clear();
+        // Server teardown runs even when pending connects or client closes failed.
+        const serverEntries = Array.from(servers.entries());
+        const serverResults = await Promise.all(serverEntries.map(async ([name, server])=>{
+            try {
+                return {
+                    name,
+                    result: await server.close(signal, opts)
+                };
+            } catch (error) {
+                return {
+                    name,
+                    error: asError(error)
+                };
+            }
+        }));
+        let timedOut = false;
+        let killedCount = 0;
+        for (const result of serverResults){
+            if ('error' in result && result.error !== undefined) {
+                errors.push(withCause(`Failed to close server '${result.name}': ${result.error.message}`, result.error));
+            } else if ('result' in result) {
+                timedOut || (timedOut = result.result.timedOut);
+                if (result.result.killed) killedCount += 1;
+            }
+        }
+        lifecycleState = 'closed';
+        if (errors.length > 0) {
+            const details = errors.map((error)=>error.message).join('; ');
+            throw new AggregateError(errors, `Registry shutdown completed with ${errors.length} cleanup failure(s): ${details}`);
         }
-        // Close all servers in parallel
-        const closeResults = await Promise.all(Array.from(servers.values()).map((server)=>server.close(signal, opts)));
-        // Check if any timed out and count how many were force-killed
-        const timedOut = closeResults.some((result)=>result.timedOut);
-        const killedCount = closeResults.filter((result)=>result.killed).length;
         return {
             timedOut,
             killedCount
         };
     };
+    const close = (signal = 'SIGINT', opts = {})=>{
+        if (!closePromise) {
+            lifecycleState = 'closing';
+            closePromise = closeAll(signal, opts);
+        }
+        return closePromise;
+    };
     const searchFromRegistry = async (query, options = {})=>{
         var _options_servers;
         const requestedServers = (_options_servers = options.servers) !== null && _options_servers !== void 0 ? _options_servers : Object.keys(serversConfig);

package/dist/esm/spawn/spawn-servers.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/mcp-z/client/src/spawn/spawn-servers.ts"],"sourcesContent":["/**\n * High-level multi-server registry management.\n * Starts multiple servers from a servers configuration object.\n * Supports stdio, http, and ws transports.\n * Implements Claude Code-compatible configuration with start extension support.\n */\n\nimport * as fs from 'fs';\nimport * as process from 'process';\nimport { decorateClient, type ManagedClient } from '../client-helpers.ts';\nimport { validateServers } from '../config/validate-config.ts';\nimport { connectMcpClient } from '../connection/connect-client.ts';\nimport { buildCapabilityIndex, type CapabilityClient, searchCapabilities as executeCapabilitySearch, type SearchOptions, type SearchResponse } from '../search/index.ts';\nimport type { McpServerEntry, TransportType } from '../types.ts';\nimport { logger } from '../utils/logger.ts';\nimport { type ServerProcess, spawnProcess } from './spawn-server.ts';\n\n/**\n * Servers configuration type - a map of server names to their configurations.\n */\nexport type ServersConfig = Record<string, McpServerEntry>;\n\n/**\n * Dialect for server spawning.\n *\n * - 'servers': Spawn stdio servers (Claude Code compatible)\n * - 'start': Spawn HTTP servers with start blocks\n */\nexport type Dialect = 'servers' | 'start';\n\n/**\n * Options for creating a server registry.\n */\nexport interface CreateServerRegistryOptions {\n  /** Working directory for spawned processes (default: process.cwd()) */\n  cwd?: string;\n\n  /**\n   * Base environment for all servers.\n   * If provided, process.env is NOT included (caller has full control).\n   * If omitted, process.env is used as the base (default behavior).\n   */\n  env?: Record<string, string>;\n\n  /**\n   * Dialects controlling which servers to spawn.\n   * - ['servers']: Spawn stdio servers only (default, Claude Code compatible)\n   * - ['start']: Only spawn servers with start blocks (HTTP servers)\n   * - ['servers', 'start']: Spawn both stdio servers and start blocks\n   * @default ['servers']\n   */\n  dialects?: Dialect[];\n}\n\n/**\n * Result of closing the registry.\n */\nexport interface CloseResult {\n  /** Whether any process timed out during shutdown */\n  timedOut: boolean;\n  /** Number of processes that were force-killed */\n  killedCount: number;\n}\n\n/**\n * Infer transport type: explicit type > URL protocol > default 'stdio'\n */\nfunction inferTransportType(config: { type?: TransportType; url?: string }): TransportType {\n  if (config.type) {\n    return config.type;\n  }\n\n  if (config.url) {\n    const url = new URL(config.url);\n    if (url.protocol === 'http:' || url.protocol === 'https:') {\n      return 'http';\n    }\n  }\n\n  return 'stdio';\n}\n\n/**\n * Spawn configuration result (internal)\n */\ninterface SpawnConfig {\n  shouldSpawn: boolean;\n  command?: string;\n  args?: string[];\n  env?: Record<string, string>;\n}\n\n/**\n * Helper to filter undefined values from environment\n */\nfunction filterEnv(env: Record<string, string | undefined>): Record<string, string> {\n  const filtered: Record<string, string> = {};\n  for (const [key, value] of Object.entries(env)) {\n    if (value !== undefined) {\n      filtered[key] = value;\n    }\n  }\n  return filtered;\n}\n\n/**\n * Determine spawn behavior based on dialects and config structure.\n *\n * Dialects:\n * - ['servers'] (default): Claude Code compatible - ignores start blocks, stdio only\n * - ['start']: Only spawn servers with start blocks (HTTP server testing)\n * - ['servers', 'start']: Spawn both start blocks and stdio servers (full MCP-Z extension support)\n *\n * Environment merging (when baseEnv provided):\n * - HTTP servers (start block): { ...baseEnv, ...entry.start.env }\n * - Stdio servers: { ...baseEnv, ...entry.env }\n *\n * When baseEnv is not provided, process.env is used as the base.\n */\nfunction getSpawnConfig(entry: McpServerEntry, dialects: Dialect[], baseEnv: Record<string, string | undefined>): SpawnConfig {\n  const transportType = inferTransportType(entry);\n  const hasServers = dialects.includes('servers');\n  const hasStart = dialects.includes('start');\n\n  // If only 'servers' dialect: Claude Code compatible (ignore start blocks, stdio only)\n  if (hasServers && !hasStart) {\n    if (transportType === 'stdio' && entry.command) {\n      return {\n        shouldSpawn: true,\n        command: entry.command,\n        args: entry.args || [],\n        env: filterEnv({ ...baseEnv, ...entry.env }),\n      };\n    }\n    return { shouldSpawn: false };\n  }\n\n  // If only 'start' dialect: Only spawn servers with start blocks\n  if (hasStart && !hasServers) {\n    if (entry.start) {\n      return {\n        shouldSpawn: true,\n        command: entry.start.command,\n        args: entry.start.args || [],\n        env: filterEnv({ ...baseEnv, ...entry.start.env }),\n      };\n    }\n    return { shouldSpawn: false };\n  }\n\n  // Both dialects: Spawn both start blocks and stdio servers\n  // Priority: start blocks first, then stdio\n  if (entry.start) {\n    return {\n      shouldSpawn: true,\n      command: entry.start.command,\n      args: entry.start.args || [],\n      env: filterEnv({ ...baseEnv, ...entry.start.env }),\n    };\n  }\n\n  if (transportType === 'stdio' && entry.command) {\n    return {\n      shouldSpawn: true,\n      command: entry.command,\n      args: entry.args || [],\n      env: filterEnv({ ...baseEnv, ...entry.env }),\n    };\n  }\n\n  return { shouldSpawn: false };\n}\n\n/**\n * A registry of spawned MCP servers with connection management.\n * Provides access to individual server handles, connection management, and collection-wide close.\n */\ntype RegistryConnectOptions = Parameters<typeof connectMcpClient>[2];\n\nexport interface ServerRegistry {\n  /**\n   * The resolved servers configuration that was used.\n   * Useful for debugging and understanding what was started.\n   */\n  config: ServersConfig;\n\n  /**\n   * Map of server name to server process handle.\n   * @hidden\n   */\n  servers: Map<string, ServerProcess>;\n\n  /**\n   * Set of connected clients tracked by this registry.\n   * Automatically populated when using registry.connect().\n   */\n  clients: Set<ManagedClient>;\n\n  /**\n   * Connect to a server by name.\n   * The connected client is automatically tracked for close.\n   *\n   * @param name - Server name from configuration\n   * @returns Connected MCP SDK Client\n   */\n  connect: (name: string, options?: RegistryConnectOptions) => Promise<ManagedClient>;\n\n  /**\n   * Close all clients and servers gracefully.\n   * First closes all tracked clients, then sends the specified signal to all server processes.\n   *\n   * @param signal - Signal to send to processes (default: SIGINT)\n   * @param opts - Options including timeout\n   * @returns Promise resolving to whether any process timed out and how many were force-killed\n   */\n  close: (signal?: NodeJS.Signals, opts?: { timeoutMs?: number }) => Promise<CloseResult>;\n\n  /**\n   * Search indexed capabilities across all currently connected clients.\n   * Requires at least one connected client; respects SearchOptions filters.\n   */\n  searchCapabilities: (query: string, options?: SearchOptions) => Promise<SearchResponse>;\n\n  /**\n   * Support for `await using` pattern (automatic close).\n   */\n  [Symbol.asyncDispose]: () => Promise<void>;\n}\n\n/**\n * Create a registry of MCP servers from configuration.\n *\n * **Fast start**: Returns immediately after processes are created.\n * Use `registry.connect()` for lazy MCP connection.\n *\n * @param serversConfig - Map of server names to their configurations\n * @param options - Options for registry creation\n * @param options.cwd - Working directory for spawned processes (default: process.cwd())\n * @param options.env - Base environment for all servers. If provided, process.env is NOT included.\n *                      If omitted, process.env is used as the base (default behavior).\n * @param options.dialects - Dialects controlling which servers to spawn (default: ['servers'])\n *   - ['servers']: Spawn stdio servers only (Claude Code compatible)\n *   - ['start']: Only spawn servers with start blocks (HTTP servers)\n *   - ['servers', 'start']: Spawn both stdio servers and start blocks\n * @returns ServerRegistry instance with config, server map, connect method, and close function\n *\n * @example\n * // Fast server start (does NOT wait for readiness)\n * const registry = createServerRegistry({\n *   'echo': { command: 'node', args: ['server.ts'] },\n * });\n *\n * // Connect when needed (waits for MCP handshake)\n * const client = await registry.connect('echo');\n *\n * // Cleanup (closes all clients AND processes)\n * await registry.close();\n *\n * @example\n * // Start HTTP servers with start blocks\n * const registry = createServerRegistry(\n *   {\n *     'http-server': {\n *       url: 'http://localhost:8080/mcp',\n *       start: { command: 'node', args: ['http.ts', '--port', '8080'] }\n *     },\n *   },\n *   { dialects: ['start'] }\n * );\n *\n * @example\n * // Using await using for automatic close\n * await using registry = createServerRegistry(config);\n * const client = await registry.connect('server');\n * // Auto-disposed when scope exits\n */\nexport function createServerRegistry(serversConfig: ServersConfig, options?: CreateServerRegistryOptions): ServerRegistry {\n  const cwd = options?.cwd ?? process.cwd();\n  const dialects = options?.dialects ?? ['servers'];\n\n  // Determine base environment:\n  // - If options.env provided, use it (process.env NOT included)\n  // - If options.env omitted, use process.env as base\n  const baseEnv: Record<string, string | undefined> = options?.env ?? process.env;\n\n  // Validate working directory exists (fail fast for configuration errors)\n  if (!fs.existsSync(cwd)) {\n    throw new Error(`Cannot start servers: working directory '${cwd}' does not exist`);\n  }\n\n  // Validate configuration (fail fast with clear errors)\n  const validation = validateServers(serversConfig);\n  if (!validation.valid) {\n    throw new Error(`Invalid servers configuration:\\n${validation.errors?.join('\\n') ?? 'Unknown validation error'}`);\n  }\n\n  // Log validation warnings (non-blocking)\n  if (validation.warnings && validation.warnings.length > 0) {\n    for (const warning of validation.warnings) {\n      logger.warn(warning);\n    }\n  }\n\n  const servers = new Map<string, ServerProcess>();\n  const clients = new Set<ManagedClient>();\n  const sharedStdioClients = new Map<string, { client?: ManagedClient; connecting?: Promise<ManagedClient>; refs: number }>();\n\n  // Start each server in the configuration\n  for (const [name, entry] of Object.entries(serversConfig)) {\n    // Infer transport type from config\n    const transportType = inferTransportType(entry);\n\n    // Determine spawn behavior based on dialects\n    const spawnConfig = getSpawnConfig(entry, dialects, baseEnv);\n\n    // Check if we should spawn this server\n    if (!spawnConfig.shouldSpawn) {\n      // External server - just log, no spawn needed\n      if (entry.url) {\n        logger.info(`[${name}] external ${transportType} server (url: ${entry.url})`);\n      } else {\n        logger.warn(`[${name}] skipping: no spawn configuration (missing start or command) and no url for external server`);\n      }\n      continue;\n    }\n\n    try {\n      // Validate spawn config\n      if (!spawnConfig.command) {\n        throw new Error(`Server \"${name}\" missing command field`);\n      }\n\n      // All servers use the same working directory (cwd from options)\n      const resolvedCwd = cwd;\n\n      // Start the server\n      logger.info(`[${name}] starting ${transportType} server (${spawnConfig.command} ${(spawnConfig.args || []).join(' ')})`);\n\n      // stdio servers need 'pipe' for MCP communication over stdin/stdout\n      // network servers use 'inherit' so we see their logs\n      const stdio = transportType === 'stdio' ? 'pipe' : 'inherit';\n\n      const handle = spawnProcess({\n        name,\n        command: spawnConfig.command,\n        ...(spawnConfig.args !== undefined && { args: spawnConfig.args }),\n        cwd: resolvedCwd,\n        ...(spawnConfig.env && Object.keys(spawnConfig.env).length > 0 && { env: spawnConfig.env }),\n        stdio,\n      });\n\n      // Add server to registry (starting is fast, readiness is lazy)\n      servers.set(name, handle);\n      logger.info(`[${name}] started successfully`);\n    } catch (e) {\n      logger.info(`[${name}] start ERROR: ${e instanceof Error ? e.message : String(e)}`);\n    }\n  }\n\n  // Create connect function that tracks clients\n  const connect = async (name: string, options?: RegistryConnectOptions): Promise<ManagedClient> => {\n    const serverEntry = serversConfig[name];\n    if (!serverEntry) {\n      const available = Object.keys(serversConfig).join(', ');\n      throw new Error(`Server '${name}' not found in config. Available servers: ${available || 'none'}`);\n    }\n\n    const transportType = inferTransportType(serverEntry);\n\n    if (transportType === 'stdio') {\n      // Stdio is a single logical connection; reuse one client and lease references.\n      let entry = sharedStdioClients.get(name);\n      if (!entry) {\n        entry = { refs: 0 };\n        sharedStdioClients.set(name, entry);\n      }\n\n      if (!entry.client) {\n        if (!entry.connecting) {\n          entry.connecting = (async () => {\n            // Pass minimal RegistryLike object to connectMcpClient\n            const registryLike = { config: serversConfig, servers };\n            const rawClient = await connectMcpClient(registryLike, name, options);\n            const decorated = decorateClient(rawClient, { serverName: name });\n            entry.client = decorated;\n            entry.connecting = undefined;\n            return decorated;\n          })().catch((error) => {\n            sharedStdioClients.delete(name);\n            throw error;\n          });\n        }\n\n        await entry.connecting;\n      }\n\n      if (!entry.client) {\n        throw new Error(`Failed to connect to stdio server '${name}'`);\n      }\n\n      entry.refs += 1;\n      let released = false;\n      let lease: ManagedClient;\n\n      lease = new Proxy(entry.client, {\n        get(target, prop) {\n          if (prop === 'close') {\n            return async () => {\n              if (released) return;\n              released = true;\n              clients.delete(lease);\n              entry.refs = Math.max(0, entry.refs - 1);\n              if (entry.refs === 0) {\n                sharedStdioClients.delete(name);\n                await target.close();\n              }\n            };\n          }\n\n          const value = Reflect.get(target, prop, target) as unknown;\n          if (typeof value === 'function') {\n            return (value as (...args: unknown[]) => unknown).bind(target);\n          }\n          return value;\n        },\n      }) as ManagedClient;\n\n      clients.add(lease);\n      return lease;\n    }\n\n    // Pass minimal RegistryLike object to connectMcpClient\n    const registryLike = { config: serversConfig, servers };\n    const rawClient = await connectMcpClient(registryLike, name, options);\n    const decorated = decorateClient(rawClient, { serverName: name });\n    clients.add(decorated);\n    return decorated;\n  };\n\n  // Create close function that stops all clients and servers\n  const close = async (signal: NodeJS.Signals = 'SIGINT', opts: { timeoutMs?: number } = {}): Promise<CloseResult> => {\n    logger.info(`[registry] closing (${signal})`);\n\n    // First, close all tracked clients\n    const clientClosePromises = Array.from(clients).map(async (client) => {\n      try {\n        await client.close();\n      } catch {\n        // Ignore errors during client close\n      }\n    });\n    await Promise.all(clientClosePromises);\n    clients.clear();\n\n    // Then close all server processes\n    if (servers.size === 0) {\n      return { timedOut: false, killedCount: 0 };\n    }\n\n    // Close all servers in parallel\n    const closeResults = await Promise.all(Array.from(servers.values()).map((server) => server.close(signal, opts)));\n\n    // Check if any timed out and count how many were force-killed\n    const timedOut = closeResults.some((result) => result.timedOut);\n    const killedCount = closeResults.filter((result) => result.killed).length;\n\n    return { timedOut, killedCount };\n  };\n\n  const searchFromRegistry = async (query: string, options: SearchOptions = {}): Promise<SearchResponse> => {\n    const requestedServers = options.servers ?? Object.keys(serversConfig);\n    if (requestedServers.length === 0) {\n      throw new Error('Cannot search capabilities: registry has no configured servers');\n    }\n\n    const unknownServers = requestedServers.filter((name) => !(name in serversConfig));\n    if (unknownServers.length > 0) {\n      throw new Error(`Cannot search capabilities: unknown server(s) [${unknownServers.join(', ')}]`);\n    }\n\n    const capabilityClients = new Map<string, CapabilityClient>();\n    const failures: Array<{ server: string; reason: string }> = [];\n\n    const ensureClient = async (serverName: string): Promise<ManagedClient> => {\n      for (const client of clients) {\n        if (client.serverName === serverName) {\n          return client;\n        }\n      }\n      return connect(serverName);\n    };\n\n    await Promise.all(\n      requestedServers.map(async (serverName) => {\n        try {\n          const managed = await ensureClient(serverName);\n          capabilityClients.set(serverName, managed.nativeClient);\n        } catch (error) {\n          failures.push({\n            server: serverName,\n            reason: error instanceof Error ? error.message : String(error),\n          });\n        }\n      })\n    );\n\n    if (capabilityClients.size === 0) {\n      const failureDetails = failures.length > 0 ? ` Connection failures: ${failures.map((f) => `${f.server} (${f.reason})`).join('; ')}` : '';\n      throw new Error(`Cannot search capabilities: unable to connect to any requested servers.${failureDetails}`);\n    }\n\n    if (failures.length > 0) {\n      throw new Error(`Cannot search capabilities: failed to connect to server(s) [${failures.map((f) => f.server).join(', ')}]. Reasons: ${failures.map((f) => `${f.server}: ${f.reason}`).join('; ')}`);\n    }\n\n    const index = await buildCapabilityIndex(capabilityClients);\n    return executeCapabilitySearch(index, query, options);\n  };\n\n  // Async dispose for `await using` pattern\n  const asyncDispose = async (): Promise<void> => {\n    await close();\n  };\n\n  return {\n    config: serversConfig,\n    servers,\n    clients,\n    connect,\n    close,\n    searchCapabilities: searchFromRegistry,\n    [Symbol.asyncDispose]: asyncDispose,\n  };\n}\n"],"names":["fs","process","decorateClient","validateServers","connectMcpClient","buildCapabilityIndex","searchCapabilities","executeCapabilitySearch","logger","spawnProcess","inferTransportType","config","type","url","URL","protocol","filterEnv","env","filtered","key","value","Object","entries","undefined","getSpawnConfig","entry","dialects","baseEnv","transportType","hasServers","includes","hasStart","command","shouldSpawn","args","start","createServerRegistry","serversConfig","options","cwd","existsSync","Error","validation","valid","errors","join","warnings","length","warning","warn","servers","Map","clients","Set","sharedStdioClients","name","spawnConfig","info","resolvedCwd","stdio","handle","keys","set","e","message","String","connect","serverEntry","available","get","refs","client","connecting","registryLike","rawClient","decorated","serverName","catch","error","delete","released","lease","Proxy","target","prop","Math","max","close","Reflect","bind","add","signal","opts","clientClosePromises","Array","from","map","Promise","all","clear","size","timedOut","killedCount","closeResults","values","server","some","result","filter","killed","searchFromRegistry","query","requestedServers","unknownServers","capabilityClients","failures","ensureClient","managed","nativeClient","push","reason","failureDetails","f","index","asyncDispose","Symbol"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/mcp-z/client/src/spawn/spawn-servers.ts"],"sourcesContent":["/**\n * High-level multi-server registry management.\n * Starts multiple servers from a servers configuration object.\n * Supports stdio, http, and ws transports.\n * Implements Claude Code-compatible configuration with start extension support.\n */\n\nimport type { VersionNegotiationOptions } from '@modelcontextprotocol/client';\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport * as process from 'process';\nimport { decorateClient, type ManagedClient } from '../client-helpers.ts';\nimport { validateServers } from '../config/validate-config.ts';\nimport { connectMcpClient } from '../connection/connect-client.ts';\nimport type { DcrAuthenticatorOptions } from '../dcr/dcr-authenticator.ts';\nimport { buildCapabilityIndex, type CapabilityClient, searchCapabilities as executeCapabilitySearch, type SearchOptions, type SearchResponse } from '../search/index.ts';\nimport type { McpServerEntry, StartConfig, StopCommandConfig, TransportType } from '../types.ts';\nimport { type Logger, logger } from '../utils/logger.ts';\nimport { type ServerProcess, spawnProcess } from './spawn-server.ts';\n\n/**\n * Servers configuration type - a map of server names to their configurations.\n */\nexport type ServersConfig = Record<string, McpServerEntry>;\n\nconst DEFAULT_SHUTDOWN_TIMEOUT_MS = 5000;\n\nfunction asError(error: unknown): Error {\n  return error instanceof Error ? error : new Error(String(error));\n}\n\nfunction withCause(message: string, cause: unknown): Error {\n  return new Error(message, { cause });\n}\n\nasync function settleWithin<T>(promise: Promise<T>, timeoutMs: number): Promise<{ settled: true; value: T } | { settled: true; error: unknown } | { settled: false }> {\n  let timer: NodeJS.Timeout | undefined;\n  return Promise.race([\n    promise.then(\n      (value) => ({ settled: true as const, value }),\n      (error: unknown) => ({ settled: true as const, error })\n    ),\n    new Promise<{ settled: false }>((resolve) => {\n      timer = setTimeout(() => resolve({ settled: false }), timeoutMs);\n    }),\n  ]).finally(() => {\n    if (timer) clearTimeout(timer);\n  });\n}\n\n/**\n * Dialect for server spawning.\n *\n * - 'servers': Spawn stdio servers (Claude Code compatible)\n * - 'start': Spawn HTTP servers with start blocks\n */\nexport type Dialect = 'servers' | 'start';\n\ntype RegistryConnectOptions = Omit<NonNullable<Parameters<typeof connectMcpClient>[2]>, 'signal'>;\n\n/**\n * Options for creating a server registry.\n */\nexport interface CreateServerRegistryOptions {\n  /** Working directory for spawned processes (default: process.cwd()) */\n  cwd?: string;\n\n  /**\n   * Base environment for all servers.\n   * If provided, process.env is NOT included (caller has full control).\n   * If omitted, process.env is used as the base (default behavior).\n   */\n  env?: Record<string, string>;\n\n  /**\n   * Dialects controlling which servers to spawn.\n   * - ['servers']: Spawn stdio servers only (default, Claude Code compatible)\n   * - ['start']: Only spawn servers with start blocks (HTTP servers)\n   * - ['servers', 'start']: Spawn both stdio servers and start blocks\n   * @default ['servers']\n   */\n  dialects?: Dialect[];\n}\n\n/**\n * Result of closing the registry.\n */\nexport interface CloseResult {\n  /** Whether any owned process exceeded its cooperative shutdown timeout */\n  timedOut: boolean;\n  /** Number of owned processes that required emergency force termination */\n  killedCount: number;\n}\n\n/**\n * Infer transport type: explicit type > URL protocol > default 'stdio'\n */\nfunction inferTransportType(config: { type?: TransportType; url?: string }): TransportType {\n  if (config.type) {\n    return config.type;\n  }\n\n  if (config.url) {\n    const url = new URL(config.url);\n    if (url.protocol === 'http:' || url.protocol === 'https:') {\n      return 'http';\n    }\n  }\n\n  return 'stdio';\n}\n\n/**\n * Spawn configuration result (internal)\n */\ninterface SpawnConfig {\n  shouldSpawn: boolean;\n  command?: string;\n  args?: string[];\n  env?: Record<string, string>;\n  cwd?: string;\n  stop?: StopCommandConfig;\n}\n\n/**\n * Helper to filter undefined values from environment\n */\nfunction filterEnv(env: Record<string, string | undefined>): Record<string, string> {\n  const filtered: Record<string, string> = {};\n  for (const [key, value] of Object.entries(env)) {\n    if (value !== undefined) {\n      filtered[key] = value;\n    }\n  }\n  return filtered;\n}\n\nfunction getStartSpawnConfig(start: StartConfig, transportType: TransportType, baseEnv: Record<string, string | undefined>): SpawnConfig {\n  const stop =\n    start.stop && (transportType === 'http' || transportType === 'sse-ide')\n      ? {\n          ...start.stop,\n          cwd: start.stop.cwd,\n          env: filterEnv({ ...baseEnv, ...start.env, ...start.stop.env }),\n        }\n      : undefined;\n\n  return {\n    shouldSpawn: true,\n    command: start.command,\n    args: start.args || [],\n    env: filterEnv({ ...baseEnv, ...start.env }),\n    cwd: start.cwd,\n    ...(stop && { stop }),\n  };\n}\n\n/**\n * Determine spawn behavior based on dialects and config structure.\n *\n * Dialects:\n * - ['servers'] (default): Claude Code compatible - ignores start blocks, stdio only\n * - ['start']: Only spawn servers with start blocks (HTTP server testing)\n * - ['servers', 'start']: Spawn both start blocks and stdio servers (full MCP-Z extension support)\n *\n * Environment merging (when baseEnv provided):\n * - HTTP servers (start block): { ...baseEnv, ...entry.start.env }\n * - Stdio servers: { ...baseEnv, ...entry.env }\n *\n * When baseEnv is not provided, process.env is used as the base.\n */\nfunction getSpawnConfig(entry: McpServerEntry, dialects: Dialect[], baseEnv: Record<string, string | undefined>): SpawnConfig {\n  const transportType = inferTransportType(entry);\n  if (dialects.length === 0) {\n    return { shouldSpawn: false };\n  }\n\n  const hasServers = dialects.includes('servers');\n  const hasStart = dialects.includes('start');\n\n  // If only 'servers' dialect: Claude Code compatible (ignore start blocks, stdio only)\n  if (hasServers && !hasStart) {\n    if (transportType === 'stdio' && entry.command) {\n      return {\n        shouldSpawn: true,\n        command: entry.command,\n        args: entry.args || [],\n        env: filterEnv({ ...baseEnv, ...entry.env }),\n      };\n    }\n    return { shouldSpawn: false };\n  }\n\n  // If only 'start' dialect: Only spawn servers with start blocks\n  if (hasStart && !hasServers) {\n    if (entry.start) {\n      return getStartSpawnConfig(entry.start, transportType, baseEnv);\n    }\n    return { shouldSpawn: false };\n  }\n\n  // Both dialects: Spawn both start blocks and stdio servers\n  // Priority: start blocks first, then stdio\n  if (entry.start) {\n    return getStartSpawnConfig(entry.start, transportType, baseEnv);\n  }\n\n  if (transportType === 'stdio' && entry.command) {\n    return {\n      shouldSpawn: true,\n      command: entry.command,\n      args: entry.args || [],\n      env: filterEnv({ ...baseEnv, ...entry.env }),\n    };\n  }\n\n  return { shouldSpawn: false };\n}\n\n/**\n * A registry of spawned MCP servers with connection management.\n * Provides access to individual server handles, connection management, and collection-wide close.\n */\nexport interface ServerRegistry {\n  /**\n   * The resolved servers configuration that was used.\n   * Useful for debugging and understanding what was started.\n   */\n  config: ServersConfig;\n\n  /**\n   * Map of server name to server process handle.\n   * @hidden\n   */\n  servers: Map<string, ServerProcess>;\n\n  /**\n   * Set of connected clients tracked by this registry.\n   * Automatically populated when using registry.connect().\n   */\n  clients: Set<ManagedClient>;\n\n  /**\n   * Connect to a server by name.\n   * The connected client is automatically tracked for close.\n   *\n   * @param name - Server name from configuration\n   * @param options - Authentication, logging, and protocol negotiation options\n   * @returns Connected MCP SDK Client\n   */\n  connect: (name: string, options?: { dcrAuthenticator?: Partial<DcrAuthenticatorOptions>; logger?: Logger; versionNegotiation?: VersionNegotiationOptions }) => Promise<ManagedClient>;\n\n  /**\n   * Close all clients and servers gracefully.\n   * Stops new connections, waits for in-flight connections, closes tracked clients, and then\n   * stops only processes owned by this registry. Stdio children receive stdin EOF first\n   * and the requested signal on POSIX if they remain open; owned HTTP children may use\n   * their configured application-specific stop command. POSIX cleanup tracks the detached\n   * process group; Windows can terminate only the direct child and cannot verify descendants.\n   * Cleanup failures are reported after every owned resource has been attempted.\n   *\n   * @param signal - Signal to send to processes (default: SIGINT)\n   * @param opts - Options including timeout\n   * @returns Promise resolving to whether any process timed out and how many required emergency force termination\n   */\n  close: (signal?: NodeJS.Signals, opts?: { timeoutMs?: number }) => Promise<CloseResult>;\n\n  /**\n   * Search indexed capabilities across all currently connected clients.\n   * Requires at least one connected client; respects SearchOptions filters.\n   */\n  searchCapabilities: (query: string, options?: SearchOptions) => Promise<SearchResponse>;\n\n  /**\n   * Support for `await using` pattern (automatic close).\n   */\n  [Symbol.asyncDispose]: () => Promise<void>;\n}\n\n/**\n * Create a registry of MCP servers from configuration.\n *\n * **Fast start**: Returns immediately after processes are created.\n * Use `registry.connect()` for lazy MCP connection.\n *\n * @param serversConfig - Map of server names to their configurations\n * @param options - Options for registry creation\n * @param options.cwd - Working directory for spawned processes (default: process.cwd())\n * @param options.env - Base environment for all servers. If provided, process.env is NOT included.\n *                      If omitted, process.env is used as the base (default behavior).\n * @param options.dialects - Dialects controlling which servers to spawn (default: ['servers'])\n *   - ['servers']: Spawn stdio servers only (Claude Code compatible)\n *   - ['start']: Only spawn servers with start blocks (HTTP servers)\n *   - ['servers', 'start']: Spawn both stdio servers and start blocks\n * @returns ServerRegistry instance with config, server map, connect method, and close function\n *\n * @example\n * // Fast server start (does NOT wait for readiness)\n * const registry = createServerRegistry({\n *   'echo': { command: 'node', args: ['server.ts'] },\n * });\n *\n * // Connect when needed (waits for MCP handshake)\n * const client = await registry.connect('echo');\n *\n * // Cleanup (closes all clients AND processes)\n * await registry.close();\n *\n * @example\n * // Start HTTP servers with start blocks\n * const registry = createServerRegistry(\n *   {\n *     'http-server': {\n *       url: 'http://localhost:8080/mcp',\n *       start: { command: 'node', args: ['http.ts', '--port', '8080'] }\n *     },\n *   },\n *   { dialects: ['start'] }\n * );\n *\n * @example\n * // Using await using for automatic close\n * await using registry = createServerRegistry(config);\n * const client = await registry.connect('server');\n * // Auto-disposed when scope exits\n */\nexport function createServerRegistry(serversConfig: ServersConfig, options?: CreateServerRegistryOptions): ServerRegistry {\n  const cwd = options?.cwd ?? process.cwd();\n  const dialects = options?.dialects ?? ['servers'];\n\n  // Determine base environment:\n  // - If options.env provided, use it (process.env NOT included)\n  // - If options.env omitted, use process.env as base\n  const baseEnv: Record<string, string | undefined> = options?.env ?? process.env;\n\n  // Validate working directory exists (fail fast for configuration errors)\n  if (!fs.existsSync(cwd)) {\n    throw new Error(`Cannot start servers: working directory '${cwd}' does not exist`);\n  }\n\n  // Validate configuration (fail fast with clear errors)\n  const validation = validateServers(serversConfig);\n  if (!validation.valid) {\n    throw new Error(`Invalid servers configuration:\\n${validation.errors?.join('\\n') ?? 'Unknown validation error'}`);\n  }\n\n  // Log validation warnings (non-blocking)\n  if (validation.warnings && validation.warnings.length > 0) {\n    for (const warning of validation.warnings) {\n      logger.warn(warning);\n    }\n  }\n\n  const servers = new Map<string, ServerProcess>();\n  const clients = new Set<ManagedClient>();\n  const sharedStdioClients = new Map<string, { client?: ManagedClient; connecting?: Promise<ManagedClient>; refs: number }>();\n  const pendingConnects = new Set<Promise<ManagedClient>>();\n  const closeAbortController = new AbortController();\n  const clientClosePromises = new WeakMap<ManagedClient, Promise<void>>();\n  const closeRaceErrors: Error[] = [];\n  let lifecycleState: 'open' | 'closing' | 'closed' = 'open';\n  let closePromise: Promise<CloseResult> | undefined;\n\n  const closeClientOnce = (client: ManagedClient): Promise<void> => {\n    let pending = clientClosePromises.get(client);\n    if (!pending) {\n      pending = Promise.resolve().then(() => client.close());\n      clientClosePromises.set(client, pending);\n    }\n    return pending;\n  };\n\n  // Start each server in the configuration\n  for (const [name, entry] of Object.entries(serversConfig)) {\n    // Infer transport type from config\n    const transportType = inferTransportType(entry);\n\n    // Determine spawn behavior based on dialects\n    const spawnConfig = getSpawnConfig(entry, dialects, baseEnv);\n\n    // Check if we should spawn this server\n    if (!spawnConfig.shouldSpawn) {\n      // External server - just log, no spawn needed\n      if (entry.url) {\n        logger.info(`[${name}] external ${transportType} server (url: ${entry.url})`);\n      } else {\n        logger.warn(`[${name}] skipping: no spawn configuration (missing start or command) and no url for external server`);\n      }\n      continue;\n    }\n\n    try {\n      // Validate spawn config\n      if (!spawnConfig.command) {\n        throw new Error(`Server \"${name}\" missing command field`);\n      }\n\n      const resolvedCwd = spawnConfig.cwd ? path.resolve(cwd, spawnConfig.cwd) : cwd;\n\n      // Start the server\n      logger.info(`[${name}] starting ${transportType} server (${spawnConfig.command} ${(spawnConfig.args || []).join(' ')})`);\n\n      // stdio servers need 'pipe' for MCP communication over stdin/stdout\n      // network servers use 'inherit' so we see their logs\n      const stdio = transportType === 'stdio' ? 'pipe' : 'inherit';\n\n      const handle = spawnProcess({\n        name,\n        command: spawnConfig.command,\n        ...(spawnConfig.args !== undefined && { args: spawnConfig.args }),\n        cwd: resolvedCwd,\n        ...(spawnConfig.env && Object.keys(spawnConfig.env).length > 0 && { env: spawnConfig.env }),\n        inheritEnv: options?.env === undefined,\n        ...(spawnConfig.stop && { stop: { ...spawnConfig.stop, cwd: spawnConfig.stop.cwd ? path.resolve(resolvedCwd, spawnConfig.stop.cwd) : resolvedCwd } }),\n        stdio,\n      });\n\n      // Add server to registry (starting is fast, readiness is lazy)\n      servers.set(name, handle);\n      logger.info(`[${name}] started successfully`);\n    } catch (e) {\n      logger.info(`[${name}] start ERROR: ${e instanceof Error ? e.message : String(e)}`);\n    }\n  }\n\n  // Connect internally, then track each returned lease for registry shutdown.\n  const connectInternal = async (name: string, options?: RegistryConnectOptions): Promise<ManagedClient> => {\n    const serverEntry = serversConfig[name];\n    if (!serverEntry) {\n      const available = Object.keys(serversConfig).join(', ');\n      throw new Error(`Server '${name}' not found in config. Available servers: ${available || 'none'}`);\n    }\n\n    const transportType = inferTransportType(serverEntry);\n\n    if (transportType === 'stdio') {\n      // Stdio is a single logical connection; reuse one client and lease references.\n      let entry = sharedStdioClients.get(name);\n      if (!entry) {\n        entry = { refs: 0 };\n        sharedStdioClients.set(name, entry);\n      }\n\n      if (!entry.client) {\n        if (!entry.connecting) {\n          entry.connecting = (async () => {\n            // Pass minimal RegistryLike object to connectMcpClient\n            const registryLike = { config: serversConfig, servers };\n            const rawClient = await connectMcpClient(registryLike, name, { ...options, signal: closeAbortController.signal });\n            const decorated = decorateClient(rawClient, { serverName: name });\n            entry.client = decorated;\n            entry.connecting = undefined;\n            return decorated;\n          })().catch((error) => {\n            sharedStdioClients.delete(name);\n            throw error;\n          });\n        }\n\n        await entry.connecting;\n      }\n\n      if (!entry.client) {\n        throw new Error(`Failed to connect to stdio server '${name}'`);\n      }\n\n      entry.refs += 1;\n      let releasePromise: Promise<void> | undefined;\n      let lease: ManagedClient;\n\n      lease = new Proxy(entry.client, {\n        get(target, prop) {\n          if (prop === 'close') {\n            return () => {\n              releasePromise ??= (async () => {\n                entry.refs = Math.max(0, entry.refs - 1);\n                try {\n                  if (entry.refs === 0) {\n                    sharedStdioClients.delete(name);\n                    await target.close();\n                  }\n                } finally {\n                  clients.delete(lease);\n                }\n              })();\n              return releasePromise;\n            };\n          }\n\n          const value = Reflect.get(target, prop, target) as unknown;\n          if (typeof value === 'function') {\n            return (value as (...args: unknown[]) => unknown).bind(target);\n          }\n          return value;\n        },\n      }) as ManagedClient;\n\n      clients.add(lease);\n      return lease;\n    }\n\n    // Pass minimal RegistryLike object to connectMcpClient\n    const registryLike = { config: serversConfig, servers };\n    const rawClient = await connectMcpClient(registryLike, name, { ...options, signal: closeAbortController.signal });\n    const decorated = decorateClient(rawClient, { serverName: name });\n    clients.add(decorated);\n    return decorated;\n  };\n\n  const connect = (name: string, options?: RegistryConnectOptions): Promise<ManagedClient> => {\n    if (lifecycleState !== 'open') {\n      return Promise.reject(new Error(`Cannot connect to server '${name}': registry is ${lifecycleState}`));\n    }\n\n    const pending = connectInternal(name, options).then(async (client) => {\n      if (lifecycleState === 'open') return client;\n\n      const result = await settleWithin(closeClientOnce(client), DEFAULT_SHUTDOWN_TIMEOUT_MS);\n      if (!result.settled) closeRaceErrors.push(new Error(`Client for server '${name}' did not close within ${DEFAULT_SHUTDOWN_TIMEOUT_MS}ms after a connection raced registry shutdown`));\n      else if ('error' in result) closeRaceErrors.push(withCause(`Failed to close server '${name}' after a connection raced registry shutdown`, asError(result.error)));\n      throw new Error(`Connection to server '${name}' completed while the registry was closing`);\n    });\n\n    pendingConnects.add(pending);\n    void pending.then(\n      () => pendingConnects.delete(pending),\n      () => pendingConnects.delete(pending)\n    );\n    return pending;\n  };\n\n  const closeAll = async (signal: NodeJS.Signals, opts: { timeoutMs?: number }): Promise<CloseResult> => {\n    logger.info(`[registry] closing (${signal})`);\n    const timeoutMs = opts.timeoutMs ?? DEFAULT_SHUTDOWN_TIMEOUT_MS;\n    const errors: Error[] = [];\n    closeAbortController.abort(new Error('Server registry is closing'));\n\n    const pendingResult = await settleWithin(Promise.allSettled(Array.from(pendingConnects)), timeoutMs);\n    if (!pendingResult.settled) {\n      errors.push(new Error(`In-flight server connections did not settle within ${timeoutMs}ms after cancellation`));\n    }\n    errors.push(...closeRaceErrors);\n\n    // Client close can hang independently; bound it so every owned server still gets cleanup.\n    const clientEntries = Array.from(clients);\n    const clientResults = await Promise.all(clientEntries.map(async (client) => ({ client, result: await settleWithin(closeClientOnce(client), timeoutMs) })));\n    for (const { client, result } of clientResults) {\n      if (!result.settled) {\n        errors.push(new Error(`Client${client.serverName ? ` for server '${client.serverName}'` : ''} did not close within ${timeoutMs}ms`));\n      } else if ('error' in result) {\n        errors.push(withCause(`Failed to close client${client.serverName ? ` for server '${client.serverName}'` : ''}: ${asError(result.error).message}`, asError(result.error)));\n      }\n    }\n    clients.clear();\n    sharedStdioClients.clear();\n\n    // Server teardown runs even when pending connects or client closes failed.\n    const serverEntries = Array.from(servers.entries());\n    const serverResults = await Promise.all(\n      serverEntries.map(async ([name, server]) => {\n        try {\n          return { name, result: await server.close(signal, opts) };\n        } catch (error) {\n          return { name, error: asError(error) };\n        }\n      })\n    );\n\n    let timedOut = false;\n    let killedCount = 0;\n    for (const result of serverResults) {\n      if ('error' in result && result.error !== undefined) {\n        errors.push(withCause(`Failed to close server '${result.name}': ${result.error.message}`, result.error));\n      } else if ('result' in result) {\n        timedOut ||= result.result.timedOut;\n        if (result.result.killed) killedCount += 1;\n      }\n    }\n\n    lifecycleState = 'closed';\n    if (errors.length > 0) {\n      const details = errors.map((error) => error.message).join('; ');\n      throw new AggregateError(errors, `Registry shutdown completed with ${errors.length} cleanup failure(s): ${details}`);\n    }\n\n    return { timedOut, killedCount };\n  };\n\n  const close = (signal: NodeJS.Signals = 'SIGINT', opts: { timeoutMs?: number } = {}): Promise<CloseResult> => {\n    if (!closePromise) {\n      lifecycleState = 'closing';\n      closePromise = closeAll(signal, opts);\n    }\n    return closePromise;\n  };\n\n  const searchFromRegistry = async (query: string, options: SearchOptions = {}): Promise<SearchResponse> => {\n    const requestedServers = options.servers ?? Object.keys(serversConfig);\n    if (requestedServers.length === 0) {\n      throw new Error('Cannot search capabilities: registry has no configured servers');\n    }\n\n    const unknownServers = requestedServers.filter((name) => !(name in serversConfig));\n    if (unknownServers.length > 0) {\n      throw new Error(`Cannot search capabilities: unknown server(s) [${unknownServers.join(', ')}]`);\n    }\n\n    const capabilityClients = new Map<string, CapabilityClient>();\n    const failures: Array<{ server: string; reason: string }> = [];\n\n    const ensureClient = async (serverName: string): Promise<ManagedClient> => {\n      for (const client of clients) {\n        if (client.serverName === serverName) {\n          return client;\n        }\n      }\n      return connect(serverName);\n    };\n\n    await Promise.all(\n      requestedServers.map(async (serverName) => {\n        try {\n          const managed = await ensureClient(serverName);\n          capabilityClients.set(serverName, managed.nativeClient);\n        } catch (error) {\n          failures.push({\n            server: serverName,\n            reason: error instanceof Error ? error.message : String(error),\n          });\n        }\n      })\n    );\n\n    if (capabilityClients.size === 0) {\n      const failureDetails = failures.length > 0 ? ` Connection failures: ${failures.map((f) => `${f.server} (${f.reason})`).join('; ')}` : '';\n      throw new Error(`Cannot search capabilities: unable to connect to any requested servers.${failureDetails}`);\n    }\n\n    if (failures.length > 0) {\n      throw new Error(`Cannot search capabilities: failed to connect to server(s) [${failures.map((f) => f.server).join(', ')}]. Reasons: ${failures.map((f) => `${f.server}: ${f.reason}`).join('; ')}`);\n    }\n\n    const index = await buildCapabilityIndex(capabilityClients);\n    return executeCapabilitySearch(index, query, options);\n  };\n\n  // Async dispose for `await using` pattern\n  const asyncDispose = async (): Promise<void> => {\n    await close();\n  };\n\n  return {\n    config: serversConfig,\n    servers,\n    clients,\n    connect,\n    close,\n    searchCapabilities: searchFromRegistry,\n    [Symbol.asyncDispose]: asyncDispose,\n  };\n}\n"],"names":["fs","path","process","decorateClient","validateServers","connectMcpClient","buildCapabilityIndex","searchCapabilities","executeCapabilitySearch","logger","spawnProcess","DEFAULT_SHUTDOWN_TIMEOUT_MS","asError","error","Error","String","withCause","message","cause","settleWithin","promise","timeoutMs","timer","Promise","race","then","value","settled","resolve","setTimeout","finally","clearTimeout","inferTransportType","config","type","url","URL","protocol","filterEnv","env","filtered","key","Object","entries","undefined","getStartSpawnConfig","start","transportType","baseEnv","stop","cwd","shouldSpawn","command","args","getSpawnConfig","entry","dialects","length","hasServers","includes","hasStart","createServerRegistry","serversConfig","options","existsSync","validation","valid","errors","join","warnings","warning","warn","servers","Map","clients","Set","sharedStdioClients","pendingConnects","closeAbortController","AbortController","clientClosePromises","WeakMap","closeRaceErrors","lifecycleState","closePromise","closeClientOnce","client","pending","get","close","set","name","spawnConfig","info","resolvedCwd","stdio","handle","keys","inheritEnv","e","connectInternal","serverEntry","available","refs","connecting","registryLike","rawClient","signal","decorated","serverName","catch","delete","releasePromise","lease","Proxy","target","prop","Math","max","Reflect","bind","add","connect","reject","result","push","closeAll","opts","abort","pendingResult","allSettled","Array","from","clientEntries","clientResults","all","map","clear","serverEntries","serverResults","server","timedOut","killedCount","killed","details","AggregateError","searchFromRegistry","query","requestedServers","unknownServers","filter","capabilityClients","failures","ensureClient","managed","nativeClient","reason","size","failureDetails","f","index","asyncDispose","Symbol"],"mappings":"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"}

package/dist/esm/types.d.ts

@@ -3,7 +3,7 @@
  *
  * Auto-generated from schemas/servers.schema.json
  */
-export type { MCPServers, McpServerEntry, StartConfig } from '../schemas/servers.d.js';
+export type { MCPServers, McpServerEntry, StartConfig, StopCommandConfig } from '../schemas/servers.d.js';
 /**
  * Transport type for server configuration
  * Standard MCP transport types matching Claude Code's schemas

package/dist/esm/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/mcp-z/client/src/types.ts"],"sourcesContent":["/**\n * MCP Configuration Types\n *\n * Auto-generated from schemas/servers.schema.json\n */\n\n// Re-export all generated types\nexport type { MCPServers, McpServerEntry, StartConfig } from '../schemas/servers.d.ts';\n\n/**\n * Transport type for server configuration\n * Standard MCP transport types matching Claude Code's schemas\n */\nexport type TransportType = 'stdio' | 'http' | 'sse-ide' | 'ws-ide' | 'sdk';\n"],"names":[],"mappings":"AAAA;;;;CAIC,GAED,gCAAgC;AAGhC;;;CAGC,GACD,WAA4E"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/mcp-z/client/src/types.ts"],"sourcesContent":["/**\n * MCP Configuration Types\n *\n * Auto-generated from schemas/servers.schema.json\n */\n\n// Re-export all generated types\nexport type { MCPServers, McpServerEntry, StartConfig, StopCommandConfig } from '../schemas/servers.d.ts';\n\n/**\n * Transport type for server configuration\n * Standard MCP transport types matching Claude Code's schemas\n */\nexport type TransportType = 'stdio' | 'http' | 'sse-ide' | 'ws-ide' | 'sdk';\n"],"names":[],"mappings":"AAAA;;;;CAIC,GAED,gCAAgC;AAGhC;;;CAGC,GACD,WAA4E"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcp-z/client",
-  "version": "2.2.4",
+  "version": "2.3.0",
   "description": "Programmatic MCP client library for Node.js - connect, discover, and call tools on Model Context Protocol servers.",
   "keywords": [
     "mcp",
@@ -53,16 +53,17 @@
     "generate:types": "json2ts schemas/servers.schema.json schemas/servers.d.ts --bannerComment \"/* eslint-disable */\n/* Auto-generated from schemas/servers.schema.json - DO NOT EDIT */\"",
     "prepublish:check": "ncp",
     "prepublishOnly": "node scripts/require-dist-tag.cjs && tsds validate",
-    "test": "tsds test:node --no-timeouts",
-    "test:ci": "tsds test:node --no-timeouts --ignore \"test/integration/auth/todoist-oauth.test.ts\"",
-    "test:ci:engines": "nvu engines tsds test:node --no-timeouts --ignore \"test/integration/auth/todoist-oauth.test.ts\"",
-    "test:engines": "nvu engines tsds test:node --no-timeouts",
+    "test": "tsds test:node --require test/lib/env-loader.ts --no-timeouts",
+    "test:ci": "tsds test:node --require test/lib/env-loader.ts --no-timeouts --ignore \"test/integration/auth/todoist-oauth.test.ts\"",
+    "test:ci:engines": "nvu engines tsds test:node --require test/lib/env-loader.ts --no-timeouts --ignore \"test/integration/auth/todoist-oauth.test.ts\"",
+    "test:engines": "nvu engines tsds test:node --require test/lib/env-loader.ts --no-timeouts",
     "version": "tsds version"
   },
   "dependencies": {
     "@modelcontextprotocol/client": "^2.0.0",
     "ajv": "^8.0.0",
     "ajv-formats": "^3.0.0",
+    "cross-spawn": "^7.0.6",
     "get-port": "5.1.1",
     "ipaddr.js": "^2.5.0",
     "keyv": "^5.0.0",
@@ -72,6 +73,7 @@
   "devDependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
     "@modelcontextprotocol/server": "^2.0.0",
+    "@types/cross-spawn": "^6.0.6",
     "@types/express": "^5.0.6",
     "@types/mocha": "^10.0.10",
     "@types/node": "^26.2.0",
@@ -80,6 +82,7 @@
     "node-version-use": "^2.4.7",
     "ts-dev-stack": "^1.22.1",
     "tsds-config": "^1.0.4",
+    "tsds-lib": "^1.22.6",
     "zod": "^4.0.0"
   },
   "engines": {

package/schemas/servers.d.ts

@@ -87,4 +87,28 @@ export interface StartConfig {
    * Working directory
    */
   cwd?: string;
+  stop?: StopCommandConfig;
+}
+/**
+ * Optional application-specific cooperative shutdown command for a registry-owned HTTP server
+ */
+export interface StopCommandConfig {
+  /**
+   * Command that requests application-specific server shutdown
+   */
+  command: string;
+  /**
+   * Command arguments
+   */
+  args?: string[];
+  /**
+   * Environment variables for the stop command
+   */
+  env?: {
+    [k: string]: string;
+  };
+  /**
+   * Working directory for the stop command
+   */
+  cwd?: string;
 }

package/schemas/servers.schema.json

@@ -95,6 +95,37 @@
         "cwd": {
           "type": "string",
           "description": "Working directory"
+        },
+        "stop": {
+          "$ref": "#/definitions/StopCommandConfig",
+          "description": "Optional application-specific cooperative shutdown command for a registry-owned HTTP server"
+        }
+      },
+      "required": ["command"],
+      "additionalProperties": false
+    },
+    "StopCommandConfig": {
+      "type": "object",
+      "description": "Command run once by registry.close() before waiting for an owned HTTP server to exit. The application must implement the shutdown mechanism; MCP HTTP defines no server shutdown operation.",
+      "properties": {
+        "command": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Command that requests application-specific server shutdown"
+        },
+        "args": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "Command arguments"
+        },
+        "env": {
+          "type": "object",
+          "additionalProperties": { "type": "string" },
+          "description": "Environment variables for the stop command"
+        },
+        "cwd": {
+          "type": "string",
+          "description": "Working directory for the stop command"
         }
       },
       "required": ["command"],