mirror of
https://github.com/morluto/rea.git
synced 2026-11-17 04:04:25 +00:00
Run ordinary CLI commands through REA's registry, argv parser and result owner. Remove Incur, the second admission parse, SDK error middleware, output capture and redundant command traversal. Preserve explicit redaction, publication receipts, incremental output, terminal notice eligibility and drain ownership. Migrate fixtures to real registrations and retain the derived-source notices. Validation includes unchanged public parity goldens, public and lifecycle regressions, repaired fixture consumers, real TTY base comparisons, exports beyond the engine string limit, four schema catalogs and final static/docs checks. Native provider and optional validator coverage limits are in the PR. Fixes #11654. Fixes #10583. Refs #11682, #11476 and #10511. BREAKING CHANGE: Markdown argument diagnostics use REA's literal escaping, table widths and token counts. Flag-shaped unknown MCP subcommands honor the selected format. Completion --schema/--version routes use the canonical REA-owned hook rather than the retired SDK generator. Refresh affected literal snapshots and regenerate completion hooks with rea completions <shell>. Co-authored-by: gensokyo-dev <342580529+gensokyo-dev@users.noreply.github.com>
697 lines
22 KiB
TypeScript
697 lines
22 KiB
TypeScript
import { cliCommand } from "../../../src/cli/commandRegistry.js";
|
|
import { createCommandCli } from "../../support/cli/commandCli.js";
|
|
import { unknownTarget } from "../../../src/domain/targetIdentity.js";
|
|
import pino from "pino";
|
|
import { z } from "zod";
|
|
import { afterEach, expect, it, vi } from "vitest";
|
|
import { rm } from "node:fs/promises";
|
|
|
|
import { registerReverseEngineeringCommands } from "../../../src/cli/reverseEngineeringCommands.js";
|
|
import {
|
|
CLI_COMMANDS,
|
|
cliCommandFor,
|
|
} from "../../../src/contracts/cliCommandNames.js";
|
|
import {
|
|
AnalysisCancelledError,
|
|
AnalysisTimeoutError,
|
|
AnalysisOutputError,
|
|
} from "../../../src/domain/analysisErrorCore.js";
|
|
import {
|
|
createEvidence,
|
|
evidenceSchema,
|
|
} from "../../../src/domain/evidence.js";
|
|
import { err, ok } from "../../../src/domain/result.js";
|
|
import { ProviderCleanupError } from "../../../src/domain/providerCleanupError.js";
|
|
import { RizinDebugSessionManager } from "../../../src/rizin/RizinDebugSessionManager.js";
|
|
import { closeOwnedDebuggerSessions } from "../../../src/process/ownedDebuggerSession.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";
|
|
import { releaseOwnedCleanup } from "../../support/cleanupRelease.js";
|
|
|
|
const originalExitCode = process.exitCode;
|
|
|
|
afterEach(() => {
|
|
process.exitCode = originalExitCode;
|
|
});
|
|
|
|
const observation = (completionStatus: "complete" | "unknown") =>
|
|
createEvidence(
|
|
unknownTarget("not-observed"),
|
|
{ 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",
|
|
selection: {
|
|
operation?: string;
|
|
symbol?: string;
|
|
commandTimeoutMs?: number;
|
|
maxOutputBytes?: number;
|
|
} = {},
|
|
) => {
|
|
const cli = createCommandCli();
|
|
registerReverseEngineeringCommands(
|
|
cli,
|
|
pino({ enabled: false }),
|
|
{},
|
|
undefined,
|
|
() => service as ReverseEngineeringService,
|
|
);
|
|
const command = cliCommand(
|
|
cli,
|
|
cliCommandFor("inspect_with_objdump"),
|
|
)?.definition;
|
|
if (command === undefined)
|
|
throw new Error("objdump CLI command was not registered");
|
|
return command.run({
|
|
formatExplicit: false,
|
|
args: { path, operation: selection.operation ?? "file_headers" },
|
|
options: {
|
|
followDebugLinks: false,
|
|
...(selection.symbol === undefined ? {} : { symbol: selection.symbol }),
|
|
...(selection.maxOutputBytes === undefined
|
|
? {}
|
|
: { maxOutputBytes: selection.maxOutputBytes }),
|
|
...(selection.commandTimeoutMs === undefined
|
|
? {}
|
|
: { commandTimeoutMs: selection.commandTimeoutMs }),
|
|
},
|
|
});
|
|
};
|
|
|
|
it("forwards the selected native symbol to the shared workflow", async () => {
|
|
const inspectWithObjdump = vi.fn(async (_input: unknown) =>
|
|
ok(observation("complete")),
|
|
);
|
|
await runObjdump(
|
|
{ inspectWithObjdump, close: async () => undefined },
|
|
"/tmp/sample",
|
|
{ operation: "disassemble", symbol: "_Z3foov@@VERSION_1" },
|
|
);
|
|
expect(inspectWithObjdump.mock.calls[0]?.[0]).toEqual({
|
|
path: "/tmp/sample",
|
|
operation: "disassemble",
|
|
follow_debug_links: false,
|
|
symbol: "_Z3foov@@VERSION_1",
|
|
});
|
|
});
|
|
|
|
it("forwards selected objdump resource budgets and preserves omission", async () => {
|
|
const inspectWithObjdump = vi.fn(async (_input: unknown) =>
|
|
ok(observation("complete")),
|
|
);
|
|
const service = { inspectWithObjdump, close: async () => undefined };
|
|
await runObjdump(service, "/tmp/sample", {
|
|
commandTimeoutMs: 5_000,
|
|
maxOutputBytes: 1234,
|
|
});
|
|
expect(inspectWithObjdump.mock.calls[0]?.[0]).toEqual({
|
|
path: "/tmp/sample",
|
|
operation: "file_headers",
|
|
follow_debug_links: false,
|
|
command_timeout_ms: 5_000,
|
|
max_output_bytes: 1234,
|
|
});
|
|
await runObjdump(service, "/tmp/sample");
|
|
expect(inspectWithObjdump.mock.calls[1]?.[0]).toEqual({
|
|
path: "/tmp/sample",
|
|
operation: "file_headers",
|
|
follow_debug_links: 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 cli = createCommandCli();
|
|
registerReverseEngineeringCommands(
|
|
cli,
|
|
pino({ enabled: false }),
|
|
{},
|
|
undefined,
|
|
() =>
|
|
({
|
|
inspectWithObjdump,
|
|
close: vi.fn(async () => undefined),
|
|
}) as unknown as ReverseEngineeringService,
|
|
);
|
|
const command = cliCommand(
|
|
cli,
|
|
CLI_COMMANDS.listObjdumpArchitectures,
|
|
)?.definition;
|
|
if (command === undefined)
|
|
throw new Error("architecture command was not registered");
|
|
|
|
const result = await command.run({
|
|
formatExplicit: false,
|
|
args: {},
|
|
options: { detail: "complete" },
|
|
});
|
|
|
|
expect(result).toEqual(evidence);
|
|
expect(inspectWithObjdump).toHaveBeenCalledWith(
|
|
{ operation: "architectures" },
|
|
expect.objectContaining({ signal: expect.any(AbortSignal) }),
|
|
);
|
|
const artifactCommand = cliCommand(
|
|
cli,
|
|
cliCommandFor("inspect_with_objdump"),
|
|
)?.definition;
|
|
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: "objdump.command" },
|
|
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();
|
|
// The service names the contract field; the CLI adds the flag that sets it.
|
|
expect(timeout?.limit).toMatchObject({
|
|
control_kind: "parameter",
|
|
parameter: "command_timeout_ms",
|
|
});
|
|
expect(
|
|
JSON.stringify((result as { remediation?: unknown }).remediation),
|
|
).not.toContain("--");
|
|
expect(result).toMatchObject({
|
|
details: {
|
|
limit: {
|
|
parameter: "command_timeout_ms",
|
|
cli_flag: "--command-timeout-ms",
|
|
},
|
|
},
|
|
});
|
|
} 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 () => {
|
|
releaseOwnedCleanup(error);
|
|
}),
|
|
};
|
|
|
|
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((result as { details: unknown }).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 () => {
|
|
releaseOwnedCleanup(error);
|
|
}),
|
|
};
|
|
|
|
const result = await runObjdump(service);
|
|
|
|
expect(error.cleanupIncomplete).toBe(false);
|
|
expect(result).toMatchObject({
|
|
code: "cancelled",
|
|
details: { cleanup: "complete" },
|
|
});
|
|
});
|
|
|
|
it("returns cancellation with the completed observation when the caller interrupts service close", async () => {
|
|
const evidence = observation("complete");
|
|
const service = {
|
|
inspectWithObjdump: vi.fn(async () => ok(evidence)),
|
|
close: vi.fn(async () => {
|
|
process.emit("SIGINT");
|
|
}),
|
|
};
|
|
|
|
const result = await runObjdump(service);
|
|
|
|
expect(result).toMatchObject({
|
|
code: "cancelled",
|
|
details: { partial_observation: evidence },
|
|
});
|
|
expect(process.exitCode).toBe(130);
|
|
});
|
|
|
|
it("retains completed objdump Evidence when final cleanup fails", async () => {
|
|
const evidence = observation("complete");
|
|
const result = await runObjdump({
|
|
inspectWithObjdump: async () => ok(evidence),
|
|
close: async () => {
|
|
throw new ProviderCleanupError(
|
|
"objdump.command",
|
|
["owned-run"],
|
|
{ reason: "process cleanup remains incomplete" },
|
|
{ operation: "inspect_with_objdump" },
|
|
);
|
|
},
|
|
});
|
|
|
|
expect(result).toMatchObject({
|
|
code: "cleanup_incomplete",
|
|
details: {
|
|
resources: ["owned-run"],
|
|
partial_observation: evidence,
|
|
},
|
|
});
|
|
});
|
|
|
|
it("retains an unexpected operation failure and an independent cleanup failure", async () => {
|
|
const result = await runObjdump({
|
|
inspectWithObjdump: async () => {
|
|
throw new AnalysisTimeoutError("inspect_with_objdump", 1_000);
|
|
},
|
|
close: async () => {
|
|
throw new ProviderCleanupError(
|
|
"objdump.command",
|
|
["owned-run"],
|
|
{ reason: "process cleanup remains incomplete" },
|
|
{ operation: "inspect_with_objdump" },
|
|
);
|
|
},
|
|
});
|
|
|
|
expect(result).toMatchObject({
|
|
code: "cleanup_incomplete",
|
|
category: "timeout",
|
|
details: {
|
|
diagnostics: {
|
|
primary_error: { code: "provider_timeout" },
|
|
cleanup_error: { details: { resources: ["owned-run"] } },
|
|
},
|
|
},
|
|
});
|
|
});
|
|
|
|
it.each([false, true])(
|
|
"passes the Rizin TTY and uses final cleanup outcome (retry=%s)",
|
|
async (retryClose) => {
|
|
process.exitCode = 0;
|
|
|
|
const cli = createCommandCli();
|
|
const evidence = createEvidence(
|
|
unknownTarget("not-observed"),
|
|
{ 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(
|
|
retryClose
|
|
? err(
|
|
new AnalysisOutputError(
|
|
"close_rizin_debug_session",
|
|
"first close incomplete",
|
|
{
|
|
cleanup: { reason: "retry pending", resources: ["session-1"] },
|
|
},
|
|
),
|
|
)
|
|
: ok({ target_state: "unknown" }),
|
|
);
|
|
vi.spyOn(RizinDebugSessionManager.prototype, "closeAll").mockResolvedValue(
|
|
undefined,
|
|
);
|
|
registerReverseEngineeringCommands(cli, pino({ enabled: false }), {});
|
|
const command = cliCommand(cli, CLI_COMMANDS.debugWithRizin)?.definition;
|
|
if (command === undefined)
|
|
throw new Error("Rizin CLI command was not registered");
|
|
|
|
await command.run({
|
|
formatExplicit: false,
|
|
args: { path: "./sample.bin", command: "dr" },
|
|
options: { inferiorTty: "/dev/pts/7" },
|
|
});
|
|
|
|
expect(process.exitCode).toBe(0);
|
|
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 = createCommandCli();
|
|
registerReverseEngineeringCommands(
|
|
parserCli as unknown as CliInstance,
|
|
pino({ enabled: false }),
|
|
{},
|
|
);
|
|
const commandContract = cliCommand(
|
|
parserCli,
|
|
CLI_COMMANDS.debugWithRizin,
|
|
)?.definition;
|
|
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",
|
|
});
|
|
},
|
|
);
|
|
|
|
/** The one-shot command reports the retained debugger and why its stop is unconfirmed. */
|
|
const retainedRizinCleanup = {
|
|
retained_debugger_pids: [4242],
|
|
debugger_cleanup_codes: ["stop-failed"],
|
|
};
|
|
|
|
it.each(["incomplete", "interrupt", "control"] as const)(
|
|
"reports final Rizin cleanup %s as a typed outcome",
|
|
async (mode) => {
|
|
const cli = createCommandCli();
|
|
const previous = process.exitCode;
|
|
const evidence = createEvidence(
|
|
unknownTarget("not-observed"),
|
|
{ id: "rizin.debugger", name: "Rizin debugger", version: null },
|
|
{
|
|
predicateType: "rea.debugger.command-observation",
|
|
operation: "rizin_debug_command",
|
|
parameters: {
|
|
session_id: "fixture-session",
|
|
command: "dr",
|
|
inferior_tty: "/dev/pts/7",
|
|
},
|
|
result: { output: "registers" },
|
|
rawResult: { output: "registers" },
|
|
},
|
|
);
|
|
const sessions = new Map([
|
|
[
|
|
"fixture-session",
|
|
{
|
|
id: "fixture-session",
|
|
launched: { process: { pid: 4242 } },
|
|
supervisor: { ref: vi.fn(), unref: vi.fn() },
|
|
},
|
|
],
|
|
]);
|
|
vi.spyOn(RizinDebugSessionManager.prototype, "start").mockResolvedValue(
|
|
ok({ session_id: "fixture-session", 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").mockImplementation(
|
|
async () => {
|
|
if (mode === "incomplete")
|
|
return err(
|
|
new AnalysisOutputError(
|
|
"close_rizin_debug_session",
|
|
"stop unconfirmed",
|
|
{
|
|
cleanup: {
|
|
reason: "stop unconfirmed",
|
|
resources: ["fixture-session"],
|
|
},
|
|
},
|
|
),
|
|
);
|
|
sessions.clear();
|
|
return ok({ target_state: "unknown" });
|
|
},
|
|
);
|
|
let abortedAtCleanupEnd = false;
|
|
let signal: AbortSignal | undefined;
|
|
const closeAll = vi
|
|
.spyOn(RizinDebugSessionManager.prototype, "closeAll")
|
|
.mockImplementation(async () => {
|
|
signal = execute.mock.calls[0]?.[2];
|
|
await new Promise<void>((resolve) =>
|
|
setImmediate(() => {
|
|
if (mode === "interrupt") process.emit("SIGINT");
|
|
resolve();
|
|
}),
|
|
);
|
|
abortedAtCleanupEnd = signal?.aborted === true;
|
|
await closeOwnedDebuggerSessions(
|
|
sessions,
|
|
async () => ({
|
|
status: "incomplete",
|
|
code: "stop-failed",
|
|
reason: "stop unconfirmed",
|
|
}),
|
|
"Rizin",
|
|
);
|
|
});
|
|
registerReverseEngineeringCommands(cli, pino({ enabled: false }), {});
|
|
const command = cliCommand(cli, CLI_COMMANDS.debugWithRizin)?.definition;
|
|
if (command === undefined)
|
|
throw new Error("Rizin CLI command was not registered");
|
|
try {
|
|
process.exitCode = 0;
|
|
const result = await command.run({
|
|
formatExplicit: false,
|
|
args: { path: "./sample.bin", command: "dr" },
|
|
options: { inferiorTty: "/dev/pts/7" },
|
|
});
|
|
expect(closeAll).toHaveBeenCalledOnce();
|
|
if (mode === "control") {
|
|
expect(result).toBe(evidence);
|
|
expect(process.exitCode).toBe(0);
|
|
expect(abortedAtCleanupEnd).toBe(false);
|
|
} else if (mode === "interrupt") {
|
|
expect(result).toMatchObject({
|
|
code: "cancelled",
|
|
details: {
|
|
partial_observation: {
|
|
operation: "rizin_debug_command",
|
|
parameters: { session_id: "fixture-session" },
|
|
},
|
|
},
|
|
});
|
|
expect(process.exitCode).toBe(130);
|
|
expect(abortedAtCleanupEnd).toBe(true);
|
|
} else {
|
|
expect(result).toMatchObject({
|
|
code: "cleanup_incomplete",
|
|
details: {
|
|
cleanup: "incomplete",
|
|
resources: ["fixture-session"],
|
|
diagnostics: retainedRizinCleanup,
|
|
partial_observation: {
|
|
operation: "rizin_debug_command",
|
|
parameters: { session_id: "fixture-session" },
|
|
},
|
|
},
|
|
});
|
|
expect(sessions.size).toBe(1);
|
|
expect(process.exitCode).toBe(1);
|
|
}
|
|
} finally {
|
|
process.exitCode = previous;
|
|
vi.restoreAllMocks();
|
|
}
|
|
},
|
|
);
|