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): retry failed shutdown resources and retain failure reasons
morlutoe64678e8f976
diff --git a/src/main/shutdown.ts b/src/main/shutdown.tsindex fac2571ab..f6722eb97 100644--- a/src/main/shutdown.ts+++ b/src/main/shutdown.ts@@ -8,6 +8,11 @@ import type { JsonValue } from "../domain/jsonValue.js";import type { RuntimeDependencies } from "./types.js";import { MCP_SHUTDOWN_FAILED } from "./messages.js";+interface ShutdownCleanupOwner {+ readonly close: () => Promise<void>;+ closed: boolean;+}+export const createShutdown = (input: {readonly handle: StdioServerHandle;readonly closeAndroid?: () => Promise<void>;@@ -19,22 +24,51 @@ export const createShutdown = (input: {readonly request: () => void;} => {const { handle, session, dependencies, serverLogger } = input;- let shutdownPromise: Promise<void> | undefined;+ let shutdownAttempt: Promise<void> | undefined;+ const cleanupOwners: ShutdownCleanupOwner[] = [+ { close: () => handle.close(), closed: false },+ ...(input.closeAndroid === undefined+ ? []+ : [{ close: input.closeAndroid, closed: false }]),+ {+ close: async () => {+ const closed = await session.close({ retainProviderDocuments: true });+ if (!closed.ok) throw closed.error;+ },+ closed: false,+ },+ ];+ let shutdownUnregistered = false;let unregisterShutdown = (): void => undefined;const shutdown = async (): Promise<void> => {- shutdownPromise ??= (async () => {- unregisterShutdown();- const results = await Promise.allSettled([- handle.close(),- input.closeAndroid?.(),- session.close({ retainProviderDocuments: true }).then((closed) => {- if (!closed.ok) throw closed.error;+ if (shutdownAttempt !== undefined) return shutdownAttempt;+ const pending = cleanupOwners.filter(({ closed }) => !closed);+ const attempt = (async () => {+ const results = await Promise.allSettled(+ pending.map(async (owner) => {+ await owner.close();+ owner.closed = true;}),- ]);+ );+ const failures: unknown[] = [];for (const result of results)- if (result.status === "rejected") throw result.reason;+ if (result.status === "rejected") failures.push(result.reason);+ if (failures.length === 1) throw failures[0];+ if (failures.length > 1)+ throw new AggregateError(+ failures,+ "Multiple MCP cleanup operations failed",+ );+ if (!shutdownUnregistered) {+ unregisterShutdown();+ shutdownUnregistered = true;+ }})();- return shutdownPromise;+ shutdownAttempt = attempt;+ void attempt.catch(() => {+ if (shutdownAttempt === attempt) shutdownAttempt = undefined;+ });+ return attempt;};const requestShutdown = (): void => {shutdown().catch((cause: unknown) => {@@ -55,26 +89,47 @@ export const createShutdown = (input: {const describeShutdownFailure = (cause: unknown,+): Readonly<Record<string, JsonValue>> =>+ describeShutdownFailureNode(cause, new WeakSet<object>());++const describeShutdownFailureNode = (+ cause: unknown,+ active: WeakSet<object>,): Readonly<Record<string, JsonValue>> => {- if (cause instanceof AnalysisError)- return { analysis_error: projectAnalysisError(cause) };- if (cause instanceof Error) {- const code = "code" in cause ? cause.code : undefined;- return {- name: cause.name,- message: cause.message,- ...(typeof code === "string" ||- (typeof code === "number" && Number.isFinite(code))- ? { code }- : {}),- };+ if (typeof cause === "object" && cause !== null) {+ if (active.has(cause)) return { type: "cyclic_error" };+ active.add(cause);+ }+ try {+ if (cause instanceof AnalysisError)+ return { analysis_error: projectAnalysisError(cause) };+ if (cause instanceof Error) {+ const code = "code" in cause ? cause.code : undefined;+ return {+ name: cause.name,+ message: cause.message,+ ...(typeof code === "string" ||+ (typeof code === "number" && Number.isFinite(code))+ ? { code }+ : {}),+ ...(cause instanceof AggregateError+ ? {+ errors: cause.errors.map((error: unknown) =>+ describeShutdownFailureNode(error, active),+ ),+ }+ : {}),+ };+ }+ if (+ cause === null ||+ typeof cause === "string" ||+ typeof cause === "boolean" ||+ (typeof cause === "number" && Number.isFinite(cause))+ )+ return { type: cause === null ? "null" : typeof cause, value: cause };+ return { type: typeof cause };+ } finally {+ if (typeof cause === "object" && cause !== null) active.delete(cause);}- if (- cause === null ||- typeof cause === "string" ||- typeof cause === "boolean" ||- (typeof cause === "number" && Number.isFinite(cause))- )- return { type: cause === null ? "null" : typeof cause, value: cause };- return { type: typeof cause };};diff --git a/tests/boundary/mcp/shutdown.test.ts b/tests/boundary/mcp/shutdown.test.tsindex c939fbbc7..f1720bb62 100644--- a/tests/boundary/mcp/shutdown.test.ts+++ b/tests/boundary/mcp/shutdown.test.ts@@ -116,5 +116,96 @@ it("reports a typed binary cleanup failure and retains the client for retry", as]);expect(retainDocument).toBe(true);cleanupAllowed = true;+ requests[0]?.();+ await new Promise((resolve) => setImmediate(resolve));expect((await session.close()).ok).toBe(true);});++it("retries only failed cleanup owners after concurrent shutdown requests", async () => {+ const requests: Array<() => void> = [];+ const logs: string[] = [];+ const exitCodes: number[] = [];+ let unregisterCount = 0;+ let handleCalls = 0;+ let androidCalls = 0;+ let sessionCalls = 0;+ const dependencies: RuntimeDependencies = {+ env: {},+ serve: () => {+ throw new Error("unused fixture transport");+ },+ writeStderr: () => undefined,+ setExitCode: (code) => exitCodes.push(code),+ registerShutdown: (request) => {+ requests.push(request);+ return () => {+ unregisterCount += 1;+ };+ },+ };+ 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);+ const lifecycle = 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(+ { level: "debug" },+ { write: (line) => logs.push(line) },+ ),+ });++ const first = lifecycle.shutdown();+ const concurrent = lifecycle.shutdown();+ requests[0]?.();+ await expect(first).rejects.toBeInstanceOf(AggregateError);+ await expect(concurrent).rejects.toBeInstanceOf(AggregateError);+ await expect(first).rejects.toMatchObject({+ errors: [+ { message: "first handle close failed" },+ { message: "first Android close failed" },+ ],+ });+ await new Promise((resolve) => setImmediate(resolve));+ expect(exitCodes).toEqual([1]);+ expect(logs.map((line) => JSON.parse(line))).toContainEqual(+ expect.objectContaining({+ msg: "MCP shutdown rejected",+ failure_cause: expect.objectContaining({+ errors: [+ expect.objectContaining({ message: "first handle close failed" }),+ expect.objectContaining({ message: "first Android close failed" }),+ ],+ }),+ }),+ );+ expect([handleCalls, androidCalls, sessionCalls, unregisterCount]).toEqual([+ 1, 1, 1, 0,+ ]);++ await lifecycle.shutdown();+ expect([handleCalls, androidCalls, sessionCalls, unregisterCount]).toEqual([+ 2, 2, 1, 1,+ ]);+ await lifecycle.shutdown();+ expect([handleCalls, androidCalls, sessionCalls, unregisterCount]).toEqual([+ 2, 2, 1, 1,+ ]);+});