Skip to content

armgit / rea

Public Imported from GitHub
0

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

fix(gdb): gate readiness and retain caller cancellation through cleanup

morluto696832caa3cf
diff --git a/src/gdb/GdbSessionManager.ts b/src/gdb/GdbSessionManager.ts
index dc517aadc..dcde0c90f 100644
--- a/src/gdb/GdbSessionManager.ts
+++ b/src/gdb/GdbSessionManager.ts
@@ -43,6 +43,30 @@ const DEFAULT_MAX_SESSIONS = 8;
const MAX_PENDING_GDB_COMMANDS = 16;
const RECENT_RECORD_TRUNCATION_MARKER = "[recent record truncated]";
+const cancelledWithCallerReason = (
+ operation: string,
+ signal: AbortSignal,
+ previous?: AnalysisCancelledError,
+): AnalysisCancelledError => {
+ const cancellation = new AnalysisCancelledError(operation, {
+ cause: signal.reason,
+ cleanupPrimary: previous,
+ ...(previous?.diagnostics === undefined
+ ? {}
+ : { diagnostics: previous.diagnostics }),
+ ...(previous?.capturedOutput === undefined
+ ? {}
+ : { capturedOutput: previous.capturedOutput }),
+ ...(previous?.cleanup === undefined ? {} : { cleanup: previous.cleanup }),
+ ...(previous?.partialObservation === undefined
+ ? {}
+ : { partialObservation: previous.partialObservation }),
+ });
+ if (previous?.cleanupIncomplete)
+ cancellation.bindCleanupDependencies([previous]);
+ return cancellation;
+};
+
export const GDB_PROVIDER_IDENTITY = {
id: "gnu.gdb",
name: "GNU GDB",
@@ -572,7 +596,11 @@ export class GdbSessionManager {
]),
);
if (this.#closing || signal?.aborted)
- return err(new AnalysisCancelledError("start_gdb_session"));
+ return err(
+ signal?.aborted
+ ? cancelledWithCallerReason("start_gdb_session", signal)
+ : new AnalysisCancelledError("start_gdb_session"),
+ );
if (this.#platform !== "linux")
return err(
new AnalysisCapabilityUnavailableError(
@@ -584,7 +612,12 @@ export class GdbSessionManager {
),
);
const controller = new AbortController();
- const relayAbort = (): void => controller.abort(signal?.reason);
+ let callerAbortWon = false;
+ const relayAbort = (): void => {
+ if (controller.signal.aborted) return;
+ callerAbortWon = true;
+ controller.abort(signal?.reason);
+ };
signal?.addEventListener("abort", relayAbort, { once: true });
if (signal?.aborted) relayAbort();
const tracked = Promise.resolve()
@@ -594,7 +627,20 @@ export class GdbSessionManager {
this.#activeStarts.delete(controller);
});
this.#activeStarts.set(controller, tracked);
- return tracked;
+ return tracked.then((result) =>
+ !result.ok &&
+ result.error instanceof AnalysisCancelledError &&
+ callerAbortWon &&
+ signal !== undefined
+ ? err(
+ cancelledWithCallerReason(
+ "start_gdb_session",
+ signal,
+ result.error,
+ ),
+ )
+ : result,
+ );
}
async #startWithReservation(
@@ -688,7 +734,10 @@ export class GdbSessionManager {
};
launched = await this.#spawnProcess(spawnOptions);
} catch (cause) {
- if (signal?.aborted || cause instanceof AnalysisCancelledError)
+ if (
+ (signal?.aborted && cause === signal.reason) ||
+ cause instanceof AnalysisCancelledError
+ )
return err(new AnalysisCancelledError("start_gdb_session", { cause }));
return err(
new AnalysisCapabilityUnavailableError(
@@ -808,7 +857,6 @@ export class GdbSessionManager {
);
startupTimer.unref();
});
- session.ready = true;
if (signal?.aborted)
throw new AnalysisCancelledError("start_gdb_session");
const autoLoad = await this.#request(
@@ -873,8 +921,11 @@ export class GdbSessionManager {
throw new Error(
session.protocolError ?? "GDB exited during startup readiness.",
);
- // Before this point no target command can run. Once a usable session is
- // published, the inferior state is no longer inferred from startup phase.
+ // Publish readiness only after every mandatory startup check completes.
+ // Retained failed-start owners remain addressable for cleanup, not work.
+ session.ready = true;
+ // Before publication no target command can run. Once usable, the
+ // inferior state is no longer inferred from startup phase.
session.noInferiorVerified = false;
this.#sessions.set(id, session);
releaseReservation();
@@ -981,6 +1032,16 @@ export class GdbSessionManager {
if (stopped.status === "incomplete") {
this.#sessions.set(id, session);
releaseReservation();
+ const cleanupFailure = this.#retainCleanupFailure(
+ session,
+ "start_gdb_session",
+ stopped.reason,
+ { cause },
+ );
+ const retainCleanup = <T extends AnalysisError>(failure: T): T =>
+ failure.bindCleanupDependencies([cleanupFailure], {
+ cleanupResources: [session.id],
+ });
const cleanup = { reason: stopped.reason, resources: [session.id] };
const details = {
cause,
@@ -992,17 +1053,27 @@ export class GdbSessionManager {
};
if (cause instanceof AnalysisTimeoutError)
return err(
- new AnalysisTimeoutError(cause.operation, cause.timeoutMs, details),
+ retainCleanup(
+ new AnalysisTimeoutError(
+ cause.operation,
+ cause.timeoutMs,
+ details,
+ ),
+ ),
);
if (cause instanceof AnalysisCancelledError)
- return err(new AnalysisCancelledError(cause.operation, details));
+ return err(
+ retainCleanup(new AnalysisCancelledError(cause.operation, details)),
+ );
const startupFailureMessage = gdbErrorMessage(cause);
return err(
- new AnalysisCapabilityUnavailableError(
- "gdb",
- "start_gdb_session",
- `GDB startup failed (${startupFailureMessage}) and its owned process could not be confirmed stopped: ${stopped.reason}`,
- details,
+ retainCleanup(
+ new AnalysisCapabilityUnavailableError(
+ "gdb",
+ "start_gdb_session",
+ `GDB startup failed (${startupFailureMessage}) and its owned process could not be confirmed stopped: ${stopped.reason}`,
+ details,
+ ),
),
);
}
@@ -1014,7 +1085,7 @@ export class GdbSessionManager {
: { partialObservation: startupEvidence }),
};
const error =
- signal?.aborted || cause instanceof AnalysisCancelledError
+ cause instanceof AnalysisCancelledError
? new AnalysisCancelledError("start_gdb_session", errorDetails)
: cause instanceof AnalysisTimeoutError
? new AnalysisTimeoutError(
@@ -1078,7 +1149,8 @@ export class GdbSessionManager {
},
]),
);
- if (signal?.aborted) return err(new AnalysisCancelledError("gdb_console"));
+ if (signal?.aborted)
+ return err(cancelledWithCallerReason("gdb_console", signal));
try {
const completed = await this.#serialize(
session,
@@ -2047,28 +2119,51 @@ export class GdbSessionManager {
"A GDB MI command was cancelled; owned-session shutdown was requested because output correlation can no longer be guaranteed.";
void this.#stopDebuggerOnly(session).then(
(stopped) => {
+ if (stopped.status !== "incomplete") {
+ pending.reject(
+ new AnalysisCancelledError("gdb_console", {
+ cause: signal?.reason,
+ partialObservation: evidence,
+ }),
+ );
+ return;
+ }
+ const cleanupFailure = this.#retainCleanupFailure(
+ session,
+ "gdb_console",
+ stopped.reason,
+ );
pending.reject(
- stopped.status === "incomplete"
- ? new AnalysisCancelledError("gdb_console", {
- cause: new Error(stopped.reason),
- cleanup: {
- reason: stopped.reason,
- resources: [session.id],
- },
- partialObservation: evidence,
- })
- : new AnalysisCancelledError("gdb_console", {
- partialObservation: evidence,
- }),
+ new AnalysisCancelledError("gdb_console", {
+ cause: signal?.reason,
+ cleanup: {
+ reason: stopped.reason,
+ resources: [session.id],
+ },
+ partialObservation: evidence,
+ }).bindCleanupDependencies([cleanupFailure], {
+ cleanupResources: [session.id],
+ }),
);
},
- (cause: unknown) =>
+ (cause: unknown) => {
+ const reason = gdbErrorMessage(cause);
+ const cleanupFailure = this.#retainCleanupFailure(
+ session,
+ "gdb_console",
+ reason,
+ { cause },
+ );
pending.reject(
new AnalysisCancelledError("gdb_console", {
- cause,
+ cause: signal?.reason,
+ cleanup: { reason, resources: [session.id] },
partialObservation: evidence,
+ }).bindCleanupDependencies([cleanupFailure], {
+ cleanupResources: [session.id],
}),
- ),
+ );
+ },
);
};
signal?.addEventListener("abort", abortListener, { once: true });
@@ -2223,17 +2318,21 @@ export const commandMayChangeInferiorOutput = (command: string): boolean => {
);
};
-/** Terminate only the directly owned debugger process, never its process group or inferiors. */
+/** Await a serialized command turn, preserving the caller's cancellation reason. */
export const waitForGdbCommandTurn = (
previous: Promise<void>,
signal?: AbortSignal,
): Promise<void> => {
if (signal === undefined) return previous;
if (signal.aborted)
- return Promise.reject(new AnalysisCancelledError("gdb_console"));
+ return Promise.reject(
+ new AnalysisCancelledError("gdb_console", { cause: signal.reason }),
+ );
return new Promise<void>((resolve, reject) => {
const onAbort = (): void =>
- reject(new AnalysisCancelledError("gdb_console"));
+ reject(
+ new AnalysisCancelledError("gdb_console", { cause: signal.reason }),
+ );
signal.addEventListener("abort", onAbort, { once: true });
previous.then(
() => {
diff --git a/tests/boundary/mcp/gdbCancellationMcp.test.ts b/tests/boundary/mcp/gdbCancellationMcp.test.ts
index 79b7f1fce..9281ad63a 100644
--- a/tests/boundary/mcp/gdbCancellationMcp.test.ts
+++ b/tests/boundary/mcp/gdbCancellationMcp.test.ts
@@ -18,6 +18,7 @@ import { thinMach } from "../../../src/domain/binaryTarget.fixture.js";
import { err, ok } from "../../../src/domain/result.js";
import { GdbSessionManager } from "../../../src/gdb/GdbSessionManager.js";
import { silentLogger } from "../../../src/logger.js";
+import { stopOwnedDebuggerProcess } from "../../../src/process/ownedDebuggerSession.js";
import { registerGdbTools } from "../../../src/server/registerGdbTools.js";
import type { GdbToolManager } from "../../../src/server/registerGdbTools.js";
import { createToolResultDelivery } from "../../../src/server/toolResult.js";
@@ -31,6 +32,106 @@ import {
waitForStartedFile,
} from "../../support/reverseDebuggerMcpTestHelpers.js";
+it.skipIf(process.platform === "win32")(
+ "keeps a failed GDB startup closed through MCP and retries its retained owner before console admission",
+ async () => {
+ const directory = await mkdtemp(join(tmpdir(), "rea-gdb-mcp-startup-"));
+ const provider = join(directory, "fake-gdb.mjs");
+ await writeFile(
+ provider,
+ `#!${process.execPath}
+process.stdout.write("(gdb)\\n");
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (chunk) => {
+ for (const line of chunk.split("\\n")) {
+ const match = /^(\\d+)/.exec(line);
+ if (!match) continue;
+ process.stdout.write(match[1] + (line.includes("auto-load off")
+ ? "^error,msg=\\"setting rejected\\"\\n"
+ : "^done\\n"));
+ }
+});
+`,
+ );
+ await chmod(provider, 0o700);
+ let stopCalls = 0;
+ let exitedDuringRetry = false;
+ const manager = new GdbSessionManager({
+ platform: "linux",
+ environment: { REA_GDB_COMMAND: provider },
+ stopProcess: async (session, name) => {
+ stopCalls += 1;
+ if (stopCalls === 1)
+ return {
+ status: "incomplete",
+ reason: "simulated startup stop uncertainty",
+ };
+ const stopped = await stopOwnedDebuggerProcess(session, name);
+ exitedDuringRetry = session.exited;
+ return stopped;
+ },
+ });
+ const server = new McpServer({
+ name: "gdb-startup-readiness",
+ version: "1",
+ });
+ registerGdbTools(
+ server,
+ manager,
+ silentLogger,
+ createToolResultDelivery(undefined),
+ );
+ const client = new Client({ name: "gdb-startup-readiness", version: "1" });
+ const [clientTransport, serverTransport] =
+ InMemoryTransport.createLinkedPair();
+ try {
+ await server.connect(serverTransport);
+ await client.connect(clientTransport);
+ const started = await client.callTool({
+ name: "start_gdb_session",
+ arguments: {},
+ });
+ expect(started.isError).toBe(true);
+ expect(started.structuredContent).toMatchObject({
+ error: {
+ code: "cleanup_incomplete",
+ details: {
+ cleanup_reason: "simulated startup stop uncertainty",
+ resources: [expect.stringMatching(/^[0-9a-f-]{36}$/u)],
+ },
+ },
+ });
+ const failure = z
+ .object({
+ error: z.object({
+ details: z.object({ resources: z.tuple([z.string().uuid()]) }),
+ }),
+ })
+ .parse(started.structuredContent);
+ const sessionId = failure.error.details.resources[0];
+ expect(stopCalls).toBe(1);
+ expect(manager.status(sessionId)?.state).toBe("closed");
+ expect(exitedDuringRetry).toBe(false);
+
+ const command = await client.callTool({
+ name: "gdb_console",
+ arguments: { session_id: sessionId, command: "show version" },
+ });
+ expect(command.isError).toBe(true);
+ expect(command.structuredContent).toMatchObject({
+ error: { code: "invalid_request" },
+ });
+ expect(stopCalls).toBe(2);
+ expect(exitedDuringRetry).toBe(true);
+ expect(manager.status(sessionId)).toBeUndefined();
+ } finally {
+ await Promise.allSettled([client.close(), server.close()]);
+ await manager.closeAll().catch(() => undefined);
+ await rm(directory, { recursive: true, force: true });
+ }
+ },
+);
+
it.skipIf(process.platform === "win32")(
"propagates MCP cancellation into a running GDB command",
async () => {
diff --git a/tests/boundary/providers/GdbSessionManagerCoverage.test.ts b/tests/boundary/providers/GdbSessionManagerCoverage.test.ts
index 9b768dc01..53233ce13 100644
--- a/tests/boundary/providers/GdbSessionManagerCoverage.test.ts
+++ b/tests/boundary/providers/GdbSessionManagerCoverage.test.ts
@@ -7,7 +7,10 @@ import { PassThrough } from "node:stream";
import { afterEach, expect, it } from "vitest";
-import { AnalysisTimeoutError } from "../../../src/domain/analysisErrorCore.js";
+import {
+ AnalysisCancelledError,
+ AnalysisTimeoutError,
+} from "../../../src/domain/analysisErrorCore.js";
import {
commandMayChangeInferiorOutput,
gdbErrorMessage,
@@ -324,20 +327,25 @@ const recordingInferiorListResponder = (groups: string) => {
it("returns cancellation when GDB startup is aborted after spawn", async () => {
const controller = new AbortController();
+ const reason = { source: "caller startup cancellation" };
const fake = createFakeSpawner(undefined, {
- afterSpawn: () => controller.abort(),
+ afterSpawn: () => controller.abort(reason),
});
const manager = managerWithFakeSpawner(fake.spawnProcess);
const started = await manager.start(controller.signal);
expect(started.ok).toBe(false);
- if (!started.ok) expect(started.error._tag).toBe("AnalysisCancelledError");
+ if (!started.ok) {
+ expect(started.error._tag).toBe("AnalysisCancelledError");
+ expect(started.error.cause).toBe(reason);
+ }
expect(fake.children[0]?.signalCode).toBe("SIGTERM");
});
it("cancels immediately after the startup prompt before sending configuration commands", async () => {
const controller = new AbortController();
+ const reason = new Error("caller cancelled after prompt");
const commands: string[] = [];
const fake = createFakeSpawner(
(child, token, command) => {
@@ -346,7 +354,7 @@ it("cancels immediately after the startup prompt before sending configuration co
},
{
deferPrompt: true,
- afterPrompt: () => controller.abort(),
+ afterPrompt: () => controller.abort(reason),
},
);
const manager = managerWithFakeSpawner(fake.spawnProcess);
@@ -358,6 +366,7 @@ it("cancels immediately after the startup prompt before sending configuration co
error: { _tag: "AnalysisCancelledError" },
});
expect(commands).toEqual([]);
+ if (!started.ok) expect(started.error.cause).toBe(reason);
expect(fake.children[0]?.killSignals).toEqual(["SIGTERM"]);
});
@@ -376,14 +385,41 @@ it("rejects a GDB exit queued with the final startup response", async () => {
expect(fake.children[0]?.exitCode).toBe(7);
});
+it("keeps a consumed startup failure primary when caller abort arrives during cleanup", async () => {
+ const controller = new AbortController();
+ const reason = { source: "late caller cancellation" };
+ const fake = createFakeSpawner((_child, token, command) => {
+ if (command.includes("auto-load off"))
+ _child.stdout.write(`${token}^error,msg="configuration rejected"\n`);
+ });
+ const manager = managerWithFakeSpawner(fake.spawnProcess, {
+ stopProcess: async () => {
+ controller.abort(reason);
+ return { status: "stopped" };
+ },
+ });
+
+ const started = await manager.start(controller.signal);
+
+ expect(started).toMatchObject({
+ ok: false,
+ error: { _tag: "AnalysisCapabilityUnavailableError" },
+ });
+ if (!started.ok)
+ expect(started.error.cause).toMatchObject({
+ _tag: "AnalysisCapabilityUnavailableError",
+ });
+});
+
it("cancels startup when aborted during the final readiness drain", async () => {
const controller = new AbortController();
+ const reason = "caller cancelled during readiness drain";
const commands: string[] = [];
const fake = createFakeSpawner((child, token, command) => {
commands.push(command);
child.stdout.write(`${token}^done\n`);
if (command.includes("auto-load off"))
- setImmediate(() => controller.abort());
+ setImmediate(() => controller.abort(reason));
});
const manager = managerWithFakeSpawner(fake.spawnProcess);
@@ -394,15 +430,17 @@ it("cancels startup when aborted during the final readiness drain", async () =>
error: { _tag: "AnalysisCancelledError" },
});
expect(commands).toEqual(["-gdb-set auto-load off"]);
+ if (!started.ok) expect(started.error.cause).toBe(reason);
expect(fake.children[0]?.killSignals).toEqual(["SIGTERM"]);
});
it("preserves cancellation and cleanup details when startup stop is uncertain", async () => {
const controller = new AbortController();
+ const reason = { source: "startup caller", token: 7 };
let stopCalls = 0;
const fake = createFakeSpawner(undefined, {
deferPrompt: true,
- afterPrompt: () => controller.abort(),
+ afterPrompt: () => controller.abort(reason),
});
const manager = managerWithFakeSpawner(fake.spawnProcess, {
stopProcess: async (session, name) => {
@@ -426,6 +464,66 @@ it("preserves cancellation and cleanup details when startup stop is uncertain",
cleanup: { reason: "simulated startup cancellation cleanup uncertainty" },
},
});
+ if (!started.ok) expect(started.error.cause).toBe(reason);
+});
+
+it("keeps manager-close cancellation primary when caller abort arrives during startup cleanup", async () => {
+ const caller = new AbortController();
+ const callerReason = { source: "late caller abort", token: Symbol("opaque") };
+ let commandEntered!: () => void;
+ const commandStarted = new Promise<void>((resolve) => {
+ commandEntered = resolve;
+ });
+ let cleanupEntered!: () => void;
+ const cleanupStarted = new Promise<void>((resolve) => {
+ cleanupEntered = resolve;
+ });
+ let releaseCleanup!: () => void;
+ const cleanupGate = new Promise<void>((resolve) => {
+ releaseCleanup = resolve;
+ });
+ let stopCalls = 0;
+ const fake = createFakeSpawner((_child, _token, command) => {
+ if (command.includes("auto-load off")) commandEntered();
+ });
+ const manager = managerWithFakeSpawner(fake.spawnProcess, {
+ stopProcess: async () => {
+ stopCalls += 1;
+ if (stopCalls === 1) {
+ cleanupEntered();
+ await cleanupGate;
+ }
+ return {
+ status: "incomplete",
+ reason: "held fake cleanup remains uncertain",
+ };
+ },
+ });
+
+ const starting = manager.start(caller.signal);
+ await commandStarted;
+ const closing = manager.closeAll().catch(() => undefined);
+ await cleanupStarted;
+ caller.abort(callerReason);
+ releaseCleanup();
+ const started = await starting;
+
+ expect(started.ok).toBe(false);
+ if (!started.ok) {
+ expect(started.error).toBeInstanceOf(AnalysisCancelledError);
+ expect(started.error.cause).toBeInstanceOf(AnalysisCancelledError);
+ expect(started.error.cause).not.toBe(callerReason);
+ expect(started.error.cleanup).toEqual({
+ reason: "held fake cleanup remains uncertain",
+ resources: started.error.cleanupResources,
+ });
+ expect(started.error.cleanupIncomplete).toBe(true);
+ }
+ expect(stopCalls).toBeGreaterThanOrEqual(1);
+ expect(fake.children[0]?.exitCode).toBeNull();
+ await closing;
+ expect(stopCalls).toBeGreaterThanOrEqual(2);
+ expect(fake.children[0]?.exitCode).toBeNull();
});
it("classifies cancellation while asynchronous GDB ownership preparation is pending", async () => {
@@ -442,7 +540,7 @@ it("classifies cancellation while asynchronous GDB ownership preparation is pend
entered();
options.signal?.addEventListener(
"abort",
- () => reject(new Error("spawn preparation aborted")),
+ () => reject(options.signal?.reason),
{ once: true },
);
}),
@@ -1216,13 +1314,24 @@ afterEach(async () => {
it("rejects a pre-cancelled GDB start and an unconfigured executable", async () => {
const cancelled = new AbortController();
- cancelled.abort();
+ const reason = new Error("caller cancelled before start");
+ cancelled.abort(reason);
const startResult = await new GdbSessionManager({ platform: "linux" }).start(
cancelled.signal,
);
expect(startResult.ok).toBe(false);
- if (!startResult.ok)
+ if (!startResult.ok) {
expect(startResult.error._tag).toBe("AnalysisCancelledError");
+ expect(startResult.error.cause).toBe(reason);
+ }
+
+ const nullReasonController = new AbortController();
+ nullReasonController.abort(null);
+ const nullReasonResult = await new GdbSessionManager({
+ platform: "linux",
+ }).start(nullReasonController.signal);
+ expect(nullReasonResult.ok).toBe(false);
+ if (!nullReasonResult.ok) expect(nullReasonResult.error.cause).toBeNull();
const missing = await new GdbSessionManager({
platform: "linux",
@@ -1281,6 +1390,90 @@ it("retains ownership when GDB startup fails before its prompt and stop is incom
expect(manager.status(retainedSessionId ?? "")?.state).toBe("closed");
});
+it.each([
+ ["required auto-load configuration", "auto-load"],
+ ["caller-selected inferior TTY", "tty"],
+ ["late startup cancellation", "cancel"],
+] as const)(
+ "keeps an incompletely stopped failed startup unavailable and retriable after %s",
+ async (_label, failure) => {
+ const controller = new AbortController();
+ const commands: string[] = [];
+ let stopCalls = 0;
+ const fake = createFakeSpawner((child, token, command) => {
+ commands.push(command);
+ if (failure === "auto-load" && command.includes("auto-load off")) {
+ child.stdout.write(`${token}^error,msg="setting rejected"\n`);
+ } else if (failure === "tty" && command.includes("inferior-tty-show")) {
+ child.stdout.write(
+ `${token}^done,inferior_tty_terminal="/dev/pts/8"\n`,
+ );
+ } else {
+ child.stdout.write(`${token}^done\n`);
+ }
+ // The MI response is complete, but the startup continuation has not yet
+ // observed it. This exercises cancellation between, not during, requests.
+ if (failure === "cancel" && command.includes("auto-load off"))
+ controller.abort();
+ });
+ const manager = managerWithFakeSpawner(fake.spawnProcess, {
+ stopProcess: async (session, name) => {
+ stopCalls += 1;
+ return stopCalls === 1
+ ? {
+ status: "incomplete",
+ reason: "simulated startup stop uncertainty",
+ }
+ : stopOwnedDebuggerProcess(session, name);
+ },
+ });
+
+ const started = await manager.start(
+ failure === "cancel" ? controller.signal : undefined,
+ failure === "tty" ? { inferiorTty: "/dev/pts/7" } : {},
+ );
+
+ expect(started.ok).toBe(false);
+ if (started.ok) return;
+ expect(started.error._tag).toBe(
+ failure === "cancel"
+ ? "AnalysisCancelledError"
+ : "AnalysisCapabilityUnavailableError",
+ );
+ expect(started.error.cause).toBeDefined();
+ expect(started.error.partialObservation).toMatchObject({
+ predicate_type: "rea.debugger.startup-observation",
+ });
+ expect(started.error.cleanup).toMatchObject({
+ reason: "simulated startup stop uncertainty",
+ });
+ expect(started.error.cleanupIncomplete).toBe(true);
+ const [sessionId] = started.error.cleanupResources;
+ if (sessionId === undefined)
+ throw new Error("Failed startup did not retain its GDB session ID.");
+ expect(sessionId).toMatch(/^[0-9a-f-]{36}$/u);
+ expect(started.error.cleanup?.resources).toEqual([sessionId]);
+ expect(stopCalls).toBe(1);
+ expect(fake.children[0]?.exitCode).toBeNull();
+ expect(manager.status(sessionId)?.state).toBe("closed");
+
+ const command = await manager.execute(sessionId, "show version");
+ expect(command).toMatchObject({
+ ok: false,
+ error: { _tag: "AnalysisInputError" },
+ });
+ expect(commands).not.toContain('-interpreter-exec console "show version"');
+ expect(fake.children[0]?.exitCode).toBeNull();
+
+ expect((await manager.retryCleanupFailures()).ok).toBe(true);
+ expect(stopCalls).toBe(2);
+ expect(started.error.cleanupIncomplete).toBe(false);
+ expect(manager.status(sessionId)).toBeUndefined();
+ expect(fake.children[0]?.exitCode).toBeNull();
+ expect(fake.children[0]?.signalCode).toBe("SIGTERM");
+ },
+);
+
it("uses a fallback message when the process launcher rejects without an Error", async () => {
let attempts = 0;
const manager = managerWithFakeSpawner(async () => {
@@ -1677,20 +1870,26 @@ it("waits for the prior command and preserves cancellation and queue failures",
expect(waitForGdbCommandTurn(resolved)).toBe(resolved);
const preAborted = new AbortController();
- preAborted.abort();
+ const queueReason = "queue cancelled before admission";
+ preAborted.abort(queueReason);
await expect(
waitForGdbCommandTurn(Promise.resolve(), preAborted.signal),
- ).rejects.toMatchObject({ _tag: "AnalysisCancelledError" });
+ ).rejects.toMatchObject({
+ _tag: "AnalysisCancelledError",
+ cause: queueReason,
+ });
let release!: () => void;
const pending = new Promise<void>((resolve) => {
release = resolve;
});
const controller = new AbortController();
+ const activeQueueReason = { source: "active queue cancellation" };
const cancelledWait = waitForGdbCommandTurn(pending, controller.signal);
- controller.abort();
+ controller.abort(activeQueueReason);
await expect(cancelledWait).rejects.toMatchObject({
_tag: "AnalysisCancelledError",
+ cause: activeQueueReason,
});
release();
@@ -2439,18 +2638,20 @@ it("preserves a command timeout when stopping the owned process rejects", async
}
});
-it("reports cancellation if owned-process stop rejects during an active command", async () => {
+it("retains caller cancellation and cleanup authority after active-command stop rejects", async () => {
const controller = new AbortController();
+ const reason = { source: "console caller cancellation" };
+ const cleanupFailure = new AnalysisTimeoutError("foreign_cleanup", 17);
let stopCalls = 0;
const fake = createFakeSpawner((child, token, command) => {
if (command.includes("auto-load off"))
child.stdout.write(`${token}^done\n`);
- else controller.abort();
+ else controller.abort(reason);
});
const manager = managerWithFakeSpawner(fake.spawnProcess, {
stopProcess: async (session, name) => {
stopCalls += 1;
- if (stopCalls === 1) throw new Error("simulated stop rejection");
+ if (stopCalls === 1) throw cleanupFailure;
return stopOwnedDebuggerProcess(session, name);
},
});
@@ -2463,9 +2664,19 @@ it("reports cancellation if owned-process stop rejects during an active command"
);
expect(cancelled.ok).toBe(false);
- if (!cancelled.ok)
+ if (!cancelled.ok) {
expect(cancelled.error._tag).toBe("AnalysisCancelledError");
+ expect(cancelled.error.cause).toBe(reason);
+ expect(cancelled.error.cleanup).toEqual({
+ reason: expect.stringContaining("foreign_cleanup"),
+ resources: [started.value.session_id],
+ });
+ expect(cancelled.error.cleanupIncomplete).toBe(true);
+ }
expect(stopCalls).toBe(1);
+ expect((await manager.retryCleanupFailures()).ok).toBe(false);
+ if (!cancelled.ok) expect(cancelled.error.cleanupIncomplete).toBe(true);
+ expect(stopCalls).toBe(2);
});
it("returns a tagged cleanup failure thrown while closing", async () => {
@@ -2530,6 +2741,7 @@ it("returns partial command evidence when the active MI request times out after
it("preserves cancellation without cleanup details when stop is confirmed", async () => {
const controller = new AbortController();
+ const reason = { source: "confirmed active command cancellation" };
let requestToken = "";
const fake = createFakeSpawner((_child, token, command) => {
if (command.includes("cancel-confirmed")) requestToken = token;
@@ -2546,14 +2758,17 @@ it("preserves cancellation without cleanup details when stop is confirmed", asyn
controller.signal,
);
await expect.poll(() => requestToken).not.toBe("");
- controller.abort();
+ controller.abort(reason);
const cancelled = await active;
expect(cancelled).toMatchObject({
ok: false,
error: { _tag: "AnalysisCancelledError", operation: "gdb_console" },
});
- if (!cancelled.ok) expect(cancelled.error.cleanup).toBeUndefined();
+ if (!cancelled.ok) {
+ expect(cancelled.error.cleanup).toBeUndefined();
+ expect(cancelled.error.cause).toBe(reason);
+ }
});
it("rechecks cancellation after registering the active MI request listener", async () => {