@mcp-z/client 2.2.3 → 2.3.0

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

@@ -14,6 +14,7 @@ Object.defineProperty(exports, "createServerRegistry", {
     }
 });
 var _fs = /*#__PURE__*/ _interop_require_wildcard(require("fs"));
+var _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
 var _process = /*#__PURE__*/ _interop_require_wildcard(require("process"));
 var _clienthelpersts = require("../client-helpers.js");
 var _validateconfigts = require("../config/validate-config.js");
@@ -29,6 +30,9 @@ function _array_like_to_array(arr, len) {
 function _array_with_holes(arr) {
     if (Array.isArray(arr)) return arr;
 }
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
@@ -102,6 +106,11 @@ function _interop_require_wildcard(obj, nodeInterop) {
     if (cache) cache.set(obj, newObj);
     return newObj;
 }
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) {
+        return Array.from(iter);
+    }
+}
 function _iterable_to_array_limit(arr, i) {
     var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
     if (_i == null) return;
@@ -129,6 +138,9 @@ function _iterable_to_array_limit(arr, i) {
 function _non_iterable_rest() {
     throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
 function _object_spread(target) {
     for(var i = 1; i < arguments.length; i++){
         var source = arguments[i] != null ? arguments[i] : {};
@@ -170,6 +182,9 @@ function _object_spread_props(target, source) {
 function _sliced_to_array(arr, i) {
     return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
 }
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
 function _ts_generator(thisArg, body) {
     var f, y, t, _ = {
         label: 0,
@@ -277,6 +292,47 @@ function _unsupported_iterable_to_array(o, minLen) {
     if (n === "Map" || n === "Set") return Array.from(n);
     if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
 }
+var DEFAULT_SHUTDOWN_TIMEOUT_MS = 5000;
+function asError(error) {
+    return _instanceof(error, Error) ? error : new Error(String(error));
+}
+function withCause(message, cause) {
+    return new Error(message, {
+        cause: cause
+    });
+}
+function settleWithin(promise, timeoutMs) {
+    return _async_to_generator(function() {
+        var timer;
+        return _ts_generator(this, function(_state) {
+            return [
+                2,
+                Promise.race([
+                    promise.then(function(value) {
+                        return {
+                            settled: true,
+                            value: value
+                        };
+                    }, function(error) {
+                        return {
+                            settled: true,
+                            error: error
+                        };
+                    }),
+                    new Promise(function(resolve) {
+                        timer = setTimeout(function() {
+                            return resolve({
+                                settled: false
+                            });
+                        }, timeoutMs);
+                    })
+                ]).finally(function() {
+                    if (timer) clearTimeout(timer);
+                })
+            ];
+        });
+    })();
+}
 /**
  * Infer transport type: explicit type > URL protocol > default 'stdio'
  */ function inferTransportType(config) {
@@ -319,6 +375,21 @@ function _unsupported_iterable_to_array(o, minLen) {
     }
     return filtered;
 }
+function getStartSpawnConfig(start, transportType, baseEnv) {
+    var stop = start.stop && (transportType === 'http' || transportType === 'sse-ide') ? _object_spread_props(_object_spread({}, start.stop), {
+        cwd: start.stop.cwd,
+        env: filterEnv(_object_spread({}, baseEnv, start.env, start.stop.env))
+    }) : undefined;
+    return _object_spread({
+        shouldSpawn: true,
+        command: start.command,
+        args: start.args || [],
+        env: filterEnv(_object_spread({}, baseEnv, start.env)),
+        cwd: start.cwd
+    }, stop && {
+        stop: stop
+    });
+}
 /**
  * Determine spawn behavior based on dialects and config structure.
  *
@@ -334,6 +405,11 @@ function _unsupported_iterable_to_array(o, minLen) {
  * When baseEnv is not provided, process.env is used as the base.
  */ function getSpawnConfig(entry, dialects, baseEnv) {
     var transportType = inferTransportType(entry);
+    if (dialects.length === 0) {
+        return {
+            shouldSpawn: false
+        };
+    }
     var hasServers = dialects.includes('servers');
     var hasStart = dialects.includes('start');
     // If only 'servers' dialect: Claude Code compatible (ignore start blocks, stdio only)
@@ -353,12 +429,7 @@ function _unsupported_iterable_to_array(o, minLen) {
     // 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(_object_spread({}, baseEnv, entry.start.env))
-            };
+            return getStartSpawnConfig(entry.start, transportType, baseEnv);
         }
         return {
             shouldSpawn: false
@@ -367,12 +438,7 @@ function _unsupported_iterable_to_array(o, minLen) {
     // 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(_object_spread({}, baseEnv, entry.start.env))
-        };
+        return getStartSpawnConfig(entry.start, transportType, baseEnv);
     }
     if (transportType === 'stdio' && entry.command) {
         return {
@@ -433,6 +499,22 @@ function createServerRegistry(serversConfig, options) {
     var servers = new Map();
     var clients = new Set();
     var sharedStdioClients = new Map();
+    var pendingConnects = new Set();
+    var closeAbortController = new AbortController();
+    var clientClosePromises = new WeakMap();
+    var closeRaceErrors = [];
+    var lifecycleState = 'open';
+    var closePromise;
+    var closeClientOnce = function closeClientOnce(client) {
+        var pending = clientClosePromises.get(client);
+        if (!pending) {
+            pending = Promise.resolve().then(function() {
+                return client.close();
+            });
+            clientClosePromises.set(client, pending);
+        }
+        return pending;
+    };
     var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
     try {
         // Start each server in the configuration
@@ -457,14 +539,13 @@ function createServerRegistry(serversConfig, options) {
                 if (!spawnConfig.command) {
                     throw new Error('Server "'.concat(name, '" missing command field'));
                 }
-                // All servers use the same working directory (cwd from options)
-                var resolvedCwd = cwd;
+                var resolvedCwd = spawnConfig.cwd ? _path.resolve(cwd, spawnConfig.cwd) : cwd;
                 // Start the server
                 _loggerts.logger.info("[".concat(name, "] starting ").concat(transportType, " server (").concat(spawnConfig.command, " ").concat((spawnConfig.args || []).join(' '), ")"));
                 // stdio servers need 'pipe' for MCP communication over stdin/stdout
                 // network servers use 'inherit' so we see their logs
                 var stdio = transportType === 'stdio' ? 'pipe' : 'inherit';
-                var handle = (0, _spawnserverts.spawnProcess)(_object_spread_props(_object_spread(_object_spread_props(_object_spread({
+                var handle = (0, _spawnserverts.spawnProcess)(_object_spread_props(_object_spread(_object_spread_props(_object_spread(_object_spread_props(_object_spread({
                     name: name,
                     command: spawnConfig.command
                 }, spawnConfig.args !== undefined && {
@@ -473,6 +554,12 @@ function createServerRegistry(serversConfig, options) {
                     cwd: resolvedCwd
                 }), 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: _object_spread_props(_object_spread({}, spawnConfig.stop), {
+                        cwd: spawnConfig.stop.cwd ? _path.resolve(resolvedCwd, spawnConfig.stop.cwd) : resolvedCwd
+                    })
                 }), {
                     stdio: stdio
                 }));
@@ -497,10 +584,10 @@ function createServerRegistry(serversConfig, options) {
             }
         }
     }
-    // Create connect function that tracks clients
-    var connect = function connect(name, options) {
+    // Connect internally, then track each returned lease for registry shutdown.
+    var connectInternal = function connectInternal(name, options) {
         return _async_to_generator(function() {
-            var serverEntry, available, transportType, entry, released, lease, registryLike, rawClient, decorated;
+            var serverEntry, available, transportType, entry, releasePromise, lease, registryLike, rawClient, decorated;
             return _ts_generator(this, function(_state) {
                 switch(_state.label){
                     case 0:
@@ -540,7 +627,9 @@ function createServerRegistry(serversConfig, options) {
                                                 };
                                                 return [
                                                     4,
-                                                    (0, _connectclientts.connectMcpClient)(registryLike, name, options)
+                                                    (0, _connectclientts.connectMcpClient)(registryLike, name, _object_spread_props(_object_spread({}, options), {
+                                                        signal: closeAbortController.signal
+                                                    }))
                                                 ];
                                             case 1:
                                                 rawClient = _state.sent();
@@ -573,40 +662,55 @@ function createServerRegistry(serversConfig, options) {
                             throw new Error("Failed to connect to stdio server '".concat(name, "'"));
                         }
                         entry.refs += 1;
-                        released = false;
                         lease = new Proxy(entry.client, {
                             get: function get(target, prop) {
                                 if (prop === 'close') {
                                     return function() {
-                                        return _async_to_generator(function() {
-                                            return _ts_generator(this, function(_state) {
-                                                switch(_state.label){
-                                                    case 0:
-                                                        if (released) return [
-                                                            2
-                                                        ];
-                                                        released = true;
-                                                        clients.delete(lease);
-                                                        entry.refs = Math.max(0, entry.refs - 1);
-                                                        if (!(entry.refs === 0)) return [
-                                                            3,
-                                                            2
-                                                        ];
-                                                        sharedStdioClients.delete(name);
-                                                        return [
-                                                            4,
-                                                            target.close()
-                                                        ];
-                                                    case 1:
-                                                        _state.sent();
-                                                        _state.label = 2;
-                                                    case 2:
-                                                        return [
-                                                            2
-                                                        ];
-                                                }
-                                            });
-                                        })();
+                                        releasePromise !== null && releasePromise !== void 0 ? releasePromise : releasePromise = function() {
+                                            return _async_to_generator(function() {
+                                                return _ts_generator(this, function(_state) {
+                                                    switch(_state.label){
+                                                        case 0:
+                                                            entry.refs = Math.max(0, entry.refs - 1);
+                                                            _state.label = 1;
+                                                        case 1:
+                                                            _state.trys.push([
+                                                                1,
+                                                                ,
+                                                                4,
+                                                                5
+                                                            ]);
+                                                            if (!(entry.refs === 0)) return [
+                                                                3,
+                                                                3
+                                                            ];
+                                                            sharedStdioClients.delete(name);
+                                                            return [
+                                                                4,
+                                                                target.close()
+                                                            ];
+                                                        case 2:
+                                                            _state.sent();
+                                                            _state.label = 3;
+                                                        case 3:
+                                                            return [
+                                                                3,
+                                                                5
+                                                            ];
+                                                        case 4:
+                                                            clients.delete(lease);
+                                                            return [
+                                                                7
+                                                            ];
+                                                        case 5:
+                                                            return [
+                                                                2
+                                                            ];
+                                                    }
+                                                });
+                                            })();
+                                        }();
+                                        return releasePromise;
                                     };
                                 }
                                 var value = Reflect.get(target, prop, target);
@@ -629,7 +733,9 @@ function createServerRegistry(serversConfig, options) {
                         };
                         return [
                             4,
-                            (0, _connectclientts.connectMcpClient)(registryLike, name, options)
+                            (0, _connectclientts.connectMcpClient)(registryLike, name, _object_spread_props(_object_spread({}, options), {
+                                signal: closeAbortController.signal
+                            }))
                         ];
                     case 4:
                         rawClient = _state.sent();
@@ -645,84 +751,199 @@ function createServerRegistry(serversConfig, options) {
             });
         })();
     };
-    // Create close function that stops all clients and servers
-    var close = function close() {
-        var signal = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 'SIGINT', opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    var connect = function connect(name, options) {
+        if (lifecycleState !== 'open') {
+            return Promise.reject(new Error("Cannot connect to server '".concat(name, "': registry is ").concat(lifecycleState)));
+        }
+        var pending = connectInternal(name, options).then(function(client) {
+            return _async_to_generator(function() {
+                var result;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            if (lifecycleState === 'open') return [
+                                2,
+                                client
+                            ];
+                            return [
+                                4,
+                                settleWithin(closeClientOnce(client), DEFAULT_SHUTDOWN_TIMEOUT_MS)
+                            ];
+                        case 1:
+                            result = _state.sent();
+                            if (!result.settled) closeRaceErrors.push(new Error("Client for server '".concat(name, "' did not close within ").concat(DEFAULT_SHUTDOWN_TIMEOUT_MS, "ms after a connection raced registry shutdown")));
+                            else if ('error' in result) closeRaceErrors.push(withCause("Failed to close server '".concat(name, "' after a connection raced registry shutdown"), asError(result.error)));
+                            throw new Error("Connection to server '".concat(name, "' completed while the registry was closing"));
+                    }
+                });
+            })();
+        });
+        pendingConnects.add(pending);
+        void pending.then(function() {
+            return pendingConnects.delete(pending);
+        }, function() {
+            return pendingConnects.delete(pending);
+        });
+        return pending;
+    };
+    var closeAll = function closeAll(signal, opts) {
         return _async_to_generator(function() {
-            var clientClosePromises, closeResults, timedOut, killedCount;
+            var _errors, _opts_timeoutMs, timeoutMs, errors, pendingResult, clientEntries, clientResults, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, client, result, serverEntries, serverResults, timedOut, killedCount, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, result1, details;
             return _ts_generator(this, function(_state) {
                 switch(_state.label){
                     case 0:
                         _loggerts.logger.info("[registry] closing (".concat(signal, ")"));
-                        // First, close all tracked clients
-                        clientClosePromises = Array.from(clients).map(function(client) {
-                            return _async_to_generator(function() {
-                                var unused;
-                                return _ts_generator(this, function(_state) {
-                                    switch(_state.label){
-                                        case 0:
-                                            _state.trys.push([
-                                                0,
-                                                2,
-                                                ,
-                                                3
-                                            ]);
-                                            return [
-                                                4,
-                                                client.close()
-                                            ];
-                                        case 1:
-                                            _state.sent();
-                                            return [
-                                                3,
-                                                3
-                                            ];
-                                        case 2:
-                                            unused = _state.sent();
-                                            return [
-                                                3,
-                                                3
-                                            ];
-                                        case 3:
-                                            return [
-                                                2
-                                            ];
-                                    }
-                                });
-                            })();
-                        });
+                        timeoutMs = (_opts_timeoutMs = opts.timeoutMs) !== null && _opts_timeoutMs !== void 0 ? _opts_timeoutMs : DEFAULT_SHUTDOWN_TIMEOUT_MS;
+                        errors = [];
+                        closeAbortController.abort(new Error('Server registry is closing'));
                         return [
                             4,
-                            Promise.all(clientClosePromises)
+                            settleWithin(Promise.allSettled(Array.from(pendingConnects)), timeoutMs)
                         ];
                     case 1:
-                        _state.sent();
-                        clients.clear();
-                        // Then close all server processes
-                        if (servers.size === 0) {
-                            return [
-                                2,
-                                {
-                                    timedOut: false,
-                                    killedCount: 0
-                                }
-                            ];
+                        pendingResult = _state.sent();
+                        if (!pendingResult.settled) {
+                            errors.push(new Error("In-flight server connections did not settle within ".concat(timeoutMs, "ms after cancellation")));
                         }
+                        (_errors = errors).push.apply(_errors, _to_consumable_array(closeRaceErrors));
+                        // Client close can hang independently; bound it so every owned server still gets cleanup.
+                        clientEntries = Array.from(clients);
                         return [
                             4,
-                            Promise.all(Array.from(servers.values()).map(function(server) {
-                                return server.close(signal, opts);
+                            Promise.all(clientEntries.map(function(client) {
+                                return _async_to_generator(function() {
+                                    var _tmp;
+                                    return _ts_generator(this, function(_state) {
+                                        switch(_state.label){
+                                            case 0:
+                                                _tmp = {
+                                                    client: client
+                                                };
+                                                return [
+                                                    4,
+                                                    settleWithin(closeClientOnce(client), timeoutMs)
+                                                ];
+                                            case 1:
+                                                return [
+                                                    2,
+                                                    (_tmp.result = _state.sent(), _tmp)
+                                                ];
+                                        }
+                                    });
+                                })();
                             }))
                         ];
                     case 2:
-                        closeResults = _state.sent();
-                        // Check if any timed out and count how many were force-killed
-                        timedOut = closeResults.some(function(result) {
-                            return result.timedOut;
-                        });
-                        killedCount = closeResults.filter(function(result) {
-                            return result.killed;
-                        }).length;
+                        clientResults = _state.sent();
+                        _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                        try {
+                            for(_iterator = clientResults[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                _step_value = _step.value, client = _step_value.client, result = _step_value.result;
+                                if (!result.settled) {
+                                    errors.push(new Error("Client".concat(client.serverName ? " for server '".concat(client.serverName, "'") : '', " did not close within ").concat(timeoutMs, "ms")));
+                                } else if ('error' in result) {
+                                    errors.push(withCause("Failed to close client".concat(client.serverName ? " for server '".concat(client.serverName, "'") : '', ": ").concat(asError(result.error).message), asError(result.error)));
+                                }
+                            }
+                        } catch (err) {
+                            _didIteratorError = true;
+                            _iteratorError = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                    _iterator.return();
+                                }
+                            } finally{
+                                if (_didIteratorError) {
+                                    throw _iteratorError;
+                                }
+                            }
+                        }
+                        clients.clear();
+                        sharedStdioClients.clear();
+                        // Server teardown runs even when pending connects or client closes failed.
+                        serverEntries = Array.from(servers.entries());
+                        return [
+                            4,
+                            Promise.all(serverEntries.map(function(param) {
+                                var _param = _sliced_to_array(param, 2), name = _param[0], server = _param[1];
+                                return _async_to_generator(function() {
+                                    var _tmp, error;
+                                    return _ts_generator(this, function(_state) {
+                                        switch(_state.label){
+                                            case 0:
+                                                _state.trys.push([
+                                                    0,
+                                                    2,
+                                                    ,
+                                                    3
+                                                ]);
+                                                _tmp = {
+                                                    name: name
+                                                };
+                                                return [
+                                                    4,
+                                                    server.close(signal, opts)
+                                                ];
+                                            case 1:
+                                                return [
+                                                    2,
+                                                    (_tmp.result = _state.sent(), _tmp)
+                                                ];
+                                            case 2:
+                                                error = _state.sent();
+                                                return [
+                                                    2,
+                                                    {
+                                                        name: name,
+                                                        error: asError(error)
+                                                    }
+                                                ];
+                                            case 3:
+                                                return [
+                                                    2
+                                                ];
+                                        }
+                                    });
+                                })();
+                            }))
+                        ];
+                    case 3:
+                        serverResults = _state.sent();
+                        timedOut = false;
+                        killedCount = 0;
+                        _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                        try {
+                            for(_iterator1 = serverResults[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                                result1 = _step1.value;
+                                if ('error' in result1 && result1.error !== undefined) {
+                                    errors.push(withCause("Failed to close server '".concat(result1.name, "': ").concat(result1.error.message), result1.error));
+                                } else if ('result' in result1) {
+                                    timedOut || (timedOut = result1.result.timedOut);
+                                    if (result1.result.killed) killedCount += 1;
+                                }
+                            }
+                        } catch (err) {
+                            _didIteratorError1 = true;
+                            _iteratorError1 = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                    _iterator1.return();
+                                }
+                            } finally{
+                                if (_didIteratorError1) {
+                                    throw _iteratorError1;
+                                }
+                            }
+                        }
+                        lifecycleState = 'closed';
+                        if (errors.length > 0) {
+                            details = errors.map(function(error) {
+                                return error.message;
+                            }).join('; ');
+                            throw new AggregateError(errors, "Registry shutdown completed with ".concat(errors.length, " cleanup failure(s): ").concat(details));
+                        }
                         return [
                             2,
                             {
@@ -734,6 +955,14 @@ function createServerRegistry(serversConfig, options) {
             });
         })();
     };
+    var close = function close() {
+        var signal = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 'SIGINT', opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+        if (!closePromise) {
+            lifecycleState = 'closing';
+            closePromise = closeAll(signal, opts);
+        }
+        return closePromise;
+    };
     var searchFromRegistry = function searchFromRegistry(query) {
         var _$options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
         return _async_to_generator(function() {