Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
fix(mcp): retain shutdown signals until cleanup succeeds
morluto8873b39770e8
diff --git a/src/main.ts b/src/main.tsindex 0743843ba..a01bd2398 100644--- a/src/main.ts+++ b/src/main.ts@@ -21,6 +21,7 @@ import {} from "./composition/optionalObservationProviders.js";import { createToolResultDelivery } from "./server/toolResult.js";import { createShutdown } from "./main/shutdown.js";+import { registerProcessShutdown } from "./main/processShutdown.js";const runtimeDependencies = (): RuntimeDependencies => ({env: process.env,@@ -29,18 +30,7 @@ const runtimeDependencies = (): RuntimeDependencies => ({setExitCode: (code) => {process.exitCode = code;},- registerShutdown: (handler) => {- process.once("SIGINT", handler);- process.once("SIGTERM", handler);- process.stdin.once("end", handler);- process.stdin.once("close", handler);- return () => {- process.off("SIGINT", handler);- process.off("SIGTERM", handler);- process.stdin.off("end", handler);- process.stdin.off("close", handler);- };- },+ registerShutdown: registerProcessShutdown,});/**diff --git a/src/main/processShutdown.ts b/src/main/processShutdown.tsnew file mode 100644index 000000000..1daa10268--- /dev/null+++ b/src/main/processShutdown.ts@@ -0,0 +1,38 @@+type ShutdownSignal = "SIGINT" | "SIGTERM";++interface ShutdownSignalSource {+ on(event: ShutdownSignal, listener: () => void): unknown;+ off(event: ShutdownSignal, listener: () => void): unknown;+}++interface ShutdownInputSource {+ once(event: "end" | "close", listener: () => void): unknown;+ off(event: "end" | "close", listener: () => void): unknown;+}++interface ProcessShutdownEvents {+ readonly signals: ShutdownSignalSource;+ readonly stdin: ShutdownInputSource;+}++const processShutdownEvents: ProcessShutdownEvents = {+ signals: process,+ stdin: process.stdin,+};++/** Register the process events that request shutdown and return their owner. */+export const registerProcessShutdown = (+ handler: () => void,+ events: ProcessShutdownEvents = processShutdownEvents,+): (() => void) => {+ events.signals.on("SIGINT", handler);+ events.signals.on("SIGTERM", handler);+ events.stdin.once("end", handler);+ events.stdin.once("close", handler);+ return () => {+ events.signals.off("SIGINT", handler);+ events.signals.off("SIGTERM", handler);+ events.stdin.off("end", handler);+ events.stdin.off("close", handler);+ };+};diff --git a/tests/boundary/mcp/shutdown.test.ts b/tests/boundary/mcp/shutdown.test.tsindex f1720bb62..7288ec71b 100644--- a/tests/boundary/mcp/shutdown.test.ts+++ b/tests/boundary/mcp/shutdown.test.ts@@ -1,3 +1,4 @@+import { EventEmitter } from "node:events";import type { StdioServerHandle } from "@modelcontextprotocol/server/stdio";import pino from "pino";import { expect, it } from "vitest";@@ -5,6 +6,7 @@ import { expect, it } from "vitest";import { createManagedBinarySession } from "../../../src/composition/binary.js";import { MCP_SHUTDOWN_FAILED } from "../../../src/main/messages.js";import { createShutdown } from "../../../src/main/shutdown.js";+import { registerProcessShutdown } from "../../../src/main/processShutdown.js";import type { RuntimeDependencies } from "../../../src/main/types.js";import { ProviderCleanupError } from "../../../src/domain/providerCleanupError.js";import { err, ok } from "../../../src/domain/result.js";@@ -209,3 +211,72 @@ it("retries only failed cleanup owners after concurrent shutdown requests", asyn2, 2, 1, 1,]);});++it("retries failed MCP cleanup owners on a repeated signal and unregisters after success", async () => {+ const signals = new EventEmitter();+ const stdin = new EventEmitter();+ const exitCodes: number[] = [];+ let handleCalls = 0;+ let androidCalls = 0;+ let sessionCalls = 0;+ let unregisterCalls = 0;+ const dependencies: RuntimeDependencies = {+ env: {},+ serve: () => {+ throw new Error("unused fixture transport");+ },+ writeStderr: () => undefined,+ setExitCode: (code) => exitCodes.push(code),+ registerShutdown: (handler) => {+ const unregister = registerProcessShutdown(handler, { signals, stdin });+ return () => {+ unregisterCalls += 1;+ unregister();+ };+ },+ };+ const session = createTestBinarySession(() => ({+ execute: async () => observed(null),+ close: async () => {+ sessionCalls += 1;+ return ok(null);+ },+ }));+ const [target] = await createBinarySessionTargets();+ if (target === undefined) throw new Error("Missing fixture target");+ expect((await session.open(target)).ok).toBe(true);+ createShutdown({+ handle: {+ close: async () => {+ handleCalls += 1;+ if (handleCalls === 1) throw new Error("first handle close failed");+ },+ },+ closeAndroid: async () => {+ androidCalls += 1;+ if (androidCalls === 1) throw new Error("first Android close failed");+ },+ session,+ dependencies,+ serverLogger: pino({ enabled: false }),+ });++ signals.emit("SIGTERM");+ await new Promise((resolve) => setImmediate(resolve));+ expect([handleCalls, androidCalls, sessionCalls, unregisterCalls]).toEqual([+ 1, 1, 1, 0,+ ]);+ expect(exitCodes).toEqual([1]);++ signals.emit("SIGTERM");+ await new Promise((resolve) => setImmediate(resolve));+ expect([handleCalls, androidCalls, sessionCalls, unregisterCalls]).toEqual([+ 2, 2, 1, 1,+ ]);++ signals.emit("SIGTERM");+ await new Promise((resolve) => setImmediate(resolve));+ expect([handleCalls, androidCalls, sessionCalls, unregisterCalls]).toEqual([+ 2, 2, 1, 1,+ ]);+});