fix(reverse): reconcile cleanup ownership and mutation diagnostics (#2799)
* feat(process): add owned debugger shutdown lifecycle * feat(reverse): add local inspection commands * feat(gdb): add persistent debugger integration * feat(cutter): add Cutter bridge integration * test(reverse): enforce complete integration coverage * fix(process): preserve debugger shutdown ownership * fix(reverse): retain evidence across interrupted commands * fix(gdb): honor captured provider environment * test(process): cover debugger shutdown retries * fix(reverse): retain evidence for interrupted providers * test(process): cover debugger shutdown retries * fix(reverse): retain evidence for interrupted providers * fix(server): snapshot provider environment at creation * fix(reverse): close review gaps with complete coverage * fix(reverse): address inspection review findings * fix(gdb): bound sessions and retain cleanup ownership * fix(ci): require reverse-tools quality lane * fix(process): unref inherited debugger output pipes * fix(reverse): address remaining PR 1960 findings * fix(gdb): address remaining PR 1961 findings * fix(reverse): account for unrestricted provider execution * fix(process): retain debugger ownership until safe shutdown * fix(process): preserve replacement debugger sessions * fix(reverse): preserve admission and output provenance * fix(process): retain exited debugger until output settles * fix(mcp): bound provider admission and debugger cleanup * fix(reverse): preserve failure provenance and classify E2BIG * fix(gdb): preserve startup cleanup and detach safety * fix(process): retain debugger ownership after detach failure * fix(reverse): preserve mutation and failure provenance * fix(gdb): address debugger review findings * fix(reverse): rebind sessions after external mutation * fix(process): cap debugger output after exit * fix(gdb): protect one-shot detach verification * feat(debugger): add reverse tool coverage gate * test(debugger): cover integrated failure paths * fix(gdb): bound and preserve session observations * fix(gdb): address review regressions * style: format merged integration files * fix(reverse): preserve session and output evidence * refactor(gdb): share repeated test and partial result setup * fix(gdb): invalidate TTY proof for Python aliases * fix(reverse): retain failure output byte counts * test(process): synchronize late debugger output * fix(gdb): invalidate TTY proof for wrapped commands * fix(gdb): recognize wit command abbreviation * test(reverse): wait for cancelled descendant readiness * test(reverse): bound descendant cancellation cleanup * style(reverse): format integration tests and adapters * style: format reverse engineering integration files * test(reverse): remove duplicate environment harness * test(gdb): share session startup assertions * fix(gdb): invalidate output proof for command abbreviations * test(reverse): share composition edge case scenarios * fix(ci): recognize verification and mutation tool entries * test(rizin): cover successful fake inferior detach * test(cli): align full output failure envelope * test(cli): isolate reverse command lifecycle service * test(process): share debugger output fixture setup * fix(binary): preserve high-bit Windows signature bytes * style(binary): format Windows signature parser * test(mcp): preserve call coverage in unchanged comparison * fix(ci): include reverse tools Vitest configs in lint cache * fix(mcp): preserve target content on delivery errors * ci: align duplication ceiling with expanded suite * test(reverse): allow signal admission mutants * fix(reverse): bound retained cleanup failures to process owners * fix(test): replace drifting mutation ranges with owned selectors * fix(reverse): admit persistent commands and retain cleanup ownership * fix(cutter): recover timed-out commands from exact receipts * fix(cutter): reject unsupported bridge request kinds * fix(ci): repair client format and shared verification fixtures * fix(native): preserve debugger cleanup ownership and bridge authentication * test(native): retain diagnostics without perfect coverage requirements * chore(licenses): refresh locked dependency inventory and notices * fix(test): exclude transient command locks from mutation sandboxes * fix(gdb): admit only platforms with safe detach verification * fix(cutter): retain bounded completion receipts until acknowledgement * fix(cutter): acknowledge commands rejected before UI dispatch * test(reverse): fail cancellation checks before fixture teardown * test(gdb): clean up the retained broken-stdin fixture owner * docs(test): clarify focused provider verification scope * fix(rizin): retain close cleanup failures * fix(gdb): wait for inferior stop and bound MI buffering * fix(cutter): retain failed receipt acknowledgements * fix(rizin): return retained session identity on rebind failure * fix(gdb): preserve startup cancellation and lossy status * fix(rizin): retain launch provenance and assemble frames once * fix(cutter): recover receipts across callers and bound discovery * docs: describe debugger evidence and bridge recovery * fix(process): keep cleanup incomplete while writers remain Stopping a debugger no longer reports success when inherited output streams stay open, so BinarySession cannot reopen a binary a child is still changing. Concurrent Cutter cleanup retries share one receipt acknowledgement instead of treating a consumed receipt as failure. * fix(debuggers): recover cleanup with captured process identities * fix(analysis): retire sessions after unrestricted commands * fix(cli): preserve completed evidence after cleanup recovery * fix(cutter): bound frame collection and coalesce cleanup * fix(windows): resolve selected provider paths absolutely * fix(gdb): report decoding loss in failed startup evidence * fix(rizin): scope decoding loss to collected command frames * test(mcp): cover snapshot retirement in reverse tools CI --------- Co-authored-by: Daniel Gonçalves Araujo <47118053+dandgabr@users.noreply.github.com> Co-authored-by: REA Maintainers <noreply@github.com> Co-authored-by: OpenAI Codex <codex@users.noreply.github.com> Co-authored-by: Cursor Agent <cursoragent@cursor.com>
This commit is contained in:
co-authored by
Daniel Gonçalves Araujo
REA Maintainers
OpenAI Codex
Cursor Agent
parent
2ad2a044d4
commit
4aa51bfe19
@@ -0,0 +1,183 @@
|
||||
import { createServer } from "node:net";
|
||||
import { createHmac } from "node:crypto";
|
||||
import { mkdtemp, rm, writeFile } from "node:fs/promises";
|
||||
import { tmpdir } from "node:os";
|
||||
import { join } from "node:path";
|
||||
|
||||
import { Cli } from "incur";
|
||||
import { afterEach, describe, expect, it } from "vitest";
|
||||
|
||||
import { createCli } from "../../../src/cli.js";
|
||||
import { serveCli } from "./cliServeHarness.js";
|
||||
|
||||
const SESSION_ID = "27d3e3f1-f1e5-49ae-91ec-95af1f343a5a";
|
||||
const registeredCommands = Cli.toCommands as WeakMap<
|
||||
object,
|
||||
Map<string, unknown>
|
||||
>;
|
||||
|
||||
const cutterCommand = async (
|
||||
environment: Record<string, string | undefined>,
|
||||
args: {
|
||||
readonly sessionId: string;
|
||||
readonly expectedGeneration: number;
|
||||
readonly command: string;
|
||||
},
|
||||
): Promise<unknown> => {
|
||||
const cli = createCli(environment);
|
||||
const entry = registeredCommands.get(cli)?.get("cutter-command") ?? {};
|
||||
const run = Reflect.get(entry, "run") as (...args: unknown[]) => unknown;
|
||||
return Reflect.apply(run, undefined, [{ args, options: { json: false } }]);
|
||||
};
|
||||
|
||||
const listen = async (
|
||||
server: ReturnType<typeof createServer>,
|
||||
): Promise<number> => {
|
||||
await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
|
||||
const address = server.address();
|
||||
if (address === null || typeof address === "string")
|
||||
throw new Error("Expected an ephemeral TCP listener");
|
||||
return address.port;
|
||||
};
|
||||
|
||||
describe("Cutter CLI commands", () => {
|
||||
let directory: string | undefined;
|
||||
let server: ReturnType<typeof createServer> | undefined;
|
||||
|
||||
afterEach(async () => {
|
||||
if (server !== undefined)
|
||||
await new Promise<void>((resolve) => server?.close(() => resolve()));
|
||||
if (directory !== undefined)
|
||||
await rm(directory, { recursive: true, force: true });
|
||||
directory = undefined;
|
||||
server = undefined;
|
||||
});
|
||||
|
||||
it("lists sessions from the selected bridge directory", async () => {
|
||||
directory = await mkdtemp(join(tmpdir(), "rea-cutter-cli-test-"));
|
||||
|
||||
const result = await serveCli(["list-cutter-sessions", "--json"], {
|
||||
REA_CUTTER_BRIDGE_DIR: directory,
|
||||
});
|
||||
|
||||
expect(result.exitCode).toBe(0);
|
||||
expect(JSON.parse(result.stdout)).toMatchObject({
|
||||
sessions: [],
|
||||
discovery_status: "no_live_bridge_found",
|
||||
bridge_directory: directory,
|
||||
});
|
||||
});
|
||||
|
||||
it("reports an unavailable selected session for a command", async () => {
|
||||
directory = await mkdtemp(join(tmpdir(), "rea-cutter-cli-test-"));
|
||||
|
||||
const result = await serveCli(
|
||||
["cutter-command", SESSION_ID, "0", "pdi", "--json"],
|
||||
{ REA_CUTTER_BRIDGE_DIR: directory },
|
||||
);
|
||||
|
||||
expect(result.exitCode).toBe(0);
|
||||
expect(result.stdout).toContain("invalid_request");
|
||||
});
|
||||
|
||||
it("returns Evidence when the selected Cutter session completes a command", async () => {
|
||||
directory = await mkdtemp(join(tmpdir(), "rea-cutter-cli-test-"));
|
||||
const token = "synthetic-cutter-cli-token-for-test";
|
||||
let nextConnectionOrdinal = 0;
|
||||
server = createServer((connection) => {
|
||||
const ordinal = ++nextConnectionOrdinal;
|
||||
connection.setEncoding("utf8");
|
||||
let input = "";
|
||||
let clientNonce = "";
|
||||
let serverNonce = "";
|
||||
connection.on("data", (chunk: string) => {
|
||||
input += chunk;
|
||||
const newline = input.indexOf("\n");
|
||||
if (newline < 0) return;
|
||||
const frame = JSON.parse(input.slice(0, newline)) as Record<
|
||||
string,
|
||||
unknown
|
||||
>;
|
||||
input = input.slice(newline + 1);
|
||||
if (frame.kind === "rea-auth-v2") {
|
||||
clientNonce = String(frame.nonce);
|
||||
serverNonce = `${ordinal.toString(16).padStart(16, "0")}${"b".repeat(48)}`;
|
||||
connection.write(
|
||||
`${JSON.stringify({ session_id: SESSION_ID, nonce: serverNonce, proof: createHmac("sha256", token).update(`rea-cutter-server-v2:${SESSION_ID}:${clientNonce}:${serverNonce}`).digest("hex") })}\n`,
|
||||
);
|
||||
return;
|
||||
}
|
||||
const requestBytes = String(frame.request);
|
||||
const request = JSON.parse(requestBytes) as Record<string, unknown>;
|
||||
if (
|
||||
frame.proof !==
|
||||
createHmac("sha256", token)
|
||||
.update(
|
||||
`rea-cutter-client-v2:${SESSION_ID}:${clientNonce}:${serverNonce}:${requestBytes}`,
|
||||
)
|
||||
.digest("hex")
|
||||
) {
|
||||
connection.destroy();
|
||||
return;
|
||||
}
|
||||
const status = request.kind === "status";
|
||||
const response = JSON.stringify({
|
||||
ok: true,
|
||||
session_id: request.session_id,
|
||||
...(status
|
||||
? {
|
||||
current_file: null,
|
||||
document_generation: 0,
|
||||
cutter_version: "Cutter fixture",
|
||||
identity_status: "partial",
|
||||
completed_connection: (ordinal - 1)
|
||||
.toString(16)
|
||||
.padStart(16, "0"),
|
||||
completed_commands: [],
|
||||
}
|
||||
: request.kind === "ack"
|
||||
? { acknowledged: false }
|
||||
: {
|
||||
output: { answer: 42 },
|
||||
current_file: null,
|
||||
document_generation: 0,
|
||||
cutter_version: "Cutter fixture",
|
||||
identity_status: "partial",
|
||||
execution_state: "complete",
|
||||
output_truncated: false,
|
||||
}),
|
||||
});
|
||||
const proof = createHmac("sha256", token)
|
||||
.update(
|
||||
`rea-cutter-response-v2:${SESSION_ID}:${clientNonce}:${serverNonce}:${response}`,
|
||||
)
|
||||
.digest("hex");
|
||||
connection.end(`${JSON.stringify({ response, proof })}\n`);
|
||||
});
|
||||
});
|
||||
const port = await listen(server);
|
||||
await writeFile(
|
||||
join(directory, `cutter-${process.pid}-${SESSION_ID}.json`),
|
||||
JSON.stringify({
|
||||
session_id: SESSION_ID,
|
||||
pid: process.pid,
|
||||
host: "127.0.0.1",
|
||||
port,
|
||||
token,
|
||||
document_generation: 0,
|
||||
current_file: null,
|
||||
cutter_version: "Cutter fixture",
|
||||
identity_status: "partial",
|
||||
}),
|
||||
{ mode: 0o600 },
|
||||
);
|
||||
|
||||
const result = await cutterCommand(
|
||||
{ REA_CUTTER_BRIDGE_DIR: directory },
|
||||
{ sessionId: SESSION_ID, expectedGeneration: 0, command: "pdi" },
|
||||
);
|
||||
|
||||
expect(JSON.stringify(result)).toContain("rea.cutter.command-observation");
|
||||
expect(JSON.stringify(result)).toContain('"answer":42');
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,132 @@
|
||||
import pino from "pino";
|
||||
import { expect, it, vi } from "vitest";
|
||||
|
||||
import { AnalysisOutputError } from "../../../src/domain/analysisErrorCore.js";
|
||||
import { err } from "../../../src/domain/result.js";
|
||||
import { registerReverseEngineeringCommands } from "../../../src/cli/reverseEngineeringCommands.js";
|
||||
import { CLI_COMMANDS } from "../../../src/cliCommandNames.js";
|
||||
import type { CliInstance } from "../../../src/cli/types.js";
|
||||
import type { GdbSessionManager } from "../../../src/gdb/GdbSessionManager.js";
|
||||
|
||||
const registerGdbCommand = (
|
||||
createManager: () => GdbSessionManager,
|
||||
): {
|
||||
run(input: {
|
||||
args: { command: string };
|
||||
options: { inferiorTty: string };
|
||||
}): Promise<unknown>;
|
||||
} => {
|
||||
const commands = new Map<
|
||||
string,
|
||||
{
|
||||
run(input: {
|
||||
args: { command: string };
|
||||
options: { inferiorTty: string };
|
||||
}): Promise<unknown>;
|
||||
}
|
||||
>();
|
||||
const cli = {
|
||||
command: (
|
||||
name: string,
|
||||
definition: {
|
||||
run(input: {
|
||||
args: { command: string };
|
||||
options: { inferiorTty: string };
|
||||
}): Promise<unknown>;
|
||||
},
|
||||
) => {
|
||||
commands.set(name, definition);
|
||||
return cli;
|
||||
},
|
||||
} as unknown as CliInstance;
|
||||
registerReverseEngineeringCommands(cli, pino({ enabled: false }), {}, () =>
|
||||
createManager(),
|
||||
);
|
||||
const command = commands.get(CLI_COMMANDS.debugWithGdb);
|
||||
if (command === undefined)
|
||||
throw new Error("GDB CLI command was not registered");
|
||||
return command;
|
||||
};
|
||||
|
||||
it.each([
|
||||
"source /tmp/gdbinit",
|
||||
"python print('x')",
|
||||
"def custom-command",
|
||||
"run > /tmp/out",
|
||||
"set inferior-t /dev/null",
|
||||
"with inferior-t /dev/null -- run",
|
||||
])("rejects one-shot command %s before starting GDB", async (inputCommand) => {
|
||||
const manager = {
|
||||
start: vi.fn(),
|
||||
closeAll: vi.fn(),
|
||||
} as unknown as GdbSessionManager;
|
||||
const command = registerGdbCommand(() => manager);
|
||||
const result = await command.run({
|
||||
args: { command: inputCommand },
|
||||
options: { inferiorTty: "/dev/pts/42" },
|
||||
});
|
||||
expect(result).toMatchObject({
|
||||
code: "invalid_request",
|
||||
details: {
|
||||
issues: [
|
||||
expect.objectContaining({
|
||||
message: expect.stringContaining("persistent GDB session workflow"),
|
||||
}),
|
||||
],
|
||||
},
|
||||
});
|
||||
expect(manager.start).not.toHaveBeenCalled();
|
||||
expect(manager.closeAll).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("retries retained GDB cleanup when CLI session startup fails", async () => {
|
||||
const closeAll = vi.fn(async () => undefined);
|
||||
const manager = {
|
||||
start: vi.fn(async () =>
|
||||
err(new AnalysisOutputError("start_gdb_session", "startup failed")),
|
||||
),
|
||||
closeAll,
|
||||
} as unknown as GdbSessionManager;
|
||||
const originalExitCode = process.exitCode;
|
||||
const command = registerGdbCommand(() => manager);
|
||||
|
||||
try {
|
||||
const result = await command.run({
|
||||
args: { command: "info files" },
|
||||
options: { inferiorTty: "/dev/pts/42" },
|
||||
});
|
||||
expect(result).toMatchObject({ code: "unreadable_output" });
|
||||
expect(manager.start).toHaveBeenCalledOnce();
|
||||
expect(manager.start).toHaveBeenCalledWith(expect.anything(), {
|
||||
inferiorTty: "/dev/pts/42",
|
||||
});
|
||||
expect(closeAll).toHaveBeenCalledOnce();
|
||||
} finally {
|
||||
process.exitCode = originalExitCode;
|
||||
}
|
||||
});
|
||||
|
||||
it("marks the CLI failed when retained GDB cleanup remains incomplete", async () => {
|
||||
const manager = {
|
||||
start: vi.fn(async () =>
|
||||
err(new AnalysisOutputError("start_gdb_session", "startup failed")),
|
||||
),
|
||||
closeAll: vi.fn(async () => {
|
||||
throw new Error("process still owned");
|
||||
}),
|
||||
} as unknown as GdbSessionManager;
|
||||
const originalExitCode = process.exitCode;
|
||||
const command = registerGdbCommand(() => manager);
|
||||
|
||||
try {
|
||||
const result = await command.run({
|
||||
args: { command: "info files" },
|
||||
options: { inferiorTty: "/dev/pts/42" },
|
||||
});
|
||||
expect(result).toMatchObject({ code: "unreadable_output" });
|
||||
expect(manager.closeAll).toHaveBeenCalledOnce();
|
||||
expect(process.exitCode).toBe(1);
|
||||
} finally {
|
||||
process.exitCode = originalExitCode;
|
||||
}
|
||||
});
|
||||
@@ -0,0 +1,429 @@
|
||||
import pino from "pino";
|
||||
import { Cli, z } from "incur";
|
||||
import { afterEach, expect, it, vi } from "vitest";
|
||||
import { rm } from "node:fs/promises";
|
||||
|
||||
import { registerReverseEngineeringCommands } from "../../../src/cli/reverseEngineeringCommands.js";
|
||||
import { CLI_COMMANDS } from "../../../src/cliCommandNames.js";
|
||||
import {
|
||||
AnalysisCancelledError,
|
||||
AnalysisTimeoutError,
|
||||
AnalysisOutputError,
|
||||
} from "../../../src/domain/analysisErrorCore.js";
|
||||
import { projectAnalysisError } from "../../../src/domain/analysisErrorProjection.js";
|
||||
import {
|
||||
createEvidence,
|
||||
evidenceSchema,
|
||||
} from "../../../src/domain/evidence.js";
|
||||
import { err, ok } from "../../../src/domain/result.js";
|
||||
import { RizinDebugSessionManager } from "../../../src/rizin/RizinDebugSessionManager.js";
|
||||
import { ReverseEngineeringService as CoreReverseEngineeringService } from "../../../src/application/reverse/ReverseEngineeringService.js";
|
||||
import { createReverseEngineeringCommandPort } from "../../../src/composition/reverseEngineering.js";
|
||||
import { OwnedCommandFailure } from "../../../src/process/OwnedCommand.js";
|
||||
import type { ProviderProcessSupervisor } from "../../../src/process/ProviderProcess.js";
|
||||
import {
|
||||
createArtifact,
|
||||
providerSnapshot,
|
||||
} from "../../support/reverseEngineeringCompositionFixtures.js";
|
||||
import type { CliInstance } from "../../../src/cli/types.js";
|
||||
import type { ReverseEngineeringService } from "../../../src/application/reverse/ReverseEngineeringService.js";
|
||||
|
||||
const originalExitCode = process.exitCode;
|
||||
|
||||
afterEach(() => {
|
||||
process.exitCode = originalExitCode;
|
||||
});
|
||||
|
||||
const observation = (completionStatus: "complete" | "unknown") =>
|
||||
createEvidence(
|
||||
undefined,
|
||||
{ id: "gnu.objdump", name: "GNU objdump", version: null },
|
||||
{
|
||||
predicateType: "rea.reverse-engineering.command-observation",
|
||||
operation: "inspect_with_objdump",
|
||||
parameters: { operation: "file_headers" },
|
||||
result: { completion_status: completionStatus },
|
||||
rawResult: { completion_status: completionStatus },
|
||||
},
|
||||
);
|
||||
|
||||
const runObjdump = async (
|
||||
service: Partial<ReverseEngineeringService>,
|
||||
path = "/tmp/sample",
|
||||
) => {
|
||||
const commands = new Map<
|
||||
string,
|
||||
{
|
||||
run(input: {
|
||||
args: { path: string; operation: string };
|
||||
options: { followDebugLinks: boolean };
|
||||
}): Promise<unknown>;
|
||||
}
|
||||
>();
|
||||
const cli = {
|
||||
command: (
|
||||
name: string,
|
||||
definition: {
|
||||
run(input: {
|
||||
args: { path: string; operation: string };
|
||||
options: { followDebugLinks: boolean };
|
||||
}): Promise<unknown>;
|
||||
},
|
||||
) => {
|
||||
commands.set(name, definition);
|
||||
return cli;
|
||||
},
|
||||
} as unknown as CliInstance;
|
||||
registerReverseEngineeringCommands(
|
||||
cli,
|
||||
pino({ enabled: false }),
|
||||
{},
|
||||
undefined,
|
||||
() => service as ReverseEngineeringService,
|
||||
);
|
||||
const command = commands.get(CLI_COMMANDS.inspectWithObjdump);
|
||||
if (command === undefined)
|
||||
throw new Error("objdump CLI command was not registered");
|
||||
return command.run({
|
||||
args: { path, operation: "file_headers" },
|
||||
options: { followDebugLinks: false },
|
||||
});
|
||||
};
|
||||
|
||||
it("lists objdump architectures without inventing an artifact path", async () => {
|
||||
const evidence = observation("complete");
|
||||
const inspectWithObjdump = vi.fn(async (_input: unknown) => ok(evidence));
|
||||
const commands = new Map<
|
||||
string,
|
||||
{
|
||||
readonly args?: { safeParse(input: unknown): { success: boolean } };
|
||||
run(input: { args?: unknown; options?: unknown }): Promise<unknown>;
|
||||
}
|
||||
>();
|
||||
const cli = {
|
||||
command: (_name: string, definition: unknown) => {
|
||||
commands.set(
|
||||
_name,
|
||||
definition as {
|
||||
readonly args?: {
|
||||
safeParse(input: unknown): { success: boolean };
|
||||
};
|
||||
run(input: { args?: unknown; options?: unknown }): Promise<unknown>;
|
||||
},
|
||||
);
|
||||
return cli;
|
||||
},
|
||||
} as unknown as CliInstance;
|
||||
registerReverseEngineeringCommands(
|
||||
cli,
|
||||
pino({ enabled: false }),
|
||||
{},
|
||||
undefined,
|
||||
() =>
|
||||
({
|
||||
inspectWithObjdump,
|
||||
close: vi.fn(async () => undefined),
|
||||
}) as unknown as ReverseEngineeringService,
|
||||
);
|
||||
const command = commands.get(CLI_COMMANDS.listObjdumpArchitectures);
|
||||
if (command === undefined)
|
||||
throw new Error("architecture command was not registered");
|
||||
|
||||
const result = await command.run({});
|
||||
|
||||
expect(result).toEqual(evidence);
|
||||
expect(inspectWithObjdump).toHaveBeenCalledWith(
|
||||
{ operation: "architectures" },
|
||||
expect.objectContaining({ signal: expect.any(AbortSignal) }),
|
||||
);
|
||||
const artifactCommand = commands.get(CLI_COMMANDS.inspectWithObjdump);
|
||||
expect(
|
||||
artifactCommand?.args?.safeParse({
|
||||
path: "/tmp/sample",
|
||||
operation: "dwarf",
|
||||
}).success,
|
||||
).toBe(true);
|
||||
expect(
|
||||
artifactCommand?.args?.safeParse({
|
||||
path: "/tmp/sample",
|
||||
operation: "architectures",
|
||||
}).success,
|
||||
).toBe(false);
|
||||
});
|
||||
|
||||
it("promotes only complete production cleanup-only Evidence after CLI cleanup retry", async () => {
|
||||
const { directory, path } = await createArtifact();
|
||||
const owner = {
|
||||
stop: vi.fn(async () => ({ status: "verified-cleanup" as const })),
|
||||
} as unknown as ProviderProcessSupervisor;
|
||||
const service = new CoreReverseEngineeringService({
|
||||
commands: createReverseEngineeringCommandPort({}),
|
||||
runOwned: vi.fn(async () => {
|
||||
throw new OwnedCommandFailure(
|
||||
"process",
|
||||
"Cleanup after process completion was incomplete.",
|
||||
providerSnapshot(),
|
||||
"provider process still running",
|
||||
undefined,
|
||||
["owned-run"],
|
||||
owner,
|
||||
);
|
||||
}),
|
||||
});
|
||||
const inspect = service.inspectWithObjdump.bind(service);
|
||||
let producedCleanupFailure: AnalysisOutputError | undefined;
|
||||
let cleanupIncompleteBeforeClose: boolean | undefined;
|
||||
let completionBeforeClose: unknown;
|
||||
vi.spyOn(service, "inspectWithObjdump").mockImplementation(
|
||||
async (...args) => {
|
||||
const result = await inspect(...args);
|
||||
if (!result.ok && result.error instanceof AnalysisOutputError) {
|
||||
producedCleanupFailure = result.error;
|
||||
cleanupIncompleteBeforeClose = result.error.cleanupIncomplete;
|
||||
const partialEvidence = evidenceSchema.safeParse(
|
||||
result.error.partialObservation,
|
||||
);
|
||||
if (partialEvidence.success)
|
||||
completionBeforeClose = partialEvidence.data.normalized_result;
|
||||
}
|
||||
return result;
|
||||
},
|
||||
);
|
||||
|
||||
try {
|
||||
const result = await runObjdump(service, path);
|
||||
|
||||
expect(result).toMatchObject({
|
||||
provider: { id: "gnu.objdump" },
|
||||
normalized_result: { completion_status: "complete" },
|
||||
});
|
||||
expect(producedCleanupFailure?.cleanupOnly).toBe(true);
|
||||
expect(cleanupIncompleteBeforeClose).toBe(true);
|
||||
expect(completionBeforeClose).toMatchObject({
|
||||
completion_status: "complete",
|
||||
});
|
||||
expect(producedCleanupFailure).toMatchObject({
|
||||
cleanupIncomplete: false,
|
||||
cleanup: { resources: ["owned-run"] },
|
||||
partialObservation: {
|
||||
normalized_result: { completion_status: "complete" },
|
||||
},
|
||||
});
|
||||
expect(owner.stop).toHaveBeenCalledOnce();
|
||||
} finally {
|
||||
await service.close().catch(() => undefined);
|
||||
await rm(directory, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
it("preserves an operation timeout and unknown partial Evidence after cleanup retry", async () => {
|
||||
const { directory, path } = await createArtifact();
|
||||
const owner = {
|
||||
stop: vi.fn(async () => ({ status: "verified-cleanup" as const })),
|
||||
} as unknown as ProviderProcessSupervisor;
|
||||
const service = new CoreReverseEngineeringService({
|
||||
commands: createReverseEngineeringCommandPort({}),
|
||||
runOwned: vi.fn(async () => {
|
||||
throw new OwnedCommandFailure(
|
||||
"timeout",
|
||||
"Provider command timed out.",
|
||||
providerSnapshot({ exitCode: null }),
|
||||
"provider process still running",
|
||||
undefined,
|
||||
["owned-run"],
|
||||
owner,
|
||||
);
|
||||
}),
|
||||
});
|
||||
let timeout: AnalysisTimeoutError | undefined;
|
||||
const inspect = service.inspectWithObjdump.bind(service);
|
||||
vi.spyOn(service, "inspectWithObjdump").mockImplementation(
|
||||
async (...args) => {
|
||||
const result = await inspect(...args);
|
||||
if (!result.ok && result.error instanceof AnalysisTimeoutError)
|
||||
timeout = result.error;
|
||||
return result;
|
||||
},
|
||||
);
|
||||
|
||||
try {
|
||||
const result = await runObjdump(service, path);
|
||||
|
||||
expect(result).toMatchObject({
|
||||
code: "provider_timeout",
|
||||
details: {
|
||||
partial_observation: {
|
||||
normalized_result: { completion_status: "unknown" },
|
||||
},
|
||||
},
|
||||
});
|
||||
expect(timeout).toBeInstanceOf(AnalysisTimeoutError);
|
||||
expect(timeout?.cleanupIncomplete).toBe(false);
|
||||
expect(owner.stop).toHaveBeenCalledOnce();
|
||||
} finally {
|
||||
await service.close().catch(() => undefined);
|
||||
await rm(directory, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
it("preserves an independent timeout after cleanup succeeds", async () => {
|
||||
const evidence = observation("unknown");
|
||||
const error = new AnalysisTimeoutError("inspect_with_objdump", 1_000, {
|
||||
cleanup: { reason: "first stop incomplete", resources: ["owned-run"] },
|
||||
partialObservation: evidence,
|
||||
});
|
||||
const service = {
|
||||
inspectWithObjdump: vi.fn(async () => err(error)),
|
||||
close: vi.fn(async () => {
|
||||
error.resolveCleanup();
|
||||
}),
|
||||
};
|
||||
|
||||
const result = await runObjdump(service);
|
||||
|
||||
expect(result).toMatchObject({
|
||||
code: "provider_timeout",
|
||||
details: {
|
||||
partial_observation: {
|
||||
normalized_result: { completion_status: "unknown" },
|
||||
},
|
||||
},
|
||||
});
|
||||
expect(error.cleanupIncomplete).toBe(false);
|
||||
expect(projectAnalysisError(error).details).not.toHaveProperty("cleanup");
|
||||
});
|
||||
|
||||
it("does not project cancellation cleanup as incomplete after a successful retry", async () => {
|
||||
const error = new AnalysisCancelledError("inspect_with_objdump", {
|
||||
cleanup: { reason: "first stop incomplete", resources: ["owned-run"] },
|
||||
partialObservation: observation("unknown"),
|
||||
});
|
||||
const service = {
|
||||
inspectWithObjdump: vi.fn(async () => err(error)),
|
||||
close: vi.fn(async () => {
|
||||
error.resolveCleanup();
|
||||
}),
|
||||
};
|
||||
|
||||
await runObjdump(service);
|
||||
|
||||
expect(error.cleanupIncomplete).toBe(false);
|
||||
expect(projectAnalysisError(error).details).toMatchObject({
|
||||
cleanup: "complete",
|
||||
});
|
||||
});
|
||||
|
||||
it("parses the Rizin inferior TTY as an option and passes it to the manager", async () => {
|
||||
const commands = new Map<
|
||||
string,
|
||||
{
|
||||
run(input: {
|
||||
args: Record<string, unknown>;
|
||||
options: Record<string, unknown>;
|
||||
}): Promise<unknown>;
|
||||
}
|
||||
>();
|
||||
const cli = {
|
||||
command: (
|
||||
name: string,
|
||||
definition: {
|
||||
run(input: {
|
||||
args: Record<string, unknown>;
|
||||
options: Record<string, unknown>;
|
||||
}): Promise<unknown>;
|
||||
},
|
||||
) => {
|
||||
commands.set(name, definition);
|
||||
return cli;
|
||||
},
|
||||
} as unknown as CliInstance;
|
||||
const evidence = createEvidence(
|
||||
undefined,
|
||||
{ id: "rizin.debugger", name: "Rizin debugger", version: null },
|
||||
{
|
||||
predicateType: "rea.debugger.command-observation",
|
||||
operation: "rizin_debug_command",
|
||||
parameters: {
|
||||
session_id: "session-1",
|
||||
command: "dr",
|
||||
inferior_tty: "/dev/pts/7",
|
||||
},
|
||||
result: { output: "registers" },
|
||||
rawResult: { output: "registers" },
|
||||
},
|
||||
);
|
||||
const start = vi
|
||||
.spyOn(RizinDebugSessionManager.prototype, "start")
|
||||
.mockResolvedValue(ok({ session_id: "session-1", backend: null }));
|
||||
const execute = vi
|
||||
.spyOn(RizinDebugSessionManager.prototype, "execute")
|
||||
.mockResolvedValue(
|
||||
ok({
|
||||
evidence,
|
||||
result: {
|
||||
command: "dr",
|
||||
output: "registers",
|
||||
output_scope: "command_and_interleaved_session_output",
|
||||
output_truncated: false,
|
||||
completion_status: "complete",
|
||||
backend: null,
|
||||
},
|
||||
}),
|
||||
);
|
||||
vi.spyOn(RizinDebugSessionManager.prototype, "close").mockResolvedValue(
|
||||
ok({ target_state: "unknown" }),
|
||||
);
|
||||
vi.spyOn(RizinDebugSessionManager.prototype, "closeAll").mockResolvedValue(
|
||||
undefined,
|
||||
);
|
||||
registerReverseEngineeringCommands(cli, pino({ enabled: false }), {});
|
||||
const command = commands.get(CLI_COMMANDS.debugWithRizin);
|
||||
if (command === undefined)
|
||||
throw new Error("Rizin CLI command was not registered");
|
||||
|
||||
await command.run({
|
||||
args: { path: "./sample.bin", command: "dr" },
|
||||
options: { inferiorTty: "/dev/pts/7" },
|
||||
});
|
||||
|
||||
expect(start).toHaveBeenCalledWith(
|
||||
{ path: "./sample.bin", command: "dr", inferior_tty: "/dev/pts/7" },
|
||||
expect.any(AbortSignal),
|
||||
);
|
||||
expect(execute).toHaveBeenCalledWith(
|
||||
"session-1",
|
||||
"dr",
|
||||
expect.any(AbortSignal),
|
||||
);
|
||||
|
||||
const parserCli = Cli.create("rea-test", { version: "1.0.0", sync: false });
|
||||
registerReverseEngineeringCommands(
|
||||
parserCli as unknown as CliInstance,
|
||||
pino({ enabled: false }),
|
||||
{},
|
||||
);
|
||||
const commandContract = Cli.toCommands
|
||||
.get(parserCli)
|
||||
?.get(CLI_COMMANDS.debugWithRizin);
|
||||
expect(commandContract).toBeDefined();
|
||||
const argsSchema =
|
||||
commandContract === undefined
|
||||
? undefined
|
||||
: Reflect.get(commandContract, "args");
|
||||
const optionsSchema =
|
||||
commandContract === undefined
|
||||
? undefined
|
||||
: Reflect.get(commandContract, "options");
|
||||
if (
|
||||
!(argsSchema instanceof z.ZodObject) ||
|
||||
!(optionsSchema instanceof z.ZodObject)
|
||||
)
|
||||
throw new Error("Rizin CLI args/options schemas were not registered");
|
||||
expect(argsSchema.parse({ path: "./sample.bin", command: "dr" })).toEqual({
|
||||
path: "./sample.bin",
|
||||
command: "dr",
|
||||
});
|
||||
expect(optionsSchema.parse({ inferiorTty: "/dev/pts/7" })).toMatchObject({
|
||||
inferiorTty: "/dev/pts/7",
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user