Skip to content

armgit / rea

Public Imported from GitHub
0

Reverse engineer anything with agents, from app behavior down to native binaries.

fix(mcp): retry failed shutdown resources and retain failure reasons

morlutoe64678e8f976
diff --git a/src/main/shutdown.ts b/src/main/shutdown.ts
index 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.ts
index 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,
+ ]);
+});