@evantahler/mcpx 0.21.5 → 0.21.6

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@evantahler/mcpx",
-	"version": "0.21.5",
+	"version": "0.21.6",
 	"description": "A command-line interface for MCP servers. curl for MCP.",
 	"type": "module",
 	"exports": {

package/src/cli.ts

@@ -22,8 +22,11 @@ import { registerSkillCommand } from "./commands/skill.ts";
 import { registerTaskCommand } from "./commands/task.ts";
 import { registerUpgradeCommand } from "./commands/upgrade.ts";
 import { logger } from "./output/logger.ts";
+import { ExitError, installSignalHandlers } from "./shutdown.ts";
 import { maybeCheckForUpdate } from "./update/background.ts";
 
+installSignalHandlers();
+
 program
 	.name("mcpx")
 	.description("A command-line interface for MCP servers. curl for MCP.")
@@ -92,7 +95,15 @@ if (firstCommand && !knownCommands.has(firstCommand)) {
 // Fire-and-forget background update check
 const updateNotice = maybeCheckForUpdate();
 
-program.parse();
+try {
+	await program.parseAsync();
+} catch (err) {
+	if (err instanceof ExitError) {
+		process.exit(err.code);
+	}
+	logger.error(String(err));
+	process.exit(1);
+}
 
 // Print update notice after command output completes
 process.on("beforeExit", async () => {

package/src/client/manager.ts

@@ -20,6 +20,7 @@ import pkg from "../../package.json";
 import type { AuthFile, Prompt, Resource, ServerConfig, ServersFile, Tool } from "../config/schemas.ts";
 import { isHttpServer, isStdioServer } from "../config/schemas.ts";
 import { logger } from "../output/logger.ts";
+import { register, unregister } from "../shutdown.ts";
 import { handleElicitation } from "./elicitation.ts";
 import { createHttpTransport } from "./http.ts";
 import { McpOAuthProvider } from "./oauth.ts";
@@ -97,6 +98,7 @@ export class ServerManager {
 		this.logLevel = opts.logLevel ?? "warning";
 		this.json = opts.json ?? false;
 		this.noInteractive = opts.noInteractive ?? false;
+		register(this);
 	}
 
 	/** Get or create a connected client for a server */
@@ -492,16 +494,19 @@ export class ServerManager {
 
 	/** Disconnect all clients */
 	async close(): Promise<void> {
-		const closePromises = [...this.clients.entries()].map(async ([name, client]) => {
+		unregister(this);
+		// Close every transport — covers in-flight connects whose client hasn't been promoted
+		// into `this.clients` yet (otherwise stdio children would be orphaned on shutdown).
+		const closePromises = [...this.transports.values()].map(async (transport) => {
 			try {
-				await client.close();
+				await transport.close?.();
 			} catch {
 				// Ignore close errors
 			}
-			this.clients.delete(name);
-			this.transports.delete(name);
 		});
 		await Promise.allSettled(closePromises);
+		this.clients.clear();
+		this.transports.clear();
 		this.connecting.clear();
 	}
 }

package/src/commands/exec.ts

@@ -13,6 +13,7 @@ import {
 	formatValidationErrors,
 } from "../output/formatter.ts";
 import { logger } from "../output/logger.ts";
+import { ExitError } from "../shutdown.ts";
 import { validateToolInput } from "../validation/schema.ts";
 
 type ResolvedArgs =
@@ -268,10 +269,10 @@ export function registerExecCommand(program: Command) {
 						for (const elicitation of err.elicitations) {
 							await handleUrlElicitation(elicitation, elicitOptions);
 						}
-						process.exit(1);
+						throw new ExitError(1);
 					}
 					console.error(formatError(String(err), formatOptions));
-					process.exit(1);
+					throw new ExitError(1);
 				} finally {
 					await manager.close();
 				}

package/src/commands/with-command.ts

@@ -2,6 +2,7 @@ import type { Command } from "commander";
 import { type AppContext, getContext } from "../context.ts";
 import { formatError } from "../output/formatter.ts";
 import { logger, type Spinner } from "../output/logger.ts";
+import { ExitError } from "../shutdown.ts";
 
 export interface CommandContext extends AppContext {
 	spinner: Spinner;
@@ -47,9 +48,10 @@ export function withCommand<TArgs extends unknown[]>(
 		try {
 			await handler({ ...appCtx, spinner }, ...args);
 		} catch (err) {
+			if (err instanceof ExitError) throw err;
 			spinner.error(options.errorLabel ?? "Failed");
 			console.error(formatError(String(err), formatOptions));
-			process.exit(1);
+			throw new ExitError(1);
 		} finally {
 			await manager.close();
 		}

package/src/shutdown.ts

@@ -0,0 +1,65 @@
+import { logger } from "./output/logger.ts";
+
+export interface Closeable {
+	close(): Promise<void>;
+}
+
+export class ExitError extends Error {
+	constructor(
+		public readonly code: number,
+		message?: string,
+	) {
+		super(message);
+		this.name = "ExitError";
+	}
+}
+
+const registry = new Set<Closeable>();
+let shuttingDown = false;
+
+export function register(c: Closeable): void {
+	registry.add(c);
+}
+
+export function unregister(c: Closeable): void {
+	registry.delete(c);
+}
+
+const HARD_TIMEOUT_MS = 8000;
+
+async function runShutdown(exitCode: number): Promise<never> {
+	if (shuttingDown) {
+		process.exit(exitCode);
+	}
+	shuttingDown = true;
+
+	const closeAll = Promise.allSettled([...registry].map((c) => c.close()));
+	await Promise.race([closeAll, new Promise<void>((resolve) => setTimeout(resolve, HARD_TIMEOUT_MS).unref())]);
+	process.exit(exitCode);
+}
+
+let installed = false;
+
+export function installSignalHandlers(): void {
+	if (installed) return;
+	installed = true;
+
+	process.on("SIGINT", () => {
+		void runShutdown(130);
+	});
+	process.on("SIGTERM", () => {
+		void runShutdown(143);
+	});
+	process.on("SIGHUP", () => {
+		void runShutdown(129);
+	});
+	process.on("uncaughtException", (err) => {
+		logger.error(`uncaught exception: ${err?.stack ?? String(err)}`);
+		void runShutdown(1);
+	});
+	process.on("unhandledRejection", (reason) => {
+		const detail = reason instanceof Error ? (reason.stack ?? reason.message) : String(reason);
+		logger.error(`unhandled rejection: ${detail}`);
+		void runShutdown(1);
+	});
+}