@mcp-z/client 2.2.4 → 2.3.0

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

@@ -11,10 +11,12 @@ Object.defineProperty(exports, "spawnProcess", {
         return spawnProcess;
     }
 });
-var _child_process = require("child_process");
+var _crossspawn = /*#__PURE__*/ _interop_require_default(require("cross-spawn"));
+var _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
 var _process = /*#__PURE__*/ _interop_require_wildcard(require("process"));
 var _loggerts = require("../utils/logger.js");
 var _pathutilsts = require("../utils/path-utils.js");
+var _ownedprocesstreets = require("./owned-process-tree.js");
 function _array_like_to_array(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
     for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
@@ -66,6 +68,11 @@ function _instanceof(left, right) {
         return !!right[Symbol.hasInstance](left);
     } else return left instanceof right;
 }
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
     var cacheBabelInterop = new WeakMap();
@@ -248,18 +255,18 @@ 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);
 }
-/**
- * Normalize environment variables by merging with process.env and filtering undefined values.
- */ function normalizeEnv(env) {
-    var merged = _object_spread({}, _process.env, env || {});
+var DEFAULT_CLOSE_TIMEOUT_MS = 5000;
+var PROCESS_TERMINATION_TIMEOUT_MS = 5000;
+var PROCESS_POLL_INTERVAL_MS = 25;
+function normalizeEnv(env) {
+    var inheritEnv = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
+    var merged = _object_spread({}, inheritEnv ? _process.env : {}, env || {});
     var result = {};
     var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
     try {
         for(var _iterator = Object.entries(merged)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
             var _step_value = _sliced_to_array(_step.value, 2), key = _step_value[0], value = _step_value[1];
-            if (value !== undefined) {
-                result[key] = value;
-            }
+            if (value !== undefined) result[key] = value;
         }
     } catch (err) {
         _didIteratorError = true;
@@ -277,40 +284,226 @@ function _unsupported_iterable_to_array(o, minLen) {
     }
     return result;
 }
-function terminateWindowsProcessTree(pid, force) {
-    var args = [
-        '/PID',
-        String(pid),
-        '/T'
-    ];
-    if (force) args.push('/F');
-    return new Promise(function(resolve, reject) {
-        var taskkill = (0, _child_process.spawn)('taskkill.exe', args, {
-            stdio: 'ignore',
-            windowsHide: true
-        });
-        taskkill.once('error', reject);
-        taskkill.once('close', function(code) {
-            if (code === 0) {
-                resolve();
-                return;
+function delay(ms) {
+    return new Promise(function(resolve) {
+        return setTimeout(resolve, ms);
+    });
+}
+function waitForCompletion(closeEvent, childClosed, tree, timeoutMs) {
+    return _async_to_generator(function() {
+        var _tmp, deadline, lastError, processGroupEmpty, closed;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    if (!!tree) return [
+                        3,
+                        2
+                    ];
+                    _tmp = {};
+                    return [
+                        4,
+                        waitForChildClose(closeEvent, timeoutMs)
+                    ];
+                case 1:
+                    return [
+                        2,
+                        (_tmp.closed = _state.sent() !== undefined, _tmp)
+                    ];
+                case 2:
+                    deadline = Date.now() + timeoutMs;
+                    _state.label = 3;
+                case 3:
+                    if (!true) return [
+                        3,
+                        5
+                    ];
+                    processGroupEmpty = false;
+                    try {
+                        processGroupEmpty = tree.isEmpty();
+                        lastError = undefined;
+                    } catch (error) {
+                        lastError = _instanceof(error, Error) ? error : new Error(String(error));
+                    }
+                    closed = childClosed();
+                    if (closed && processGroupEmpty) return [
+                        2,
+                        {
+                            closed: closed,
+                            processGroupEmpty: processGroupEmpty
+                        }
+                    ];
+                    if (Date.now() >= deadline) return [
+                        2,
+                        _object_spread({
+                            closed: closed,
+                            processGroupEmpty: processGroupEmpty
+                        }, lastError && {
+                            error: lastError
+                        })
+                    ];
+                    return [
+                        4,
+                        delay(Math.min(PROCESS_POLL_INTERVAL_MS, Math.max(1, deadline - Date.now())))
+                    ];
+                case 4:
+                    _state.sent();
+                    return [
+                        3,
+                        3
+                    ];
+                case 5:
+                    return [
+                        2
+                    ];
             }
-            reject(new Error("taskkill.exe failed to stop process tree rooted at PID ".concat(pid, " (exit code ").concat(code !== null && code !== void 0 ? code : 'unknown', ")")));
         });
+    })();
+}
+function isCompletionSuccessful(completion) {
+    return completion.closed && completion.processGroupEmpty !== false;
+}
+function terminateChild(child, tree) {
+    if (tree) return tree.terminate();
+    try {
+        return {
+            killed: child.kill('SIGKILL')
+        };
+    } catch (error) {
+        return {
+            killed: false,
+            error: asError(error)
+        };
+    }
+}
+function waitForChildClose(closeEvent, timeoutMs) {
+    var timer;
+    return Promise.race([
+        closeEvent,
+        new Promise(function(resolve) {
+            timer = setTimeout(function() {
+                return resolve(undefined);
+            }, timeoutMs);
+        })
+    ]).finally(function() {
+        if (timer) clearTimeout(timer);
+    });
+}
+function requestProcessSignal(child, signal) {
+    if (!child.pid) throw new Error('Cannot request cooperative shutdown because the server has no process ID');
+    if (_process.platform === 'win32') throw new Error('POSIX process signals are not available on Windows');
+    try {
+        _process.kill(-child.pid, signal);
+    } catch (error) {
+        if (!(_instanceof(error, Error) && 'code' in error && error.code === 'ESRCH')) throw error;
+    }
+}
+function asError(error) {
+    return _instanceof(error, Error) ? error : new Error(String(error));
+}
+function withCause(message, cause) {
+    return new Error(message, {
+        cause: cause
     });
 }
+function runStopCommand(command, cwd, timeoutMs, inheritEnv) {
+    return _async_to_generator(function() {
+        var stopCwd, env, args, child, spawnError, closed, closeEventValue, closeEvent, result, tree, completion, _completion_error, _termination_error, termination, afterTermination, details, reason, remaining, _closeEventValue_code;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    stopCwd = command.cwd ? _path.resolve(cwd, command.cwd) : cwd;
+                    env = normalizeEnv(command.env, inheritEnv);
+                    args = command.args ? (0, _pathutilsts.resolveArgsPaths)(command.args, stopCwd) : [];
+                    child = (0, _crossspawn.default)(command.command, args, {
+                        cwd: stopCwd,
+                        env: env,
+                        stdio: 'ignore',
+                        shell: false,
+                        detached: _process.platform !== 'win32',
+                        windowsHide: true
+                    });
+                    closed = false;
+                    closeEvent = new Promise(function(resolve) {
+                        child.once('error', function(error) {
+                            spawnError = error;
+                        });
+                        child.once('close', function(code, signal) {
+                            closed = true;
+                            closeEventValue = {
+                                code: code,
+                                signal: signal
+                            };
+                            resolve({
+                                code: code,
+                                signal: signal
+                            });
+                        });
+                    });
+                    if (!!child.pid) return [
+                        3,
+                        2
+                    ];
+                    return [
+                        4,
+                        waitForChildClose(closeEvent, timeoutMs)
+                    ];
+                case 1:
+                    result = _state.sent();
+                    if (!result) throw new Error("Stop command did not start or close within ".concat(timeoutMs, "ms"));
+                    if (spawnError) throw withCause("Stop command could not be started: ".concat(spawnError.message), spawnError);
+                    _state.label = 2;
+                case 2:
+                    tree = child.pid && _process.platform !== 'win32' ? new _ownedprocesstreets.OwnedProcessTree(child.pid) : undefined;
+                    return [
+                        4,
+                        waitForCompletion(closeEvent, function() {
+                            return closed;
+                        }, tree, timeoutMs)
+                    ];
+                case 3:
+                    completion = _state.sent();
+                    if (!!isCompletionSuccessful(completion)) return [
+                        3,
+                        5
+                    ];
+                    termination = terminateChild(child, tree);
+                    return [
+                        4,
+                        waitForCompletion(closeEvent, function() {
+                            return closed;
+                        }, tree, PROCESS_TERMINATION_TIMEOUT_MS)
+                    ];
+                case 4:
+                    afterTermination = _state.sent();
+                    details = [
+                        (_completion_error = completion.error) === null || _completion_error === void 0 ? void 0 : _completion_error.message,
+                        (_termination_error = termination.error) === null || _termination_error === void 0 ? void 0 : _termination_error.message
+                    ].filter(Boolean).join('; ');
+                    reason = "Stop command exceeded ".concat(timeoutMs, "ms and required emergency process termination");
+                    remaining = !isCompletionSuccessful(afterTermination) ? '; stop command or its POSIX process group remained alive' : '';
+                    throw new Error("".concat(reason).concat(details ? ": ".concat(details) : '').concat(remaining));
+                case 5:
+                    if (spawnError) throw withCause("Stop command could not be started: ".concat(spawnError.message), spawnError);
+                    if (closeEventValue && (closeEventValue.code !== 0 || closeEventValue.signal !== null)) {
+                        ;
+                        throw new Error("Stop command exited with code ".concat((_closeEventValue_code = closeEventValue.code) !== null && _closeEventValue_code !== void 0 ? _closeEventValue_code : 'unknown').concat(closeEventValue.signal ? " (signal ".concat(closeEventValue.signal, ")") : ''));
+                    }
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
 function spawnProcess(opts) {
-    var _opts_cwd, _opts_stdio, _opts_shell;
+    var _opts_cwd, _opts_stdio, _opts_inheritEnv;
     var name = opts.name;
     var command = opts.command;
     var cwd = (_opts_cwd = opts.cwd) !== null && _opts_cwd !== void 0 ? _opts_cwd : _process.cwd();
     var stdio = (_opts_stdio = opts.stdio) !== null && _opts_stdio !== void 0 ? _opts_stdio : 'inherit';
-    var shell = (_opts_shell = opts.shell) !== null && _opts_shell !== void 0 ? _opts_shell : _process.platform === 'win32';
-    // Resolve paths in args relative to the working directory
     var args = opts.args ? (0, _pathutilsts.resolveArgsPaths)(opts.args, cwd) : [];
-    // Merge environment variables
-    var env = normalizeEnv(opts.env);
-    // Create resolved config for return value
+    var inheritEnv = (_opts_inheritEnv = opts.inheritEnv) !== null && _opts_inheritEnv !== void 0 ? _opts_inheritEnv : true;
+    var env = normalizeEnv(opts.env, inheritEnv);
     var resolvedConfig = {
         name: name,
         command: command,
@@ -318,204 +511,197 @@ function spawnProcess(opts) {
         cwd: cwd,
         env: env,
         stdio: stdio,
-        shell: shell
+        shell: false
     };
-    // Log spawn operation
     _loggerts.logger.info("[".concat(name, "] → ").concat(command, " ").concat(args.join(' ')));
-    // Spawn the process
-    var spawnOpts = {
+    var child = (0, _crossspawn.default)(command, args, {
         cwd: cwd,
         env: env,
         stdio: stdio,
-        shell: shell
-    };
-    var child = (0, _child_process.spawn)(command, args, spawnOpts);
-    // Pipe stdio if not inherited
-    if (child.stderr) child.stderr.on('data', function(chunk) {
-        _process.stderr.write(chunk);
+        shell: false,
+        detached: _process.platform !== 'win32',
+        windowsHide: true
     });
-    // Attach lifecycle logging
-    child.on('exit', function(code, sig) {
-        return _loggerts.logger.info("[".concat(name, "] exited (code=").concat(code, ", signal=").concat(sig || 'none', ")"));
+    if (child.stderr) child.stderr.on('data', function(chunk) {
+        return _process.stderr.write(chunk);
     });
-    child.on('error', function(err) {
-        return _loggerts.logger.info("[".concat(name, "] process error: ").concat(err.message));
+    var isClosed = false;
+    var _closeEventValue;
+    var closeEvent = new Promise(function(resolve) {
+        child.once('close', function(code, signal) {
+            isClosed = true;
+            _closeEventValue = {
+                code: code,
+                signal: signal
+            };
+            _loggerts.logger.info("[".concat(name, "] closed (code=").concat(code, ", signal=").concat(signal || 'none', ")"));
+            resolve({
+                code: code,
+                signal: signal
+            });
+        });
+        child.once('error', function(error) {
+            return _loggerts.logger.info("[".concat(name, "] process error: ").concat(error.message));
+        });
     });
-    // Create stop function with graceful shutdown
-    var stop = function stop() {
-        var signal = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 'SIGINT', _$opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    var tree = child.pid && _process.platform !== 'win32' ? new _ownedprocesstreets.OwnedProcessTree(child.pid) : undefined;
+    var closePromise;
+    var performClose = function performClose(signal, timeoutMs) {
         return _async_to_generator(function() {
-            var _opts_timeoutMs, timeoutMs, closePromise;
+            var timedOut, killed, errors, stopSucceeded, error, completion, termination;
             return _ts_generator(this, function(_state) {
-                // If already exited, return immediately
-                if (child.exitCode !== null || child.signalCode !== null) {
-                    return [
-                        2,
-                        {
-                            timedOut: false,
-                            killed: false
+                switch(_state.label){
+                    case 0:
+                        if (!!child.pid) return [
+                            3,
+                            2
+                        ];
+                        return [
+                            4,
+                            waitForChildClose(closeEvent, timeoutMs)
+                        ];
+                    case 1:
+                        _state.sent();
+                        throw new Error("Cannot verify shutdown of server '".concat(name, "' because it has no process ID"));
+                    case 2:
+                        timedOut = false;
+                        killed = false;
+                        errors = [];
+                        stopSucceeded = false;
+                        if (!opts.stop) return [
+                            3,
+                            7
+                        ];
+                        _state.label = 3;
+                    case 3:
+                        _state.trys.push([
+                            3,
+                            5,
+                            ,
+                            6
+                        ]);
+                        return [
+                            4,
+                            runStopCommand(opts.stop, cwd, timeoutMs, inheritEnv)
+                        ];
+                    case 4:
+                        _state.sent();
+                        stopSucceeded = true;
+                        return [
+                            3,
+                            6
+                        ];
+                    case 5:
+                        error = _state.sent();
+                        errors.push(withCause("Server '".concat(name, "' application stop command failed: ").concat(asError(error).message), asError(error)));
+                        return [
+                            3,
+                            6
+                        ];
+                    case 6:
+                        return [
+                            3,
+                            8
+                        ];
+                    case 7:
+                        if (child.stdin && !child.stdin.destroyed && !child.stdin.writableEnded) {
+                            child.stdin.end();
+                        } else if (_process.platform !== 'win32') {
+                            try {
+                                requestProcessSignal(child, signal);
+                            } catch (error) {
+                                errors.push(withCause("Server '".concat(name, "' cooperative signal failed: ").concat(asError(error).message), asError(error)));
+                            }
                         }
-                    ];
-                }
-                timeoutMs = (_opts_timeoutMs = _$opts.timeoutMs) !== null && _opts_timeoutMs !== void 0 ? _opts_timeoutMs : 500;
-                // Wait for 'close' event (process exit + stdio streams closed)
-                // This is better than 'exit' because it ensures stdio is fully cleaned up
-                closePromise = new Promise(function(resolve, reject) {
-                    var isResolved = false;
-                    var wasKilled = false;
-                    var timedOut = false;
-                    var resolveOnce = function resolveOnce(didTimeout) {
-                        if (isResolved) return;
-                        isResolved = true;
-                        clearTimeout(timeout);
-                        resolve({
-                            timedOut: didTimeout,
-                            killed: wasKilled
-                        });
-                    };
-                    var rejectOnce = function rejectOnce(error) {
-                        if (isResolved) return;
-                        isResolved = true;
-                        clearTimeout(timeout);
-                        reject(error);
-                    };
-                    // Set timeout for forceful kill
-                    var timeout = setTimeout(function() {
+                        _state.label = 8;
+                    case 8:
+                        return [
+                            4,
+                            waitForCompletion(closeEvent, function() {
+                                return isClosed;
+                            }, tree, timeoutMs)
+                        ];
+                    case 9:
+                        completion = _state.sent();
+                        if (completion.error) errors.push(withCause("Could not inspect the owned process tree for server '".concat(name, "'"), completion.error));
+                        if (!!isCompletionSuccessful(completion)) return [
+                            3,
+                            12
+                        ];
                         timedOut = true;
-                        var forceKill = function forceKill() {
-                            return _async_to_generator(function() {
-                                var error;
-                                return _ts_generator(this, function(_state) {
-                                    switch(_state.label){
-                                        case 0:
-                                            _state.trys.push([
-                                                0,
-                                                4,
-                                                ,
-                                                5
-                                            ]);
-                                            if (!(_process.platform === 'win32' && child.pid)) return [
-                                                3,
-                                                2
-                                            ];
-                                            return [
-                                                4,
-                                                terminateWindowsProcessTree(child.pid, true)
-                                            ];
-                                        case 1:
-                                            _state.sent();
-                                            wasKilled = true;
-                                            return [
-                                                3,
-                                                3
-                                            ];
-                                        case 2:
-                                            if (child.exitCode === null && !child.killed) {
-                                                wasKilled = child.kill('SIGKILL');
-                                            }
-                                            _state.label = 3;
-                                        case 3:
-                                            resolveOnce(true);
-                                            return [
-                                                3,
-                                                5
-                                            ];
-                                        case 4:
-                                            error = _state.sent();
-                                            rejectOnce(_instanceof(error, Error) ? error : new Error(String(error)));
-                                            return [
-                                                3,
-                                                5
-                                            ];
-                                        case 5:
-                                            return [
-                                                2
-                                            ];
-                                    }
-                                });
-                            })();
-                        };
-                        void forceKill();
-                    }, timeoutMs);
-                    // Listen for 'close' event (not 'exit') to wait for stdio close
-                    child.once('close', function() {
-                        if (!timedOut) resolveOnce(false);
-                    });
-                    // Also listen for 'error' event in case spawn failed
-                    // This prevents promise from hanging forever if process never started
-                    child.once('error', function() {
-                        resolveOnce(false);
-                    });
-                    var requestShutdown = function requestShutdown() {
-                        return _async_to_generator(function() {
-                            var error;
-                            return _ts_generator(this, function(_state) {
-                                switch(_state.label){
-                                    case 0:
-                                        _state.trys.push([
-                                            0,
-                                            4,
-                                            ,
-                                            5
-                                        ]);
-                                        if (child.exitCode !== null || child.signalCode !== null) {
-                                            resolveOnce(false);
-                                            return [
-                                                2
-                                            ];
-                                        }
-                                        if (!(_process.platform === 'win32' && child.pid)) return [
-                                            3,
-                                            2
-                                        ];
-                                        return [
-                                            4,
-                                            terminateWindowsProcessTree(child.pid, false)
-                                        ];
-                                    case 1:
-                                        _state.sent();
-                                        return [
-                                            3,
-                                            3
-                                        ];
-                                    case 2:
-                                        if (!child.kill(signal)) {
-                                            resolveOnce(false);
-                                        }
-                                        _state.label = 3;
-                                    case 3:
-                                        return [
-                                            3,
-                                            5
-                                        ];
-                                    case 4:
-                                        error = _state.sent();
-                                        rejectOnce(_instanceof(error, Error) ? error : new Error(String(error)));
-                                        return [
-                                            3,
-                                            5
-                                        ];
-                                    case 5:
-                                        return [
-                                            2
-                                        ];
-                                }
-                            });
-                        })();
-                    };
-                    void requestShutdown();
-                });
-                return [
-                    2,
-                    closePromise
-                ];
+                        if (!(!opts.stop && child.stdin && _process.platform !== 'win32')) return [
+                            3,
+                            11
+                        ];
+                        try {
+                            requestProcessSignal(child, signal);
+                        } catch (error) {
+                            errors.push(withCause("Server '".concat(name, "' cooperative signal failed: ").concat(asError(error).message), asError(error)));
+                        }
+                        return [
+                            4,
+                            waitForCompletion(closeEvent, function() {
+                                return isClosed;
+                            }, tree, timeoutMs)
+                        ];
+                    case 10:
+                        completion = _state.sent();
+                        if (completion.error) errors.push(withCause("Could not inspect the owned process tree for server '".concat(name, "'"), completion.error));
+                        return [
+                            3,
+                            12
+                        ];
+                    case 11:
+                        if (!opts.stop && _process.platform !== 'win32' && !child.stdin) {
+                        // The first signal was sent before waiting for an inherited-stdio HTTP process.
+                        }
+                        _state.label = 12;
+                    case 12:
+                        if (!!isCompletionSuccessful(completion)) return [
+                            3,
+                            14
+                        ];
+                        termination = terminateChild(child, tree);
+                        killed || (killed = termination.killed);
+                        if (termination.error) errors.push(withCause("Emergency termination failed for server '".concat(name, "'"), termination.error));
+                        return [
+                            4,
+                            waitForCompletion(closeEvent, function() {
+                                return isClosed;
+                            }, tree, PROCESS_TERMINATION_TIMEOUT_MS)
+                        ];
+                    case 13:
+                        completion = _state.sent();
+                        if (!isCompletionSuccessful(completion)) {
+                            errors.push(new Error("Server '".concat(name, "' did not close").concat(completion.processGroupEmpty === false ? ' with its POSIX process group' : '', " after emergency termination")));
+                        }
+                        _state.label = 14;
+                    case 14:
+                        if (opts.stop && !stopSucceeded && errors.length === 0) {
+                            errors.push(new Error("Server '".concat(name, "' application stop command did not complete successfully")));
+                        }
+                        if (errors.length > 0) throw new AggregateError(errors, "Server '".concat(name, "' shutdown completed with ").concat(errors.length, " failure(s)"));
+                        return [
+                            2,
+                            {
+                                timedOut: timedOut,
+                                killed: killed
+                            }
+                        ];
+                }
             });
         })();
     };
+    var close = function close() {
+        var signal = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 'SIGINT', closeOptions = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+        var _closeOptions_timeoutMs;
+        closePromise !== null && closePromise !== void 0 ? closePromise : closePromise = performClose(signal, (_closeOptions_timeoutMs = closeOptions.timeoutMs) !== null && _closeOptions_timeoutMs !== void 0 ? _closeOptions_timeoutMs : DEFAULT_CLOSE_TIMEOUT_MS);
+        return closePromise;
+    };
     return {
         config: resolvedConfig,
         process: child,
-        close: stop
+        close: close
     };
 }
 /* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }