refactor(reverse): fake objdump and Rizin commands only through the owned supervisor (#11076)

* refactor(reverse): fake objdump and Rizin commands only through the owned supervisor

* test(reverse): fake launch refusals and failed exits as the owned supervisor reports them

* refactor(reverse): name objdump and Rizin command repairs through the command port (#11080)
This commit is contained in:
morluto authored and GitHub committed 2026-11-15 20:06:13 +08:00
1 parent 12a0f4a94f
commit 7826e9688d
17 files changed
+479 -498

No files matched your search

@@ -5,11 +5,22 @@ import type {
RizinInput,
} from "../../domain/reverseEngineering.js";
/** How a caller repairs a configured provider command; named by the provider. */
export interface ReverseEngineeringCommandRepair {
/** The provider's name in reports, such as "objdump". */
readonly provider: string;
/** The environment setting that selects the command. */
readonly setting: string;
/** What to change when the command cannot be found or launched. */
readonly remediationAction: string;
}
/** Provider-neutral command profile consumed by the shared application workflow. */
export interface ReverseEngineeringProviderCommand {
readonly executable: string;
readonly arguments: readonly string[];
readonly identity: EvidenceProvider;
readonly repair: ReverseEngineeringCommandRepair;
/** What the provider cannot attest about the arguments it built. */
readonly limitations?: readonly string[];
/**
@@ -27,6 +38,7 @@ export interface ReverseEngineeringProviderCommand {
*/
export interface ReverseEngineeringCommandUnavailable {
readonly identity: EvidenceProvider;
readonly repair: ReverseEngineeringCommandRepair;
/** The command as configured. */
readonly command: string;
readonly reason:
@@ -52,12 +52,12 @@ import {
} from "../../domain/reverseEngineering.js";
import type {
ReverseEngineeringCommandPort,
ReverseEngineeringCommandRepair,
ReverseEngineeringCommandSelection,
ReverseEngineeringCommandUnavailable,
ReverseEngineeringProviderCommand,
} from "./ReverseEngineeringCommandPort.js";
import {
execFileOutput,
execFileOutputFailure,
HOST_SPAWN_CAPACITY_CODES,
} from "../../process/ExecFileOutput.js";
@@ -122,7 +122,6 @@ const MAX_ACTIVE_CAPTURE_BYTES =
export interface ReverseEngineeringServiceOptions {
readonly environment?: Readonly<NodeJS.ProcessEnv>;
readonly commands: ReverseEngineeringCommandPort;
readonly run?: ReverseEngineeringCommandRunner;
readonly runOwned?: typeof runOwnedCommand;
readonly digest?: typeof digestFile;
readonly stat?: (path: string) => Promise<Stats>;
@@ -132,7 +131,12 @@ interface ReverseEngineeringCommandRunner {
(
command: string,
arguments_: readonly string[],
options?: Parameters<typeof execFileOutput>[2],
options: {
readonly env: NodeJS.ProcessEnv;
readonly signal: AbortSignal | undefined;
readonly timeout: number;
readonly maxBuffer: number;
},
): Promise<{
readonly stdout: string;
readonly stderr: string;
@@ -177,24 +181,13 @@ interface ReverseCommandObservation {
readonly outputBudgetBytes: number;
}
/** The provider a reverse command runs and how a caller repairs its command. */
const reverseCommandRepair = (
operation: ReverseEngineeringOperation,
): { readonly provider: string; readonly remediationAction: string } => {
const objdump = operation === "inspect_with_objdump";
return {
provider: objdump ? "objdump" : "rizin",
remediationAction: `Set ${objdump ? "REA_OBJDUMP_COMMAND" : "REA_RIZIN_COMMAND"} to an installed executable ${objdump ? "GNU objdump" : "Rizin"} command, or make that command available on PATH. Check execute permission on the command and search permission on its parent directories before retrying.`,
};
};
/** A configured command the host search did not find; nothing was launched. */
const reverseCommandUnavailable = (
operation: ReverseEngineeringOperation,
unavailable: ReverseEngineeringCommandUnavailable,
): AnalysisCapabilityUnavailableError => {
const { provider, remediationAction } = reverseCommandRepair(operation);
const { command, reason } = unavailable;
const { command, reason, repair } = unavailable;
const { provider, remediationAction } = repair;
return new AnalysisCapabilityUnavailableError(
unavailable.identity.id,
operation,
@@ -255,18 +248,16 @@ export class ReverseEngineeringService {
constructor(options: ReverseEngineeringServiceOptions) {
this.#environment = { ...(options.environment ?? process.env) };
this.#commands = options.commands;
this.#run =
options.run ??
runOwnedCommandOutput(
options.runOwned ?? runOwnedCommand,
(owner, cleanup) =>
this.#pendingCleanup.set(owner, {
observation: cleanup,
release:
this.#pendingCleanup.get(owner)?.release ??
new AnalysisCleanupRelease(),
}),
);
this.#run = runOwnedCommandOutput(
options.runOwned ?? runOwnedCommand,
(owner, cleanup) =>
this.#pendingCleanup.set(owner, {
observation: cleanup,
release:
this.#pendingCleanup.get(owner)?.release ??
new AnalysisCleanupRelease(),
}),
);
this.#digest = options.digest ?? digestFile;
this.#stat = options.stat ?? statPath;
}
@@ -348,6 +339,7 @@ export class ReverseEngineeringService {
operation: ReverseEngineeringOperation,
dispatch: number,
failure: AnalysisCapabilityUnavailableError,
repair: ReverseEngineeringCommandRepair,
): void {
const outcome = this.#outcome(operation);
if (
@@ -357,9 +349,7 @@ export class ReverseEngineeringService {
outcome.failure = {
dispatch,
reason: failure.userMessage ?? failure.message,
remediation:
failure.remediationAction ??
reverseCommandRepair(operation).remediationAction,
remediation: failure.remediationAction ?? repair.remediationAction,
};
}
@@ -512,7 +502,12 @@ export class ReverseEngineeringService {
// discovery reports it like a launch failure until a later success.
if (!selection.ok) {
const refusal = reverseCommandUnavailable(operation, selection.error);
this.#recordUnavailable(operation, ++this.#dispatched, refusal);
this.#recordUnavailable(
operation,
++this.#dispatched,
refusal,
selection.error.repair,
);
return Promise.resolve(err(refusal));
}
if (
@@ -590,6 +585,7 @@ export class ReverseEngineeringService {
outputBudgetBytes,
} = request;
const { executable: command, arguments: args } = profile;
const { provider, setting } = profile.repair;
if (signal?.aborted) return err(cancelledBy(operation, signal));
const cleanup = await this.retryCleanup(operation);
if (!cleanup.ok) return cleanup;
@@ -696,7 +692,6 @@ export class ReverseEngineeringService {
},
signal,
timeout: timeoutMs,
stopSignal: "SIGTERM",
maxBuffer: outputBudgetBytes,
});
stdout = output.stdout;
@@ -793,12 +788,6 @@ export class ReverseEngineeringService {
typeof code === "string" &&
HOST_SPAWN_CAPACITY_CODES.has(code)
) {
const provider =
operation === "inspect_with_objdump" ? "objdump" : "rizin";
const setting =
operation === "inspect_with_objdump"
? "REA_OBJDUMP_COMMAND"
: "REA_RIZIN_COMMAND";
earlyFailure = new AnalysisResourceConstraintError(
operation,
"capacity",
@@ -831,12 +820,6 @@ export class ReverseEngineeringService {
? cause.cause
: undefined;
if (earlyFailure === undefined && admissionFailure !== undefined) {
const provider =
operation === "inspect_with_objdump" ? "objdump" : "rizin";
const setting =
operation === "inspect_with_objdump"
? "REA_OBJDUMP_COMMAND"
: "REA_RIZIN_COMMAND";
const rawSystemCode =
admissionFailure.detail?.system_code ??
(typeof admissionFailure.cause === "object" &&
@@ -886,10 +869,6 @@ export class ReverseEngineeringService {
carriedReason(darwinFailure.cancellation?.reason),
);
} else {
const setting =
operation === "inspect_with_objdump"
? "REA_OBJDUMP_COMMAND"
: "REA_RIZIN_COMMAND";
earlyFailure = new AnalysisCapabilityUnavailableError(
"process-ownership",
"prepare_owned_process",
@@ -930,10 +909,6 @@ export class ReverseEngineeringService {
code !== "ETIMEDOUT" &&
!commandCancelled(signal, cause, code)
) {
const setting =
operation === "inspect_with_objdump"
? "REA_OBJDUMP_COMMAND"
: "REA_RIZIN_COMMAND";
const remediation =
controlFailure.remediationAction === undefined
? `${setting} does not need to change.`
@@ -985,8 +960,7 @@ export class ReverseEngineeringService {
...reverseCommandTimeoutGuidance(timeoutMs),
});
else {
const { provider, remediationAction } =
reverseCommandRepair(operation);
const { provider, remediationAction } = profile.repair;
earlyFailure = new AnalysisCapabilityUnavailableError(
profile.identity.id,
operation,
@@ -1097,7 +1071,12 @@ export class ReverseEngineeringService {
earlyFailure.diagnostics?.boundary === "provider-launch" &&
earlyFailure.providerId === profile.identity.id
) {
this.#recordUnavailable(operation, dispatch, earlyFailure);
this.#recordUnavailable(
operation,
dispatch,
earlyFailure,
profile.repair,
);
}
return err(this.#registerCleanupFailure(earlyFailure, cleanupOwner));
}
@@ -1366,7 +1345,7 @@ const runOwnedCommandOutput =
cleanup: AnalysisCleanupObservation,
) => void,
): ReverseEngineeringCommandRunner =>
async (command, args, options = {}) => {
async (command, args, options) => {
const spawnEnv = { ...options.env };
try {
const snapshot = await runOwned(
@@ -1380,9 +1359,8 @@ const runOwnedCommandOutput =
sweepTokenOwnedProcesses: true,
},
{
timeoutMs: options.timeout ?? DEFAULT_REVERSE_COMMAND_TIMEOUT_MS,
diagnosticBytes:
options.maxBuffer ?? DEFAULT_REVERSE_COMMAND_OUTPUT_BYTES,
timeoutMs: options.timeout,
diagnosticBytes: options.maxBuffer,
acceptNonZeroExit: true,
},
{ signal: options.signal },
+11 -2
View File
@@ -7,13 +7,19 @@ import type {
import { err, ok } from "../domain/result.js";
import { ReverseEngineeringService } from "../application/reverse/ReverseEngineeringService.js";
import { objdumpCommand } from "../objdump/ObjdumpCommand.js";
import { OBJDUMP_PROVIDER_IDENTITY } from "../objdump/ObjdumpProviderIdentity.js";
import {
OBJDUMP_COMMAND_REPAIR,
OBJDUMP_PROVIDER_IDENTITY,
} from "../objdump/ObjdumpProviderIdentity.js";
import {
rizinCommand,
rizinCommandLimitations,
rizinCommandRejection,
} from "../rizin/RizinCommand.js";
import { RIZIN_PROVIDER_IDENTITY } from "../rizin/RizinProviderIdentity.js";
import {
RIZIN_COMMAND_REPAIR,
RIZIN_PROVIDER_IDENTITY,
} from "../rizin/RizinProviderIdentity.js";
import { resolveWindowsProviderExecutable } from "./resolveWindowsProviderExecutable.js";
export const createReverseEngineeringCommandPort = (
@@ -28,6 +34,7 @@ export const createReverseEngineeringCommandPort = (
{
arguments: objdumpCommand(input),
identity: OBJDUMP_PROVIDER_IDENTITY,
repair: OBJDUMP_COMMAND_REPAIR,
environmentOverrides: { DEBUGINFOD_URLS: "" },
},
),
@@ -41,6 +48,7 @@ export const createReverseEngineeringCommandPort = (
limitations: rizinCommandLimitations(input),
rejection: rizinCommandRejection,
identity: RIZIN_PROVIDER_IDENTITY,
repair: RIZIN_COMMAND_REPAIR,
},
),
});
@@ -57,6 +65,7 @@ const selectCommand = (
if (resolved.ok) return ok({ ...profile, executable: resolved.value });
return err({
identity: profile.identity,
repair: profile.repair,
command,
reason:
resolved.error.kind === "not_found"
+8
View File
@@ -4,3 +4,11 @@ export const OBJDUMP_PROVIDER_IDENTITY = {
name: "objdump command",
version: null,
} as const;
/** How a caller repairs the configured objdump command. */
export const OBJDUMP_COMMAND_REPAIR = {
provider: "objdump",
setting: "REA_OBJDUMP_COMMAND",
remediationAction:
"Set REA_OBJDUMP_COMMAND to an installed executable GNU objdump command, or make that command available on PATH. Check execute permission on the command and search permission on its parent directories before retrying.",
} as const;
+8
View File
@@ -4,3 +4,11 @@ export const RIZIN_PROVIDER_IDENTITY = {
name: "Rizin",
version: null,
} as const;
/** How a caller repairs the configured Rizin command. */
export const RIZIN_COMMAND_REPAIR = {
provider: "rizin",
setting: "REA_RIZIN_COMMAND",
remediationAction:
"Set REA_RIZIN_COMMAND to an installed executable Rizin command, or make that command available on PATH. Check execute permission on the command and search permission on its parent directories before retrying.",
} as const;
@@ -17,6 +17,7 @@ import { ok } from "../../../src/domain/result.js";
import { OwnedStagedOutput } from "../../../src/filesystem/OwnedStagedOutput.js";
import { GdbSessionManager } from "../../../src/gdb/GdbSessionManager.js";
import { TestReverseEngineeringService } from "../../support/reverseEngineeringService.js";
import { ownedOutput } from "../../support/reverseEngineeringCompositionFixtures.js";
import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";
const kinds = ["objdump", "architectures", "gdb"] as const;
@@ -24,13 +25,12 @@ const fixture = async (kind: (typeof kinds)[number]) => {
const directory = await createTestTempDirectory("rea-command-delivery-");
const path = join(directory, "input.bin");
await writeFile(path, "local CLI publication fixture");
const runProvider = vi.fn(async () => ({
stdout: "opaque provider output\n",
stderr: "provider diagnostic\n",
}));
const runProvider = vi.fn(async () =>
ownedOutput("opaque provider output\n", "provider diagnostic\n"),
);
const service = new TestReverseEngineeringService({
environment: {},
run: runProvider,
runOwned: runProvider,
});
const closeService = vi.spyOn(service, "close");
const manager = new GdbSessionManager({ platform: "linux", environment: {} });
@@ -17,6 +17,7 @@ import {
import { ok } from "../../../src/domain/result.js";
import { inspectAnalysisView } from "../../../src/application/analysisView/AnalysisViewService.js";
import { TestReverseEngineeringService } from "../../support/reverseEngineeringService.js";
import { ownedOutput } from "../../support/reverseEngineeringCompositionFixtures.js";
import { advertisedMcpToolSchemas } from "../../fixtures/advertisedMcpTool.js";
const sessionId = "00000000-0000-4000-8000-000000000001";
@@ -79,11 +80,10 @@ const connect = async (retain = true) => {
close: async () => ok({ target_state: "none_observed" as const }),
retryCleanupFailures: async () => ok(null),
};
const run = vi.fn(async () => ({
stdout: "BFD advertised targets\n",
stderr: "diagnostic\n",
}));
const service = new TestReverseEngineeringService({ run });
const run = vi.fn(async () =>
ownedOutput("BFD advertised targets\n", "diagnostic\n"),
);
const service = new TestReverseEngineeringService({ runOwned: run });
const logger = pino({ enabled: false });
registerGdbTools(
server,
@@ -6,6 +6,10 @@ import { dirname, join } from "node:path";
import { expect, it, vi } from "vitest";
import { TestReverseEngineeringService as ReverseEngineeringService } from "../../support/reverseEngineeringService.js";
import {
ownedFailure,
ownedOutput,
} from "../../support/reverseEngineeringCompositionFixtures.js";
import {
AnalysisCancelledError,
AnalysisInputError,
@@ -30,14 +34,11 @@ import {
const createTimedOutRizinService = (): ReverseEngineeringService =>
new ReverseEngineeringService({
run: async () => {
throw Object.assign(new Error("timed out"), {
stdout: "partial provider output",
stderr: "",
code: "ETIMEDOUT",
signal: null,
killed: true,
});
runOwned: async () => {
throw ownedFailure(
"timeout",
ownedOutput("partial provider output", "", { exitCode: null }),
);
},
});
@@ -124,9 +125,9 @@ it("admits Rizin mutation after invalidating before dispatch", async () => {
const { server, handler } = createReverseEngineeringMcpHarness();
const events: string[] = [];
const service = new ReverseEngineeringService({
run: async () => {
runOwned: async () => {
events.push("dispatch");
return { stdout: "rizin output", stderr: "" };
return ownedOutput("rizin output");
},
});
registerReverseEngineeringTools(
@@ -156,7 +157,7 @@ it("invalidates the snapshot in the legacy Rizin admission path", async () => {
const { server, handler } = createReverseEngineeringMcpHarness();
const invalidateSnapshot = vi.fn();
const service = new ReverseEngineeringService({
run: async () => ({ stdout: "rizin output", stderr: "" }),
runOwned: async () => ownedOutput("rizin output"),
});
registerReverseEngineeringTools(
server,
@@ -215,7 +216,7 @@ it("skips snapshot invalidation for malformed Rizin input", async () => {
it("delivers failed Rizin execution after external admission", async () => {
const { server, handler } = createReverseEngineeringMcpHarness();
const service = new ReverseEngineeringService({
run: async () => {
runOwned: async () => {
throw new Error("Rizin command failed");
},
});
@@ -305,17 +306,16 @@ it.each(["success", "timeout"])(
const { server, handler } = createReverseEngineeringMcpHarness();
const service = new ReverseEngineeringService({
run: async () => {
runOwned: async () => {
await writeFile(alias, "changed by Rizin");
if (outcome === "timeout")
throw Object.assign(new Error("timed out"), {
stdout: "partial analysis output",
stderr: "timeout diagnostics",
code: "ETIMEDOUT",
signal: null,
killed: true,
});
return { stdout: "partial analysis output", stderr: "" };
throw ownedFailure(
"timeout",
ownedOutput("partial analysis output", "timeout diagnostics", {
exitCode: null,
}),
);
return ownedOutput("partial analysis output");
},
});
const recordEvidence = vi.fn(() => ok("added" as const));
@@ -420,7 +420,7 @@ it("preserves a partial MCP error without claiming failed Evidence retention", a
it("delivers pathless objdump capability Evidence and input errors through its named tool", async () => {
const { server, handler } = createReverseEngineeringMcpHarness();
const service = new ReverseEngineeringService({
run: async () => ({ stdout: "objdump output", stderr: "" }),
runOwned: async () => ownedOutput("objdump output"),
});
const delivery = createToolResultDelivery(2 * 1024 * 1024);
registerReverseEngineeringTools(
@@ -505,9 +505,9 @@ it("keeps provider execution and Evidence recording inside analysis admission",
const { server, handler } = createReverseEngineeringMcpHarness();
const events: string[] = [];
const service = new ReverseEngineeringService({
run: async () => {
runOwned: async () => {
events.push("provider");
return { stdout: "objdump output", stderr: "" };
return ownedOutput("objdump output");
},
});
const recordEvidence = vi.fn(() => {
@@ -1,17 +1,20 @@
import { rm } from "node:fs/promises";
import { expect, it, vi } from "vitest";
import { createArtifact } from "../support/reverseEngineeringCompositionFixtures.js";
import {
createArtifact,
ownedOutput,
} from "../support/reverseEngineeringCompositionFixtures.js";
import type { runOwnedCommand } from "../../src/process/OwnedCommand.js";
import { TestReverseEngineeringService } from "../support/reverseEngineeringService.js";
import { projectAnalysisError } from "../../src/domain/analysisErrorProjection.js";
it("keeps omitted and undefined selection out of default command Evidence", async () => {
const { directory, path } = await createArtifact();
const run = vi.fn(async (_command: string, _args: readonly string[]) => ({
stdout: "complete disassembly\n",
stderr: "",
}));
const service = new TestReverseEngineeringService({ run });
const run = vi.fn<typeof runOwnedCommand>(async () =>
ownedOutput("complete disassembly\n"),
);
const service = new TestReverseEngineeringService({ runOwned: run });
try {
for (const selector of [{}, { symbol: undefined }]) {
const result = await service.inspectWithObjdump({
@@ -39,11 +42,10 @@ it.each([
"preserves native symbol %j as one argument and scoped Evidence",
async (symbol) => {
const { directory, path } = await createArtifact();
const run = vi.fn(async (_command: string, _args: readonly string[]) => ({
stdout: "selected disassembly\n",
stderr: "",
}));
const service = new TestReverseEngineeringService({ run });
const run = vi.fn<typeof runOwnedCommand>(async () =>
ownedOutput("selected disassembly\n"),
);
const service = new TestReverseEngineeringService({ runOwned: run });
try {
const result = await service.inspectWithObjdump({
path,
@@ -51,7 +53,10 @@ it.each([
symbol,
});
if (!result.ok) throw result.error;
expect(run.mock.calls[0]?.[1]).toEqual([`--disassemble=${symbol}`, path]);
expect(run.mock.calls[0]?.[0].arguments).toEqual([
`--disassemble=${symbol}`,
path,
]);
expect(result.value.parameters).toMatchObject({
operation: "disassemble",
symbol,
@@ -88,7 +93,10 @@ it.each([
async (operation) => {
const digest = vi.fn();
const run = vi.fn();
const service = new TestReverseEngineeringService({ digest, run });
const service = new TestReverseEngineeringService({
digest,
runOwned: run,
});
const result = await service.inspectWithObjdump({
...(operation === "architectures" ? {} : { path: "/unread-artifact" }),
operation,
@@ -126,7 +134,7 @@ it.each([
])("rejects invalid symbol %j before artifact admission", async (symbol) => {
const digest = vi.fn();
const run = vi.fn();
const service = new TestReverseEngineeringService({ digest, run });
const service = new TestReverseEngineeringService({ digest, runOwned: run });
const result = await service.inspectWithObjdump({
path: "/unread-artifact",
operation: "disassemble",
+105 -117
View File
@@ -10,7 +10,13 @@ import { describe, expect, it } from "vitest";
import { digestFile } from "../../src/application/reverse/ReverseEngineeringService.js";
import { ok } from "../../src/domain/result.js";
import { TestReverseEngineeringService as ReverseEngineeringService } from "../support/reverseEngineeringService.js";
import { providerSnapshot } from "../support/reverseEngineeringCompositionFixtures.js";
import {
fixtureCommandRepair,
ownedFailure,
ownedLaunchRefusal,
ownedOutput,
providerSnapshot,
} from "../support/reverseEngineeringCompositionFixtures.js";
import { createReverseEngineeringService } from "../../src/composition/reverseEngineering.js";
import { projectAnalysisError } from "../../src/domain/analysisErrorProjection.js";
import { AnalysisCancelledError } from "../../src/domain/analysisErrorCore.js";
@@ -27,6 +33,7 @@ it.each(["objdump", "rizin"] as const)(
const profile = {
executable: process.execPath,
arguments: ["-e", "process.stdout.write('complete-output')"],
repair: fixtureCommandRepair,
identity: {
id: "fixture-command",
name: "Fixture command",
@@ -95,9 +102,13 @@ describe("reverse engineering command services", () => {
REA_OBJDUMP_COMMAND: "/tools/objdump",
DEBUGINFOD_URLS: "https://debug.example.invalid",
},
run: async (command, args, options) => {
calls.push({ command, args, env: options?.env });
return { stdout: "DWARF output\n", stderr: "diagnostic\n" };
runOwned: async (spawn) => {
calls.push({
command: spawn.command,
args: spawn.arguments,
env: spawn.env,
});
return ownedOutput("DWARF output\n", "diagnostic\n");
},
});
@@ -136,9 +147,9 @@ describe("reverse engineering command services", () => {
);
let invoked = false;
const service = new ReverseEngineeringService({
run: async () => {
runOwned: async () => {
invoked = true;
return { stdout: "", stderr: "" };
return ownedOutput();
},
});
@@ -171,15 +182,8 @@ describe("reverse engineering command services", () => {
const path = join(directory, "fixture.bin");
await writeFile(path, "fixture");
const service = new ReverseEngineeringService({
run: async () => {
const failure = Object.assign(new Error("not found"), {
stdout: "",
stderr: "",
code: "ENOENT",
signal: null,
killed: false,
});
throw failure;
runOwned: async (spawn) => {
throw ownedLaunchRefusal("ENOENT", spawn.command);
},
});
@@ -204,14 +208,15 @@ describe("reverse engineering command services", () => {
const path = join(directory, "fixture.bin");
await writeFile(path, "fixture");
const service = new ReverseEngineeringService({
run: async () => {
throw Object.assign(new Error("max buffer exceeded"), {
stdout: "captured partial output",
stderr: "",
code: "ERR_CHILD_PROCESS_STDIO_MAXBUFFER",
signal: "SIGTERM",
killed: true,
});
runOwned: async () => {
throw ownedFailure(
"output-limit",
ownedOutput("captured partial output", "", {
exitCode: null,
signal: "SIGTERM",
diagnosticTruncated: true,
}),
);
},
});
@@ -263,9 +268,9 @@ it.each([
const calls: (readonly string[])[] = [];
const service = new ReverseEngineeringService({
environment: { REA_OBJDUMP_COMMAND: "/tools/objdump" },
run: async (_command, args) => {
calls.push(args);
return { stdout: "captured stdout", stderr: "captured stderr" };
runOwned: async (spawn) => {
calls.push(spawn.arguments);
return ownedOutput("captured stdout", "captured stderr");
},
});
@@ -315,9 +320,9 @@ it("uses one selected environment snapshot for provider selection and execution"
};
const calls: { command: string; env: NodeJS.ProcessEnv | undefined }[] = [];
const service = createReverseEngineeringService(selectedEnvironment, {
run: async (command, _args, options) => {
calls.push({ command, env: options?.env });
return { stdout: "headers", stderr: "" };
runOwned: async (spawn) => {
calls.push({ command: spawn.command, env: spawn.env });
return ownedOutput("headers");
},
});
selectedEnvironment.REA_RIZIN_COMMAND = "/changed/rizin";
@@ -350,22 +355,18 @@ it("marks signal-terminated provider commands as unknown completion", async () =
await writeFile(path, "fixture");
let invocation = 0;
const service = new ReverseEngineeringService({
run: async () => {
runOwned: async () => {
invocation += 1;
if (invocation === 1)
throw Object.assign(new Error("provider killed by signal"), {
stdout: "partial output",
stderr: "",
code: null,
signal: "SIGKILL",
killed: true,
});
throw Object.assign(new Error("provider exited with status 2"), {
stdout: "ordinary partial output",
stderr: "ordinary diagnostic",
code: 2,
signal: null,
killed: false,
throw ownedFailure(
"process",
ownedOutput("partial output", "", {
exitCode: null,
signal: "SIGKILL",
}),
);
return ownedOutput("ordinary partial output", "ordinary diagnostic", {
exitCode: 2,
});
},
});
@@ -425,23 +426,13 @@ describe("Rizin command service", () => {
const calls: { command: string; args: readonly string[] }[] = [];
const service = new ReverseEngineeringService({
environment: { REA_RIZIN_COMMAND: "/tools/rizin" },
run: async (command, args) => {
calls.push({ command, args });
const failure = new Error("command exited with status 2") as Error & {
stdout: string;
stderr: string;
code: number;
signal: null;
killed: boolean;
};
Object.assign(failure, {
stdout: "\u001b[31mpartial data\u001b[0m\n",
stderr: "command error",
code: 2,
signal: null,
killed: false,
});
throw failure;
runOwned: async (spawn) => {
calls.push({ command: spawn.command, args: spawn.arguments });
return ownedOutput(
"\u001b[31mpartial data\u001b[0m\n",
"command error",
{ exitCode: 2 },
);
},
});
@@ -506,9 +497,9 @@ describe("Rizin command service", () => {
await writeFile(path, "fixture");
let invoked = false;
const service = new ReverseEngineeringService({
run: async () => {
runOwned: async () => {
invoked = true;
return { stdout: "", stderr: "" };
return ownedOutput();
},
});
@@ -536,9 +527,9 @@ describe("Rizin command service", () => {
const path = join(directory, "fixture.bin");
await writeFile(path, "before");
const service = new ReverseEngineeringService({
run: async () => {
runOwned: async () => {
await writeFile(path, "after");
return { stdout: "changed", stderr: "" };
return ownedOutput("changed");
},
});
@@ -576,9 +567,9 @@ it("passes decoder and map inputs to Rizin before the path and records them", as
const calls: (readonly string[])[] = [];
const service = new ReverseEngineeringService({
environment: { REA_RIZIN_COMMAND: "/tools/rizin" },
run: async (_command, args) => {
calls.push(args);
return { stdout: "bx lr\n", stderr: "" };
runOwned: async (spawn) => {
calls.push(spawn.arguments);
return ownedOutput("bx lr\n");
},
});
const input = {
@@ -640,9 +631,9 @@ it("checks only the spelling and range of decoder and map inputs", async () => {
await writeFile(path, "image");
const calls: (readonly string[])[] = [];
const service = new ReverseEngineeringService({
run: async (_command, args) => {
calls.push(args);
return { stdout: "", stderr: "" };
runOwned: async (spawn) => {
calls.push(spawn.arguments);
return ownedOutput();
},
});
@@ -721,15 +712,14 @@ it("retains partial Evidence when a provider command times out", async () => {
const path = join(directory, "fixture.bin");
await writeFile(path, "before");
const service = new ReverseEngineeringService({
run: async () => {
const failure = Object.assign(new Error("timeout"), {
stdout: "captured before timeout",
stderr: "still running",
code: "ETIMEDOUT",
signal: "SIGTERM",
killed: true,
});
throw failure;
runOwned: async () => {
throw ownedFailure(
"timeout",
ownedOutput("captured before timeout", "still running", {
exitCode: null,
signal: "SIGTERM",
}),
);
},
});
@@ -769,7 +759,7 @@ it("retains partial Evidence when a provider command times out", async () => {
it("keeps a selected architecture deadline on Evidence", async () => {
const service = new ReverseEngineeringService({
run: async () => ({ stdout: "elf64-x86-64\n", stderr: "" }),
runOwned: async () => ownedOutput("elf64-x86-64\n"),
});
const selected = await service.inspectWithObjdump({
operation: "architectures",
@@ -881,15 +871,12 @@ it("applies a caller-selected one-shot deadline on the next call", async () => {
await writeFile(path, "before");
const timeouts: number[] = [];
const service = new ReverseEngineeringService({
run: async (_command, _args, options) => {
timeouts.push(options?.timeout ?? -1);
throw Object.assign(new Error("timeout"), {
stdout: "",
stderr: "",
code: "ETIMEDOUT",
signal: "SIGTERM",
killed: true,
});
runOwned: async (_spawn, limits) => {
timeouts.push(limits.timeoutMs ?? -1);
throw ownedFailure(
"timeout",
ownedOutput("", "", { exitCode: null, signal: "SIGTERM" }),
);
},
});
@@ -929,19 +916,17 @@ it("preserves raw byte counts when cancellation rejects invalid UTF-8 output", a
const path = join(directory, "fixture.bin");
await writeFile(path, "fixture");
const controller = new AbortController();
const failure = Object.assign(new Error("The operation was aborted"), {
stdout: "�",
stderr: "€",
stdoutBytes: 1,
stderrBytes: 3,
code: "ABORT_ERR",
signal: null,
killed: true,
});
const service = new ReverseEngineeringService({
run: async () => {
runOwned: async () => {
controller.abort();
throw failure;
throw ownedFailure(
"cancelled",
ownedOutput("�", "€", {
stdout: { text: "�", bytes: 1, observedBytes: 1 },
exitCode: null,
}),
{ cancellation: { reason: controller.signal.reason } },
);
},
});
@@ -971,16 +956,22 @@ it("preserves provider facts when cancellation interrupts the post-run digest",
await writeFile(path, "fixture");
const controller = new AbortController();
const service = new ReverseEngineeringService({
run: async () => {
runOwned: async () => {
controller.abort();
return {
stdout: "�",
stderr: "�",
stdoutInvalidUtf8: true,
stderrInvalidUtf8: true,
stdoutBytes: 1,
stderrBytes: 1,
};
return ownedOutput("", "", {
stdout: {
text: "�",
bytes: 1,
observedBytes: 1,
invalidUtf8: true,
},
stderr: {
text: "�",
bytes: 1,
observedBytes: 1,
invalidUtf8: true,
},
});
},
});
@@ -1022,14 +1013,11 @@ it("marks signal-terminated provider output incomplete", async () => {
const path = join(directory, "fixture.bin");
await writeFile(path, "fixture");
const service = new ReverseEngineeringService({
run: async () => {
throw Object.assign(new Error("terminated"), {
stdout: "partial",
stderr: "",
code: null,
signal: "SIGSEGV",
killed: false,
});
runOwned: async () => {
throw ownedFailure(
"process",
ownedOutput("partial", "", { exitCode: null, signal: "SIGSEGV" }),
);
},
});
@@ -5,6 +5,11 @@ import { join } from "node:path";
import { expect, it } from "vitest";
import { TestReverseEngineeringService } from "../support/reverseEngineeringService.js";
import {
ownedFailure,
ownedLaunchRefusal,
ownedOutput,
} from "../support/reverseEngineeringCompositionFixtures.js";
it.each([
{ budget: undefined, capacity: 8 },
@@ -27,16 +32,13 @@ it.each([
let calls = 0;
let mode: "success" | "failure" | "timeout" = "success";
const service = new TestReverseEngineeringService({
run: async () => {
runOwned: async (spawn) => {
calls += 1;
if (mode === "failure")
throw Object.assign(new Error("provider failed"), { code: "ENOENT" });
if (mode === "timeout")
throw Object.assign(new Error("provider timed out"), {
code: "ETIMEDOUT",
});
throw ownedLaunchRefusal("ENOENT", spawn.command);
if (mode === "timeout") throw ownedFailure("timeout", null);
await gate;
return { stdout: "", stderr: "" };
return ownedOutput();
},
});
@@ -115,9 +117,9 @@ it("preserves the exact caller reason when objdump admission is already aborted"
controller.abort(reason);
let runs = 0;
const service = new TestReverseEngineeringService({
run: async () => {
runOwned: async () => {
runs += 1;
return { stdout: "", stderr: "" };
return ownedOutput();
},
});
try {
@@ -143,9 +145,9 @@ it("preserves the caller reason when cancellation arrives after provider output"
const reason = Object.freeze({ requested: "stop-after-output" });
const controller = new AbortController();
const service = new TestReverseEngineeringService({
run: async () => {
runOwned: async () => {
controller.abort(reason);
return { stdout: "symbols", stderr: "" };
return ownedOutput("symbols");
},
});
try {
@@ -181,9 +183,9 @@ it("keeps a physical digest denial primary when the caller aborts during that fa
controller.abort(reason);
throw denied;
},
run: async () => {
runOwned: async () => {
runs += 1;
return { stdout: "", stderr: "" };
return ownedOutput();
},
});
try {
@@ -235,33 +237,28 @@ it("keeps an unrelated digest ABORT_ERR as an adapter failure", async () => {
it.each([
{
captured: true,
captured: false,
code: "EACCES",
tag: "AnalysisCapabilityUnavailableError",
},
{
captured: true,
code: "ETIMEDOUT",
code: "timeout",
tag: "AnalysisTimeoutError",
},
{
captured: true,
code: "ABORT_ERR",
code: "cancelled",
tag: "AnalysisCancelledError",
},
{
captured: false,
code: "EACCES",
tag: "AnalysisCapabilityUnavailableError",
},
{
captured: false,
code: "ETIMEDOUT",
code: "timeout",
tag: "AnalysisTimeoutError",
},
{
captured: false,
code: "ABORT_ERR",
code: "cancelled",
tag: "AnalysisCancelledError",
},
] as const)(
@@ -274,14 +271,20 @@ it.each([
await writeFile(path, "fixture");
const reason = Object.freeze({ requested: `stop-${code}` });
const controller = new AbortController();
const failure = Object.assign(new Error("provider failure"), {
code,
...(captured
? { stdout: "partial stdout", stderr: "partial stderr" }
: {}),
});
const failure =
code === "EACCES"
? ownedLaunchRefusal(code, "objdump")
: ownedFailure(
code,
captured
? ownedOutput("partial stdout", "partial stderr", {
exitCode: null,
})
: null,
code === "cancelled" ? { cancellation: { reason } } : undefined,
);
const service = new TestReverseEngineeringService({
run: async () => {
runOwned: async () => {
controller.abort(reason);
throw failure;
},
@@ -293,7 +296,9 @@ it.each([
);
expect(result).toMatchObject({ ok: false, error: { _tag: tag } });
if (result.ok) return;
expect(result.error.cause).toBe(code === "ABORT_ERR" ? reason : failure);
if (code === "cancelled") expect(result.error.cause).toBe(reason);
else if (code === "EACCES") expect(result.error.cause).toBe(failure);
else expect(result.error.cause).toMatchObject({ cause: failure });
if (code === "EACCES") {
expect(result.error).toMatchObject({
providerId: "objdump.command",
@@ -304,7 +309,7 @@ it.each([
},
});
}
if (captured && code === "ABORT_ERR") {
if (captured && code === "cancelled") {
expect(result.error.capturedOutput).toMatchObject({
stdout: "partial stdout",
stderr: "partial stderr",
@@ -193,26 +193,6 @@ const cleanupCancellationScenario = async (options: {
}
};
it("uses stoppable process mode for caller-selected provider commands", async () => {
const directory = await mkdtemp(join(tmpdir(), "rea-rizin-stoppable-"));
const path = join(directory, "fixture.bin");
await writeFile(path, "fixture");
let received: Record<string, unknown> | undefined;
const service = new ReverseEngineeringService({
run: async (_command, _args, options) => {
received = options as Record<string, unknown>;
return { stdout: "", stderr: "" };
},
});
try {
await service.executeRizinCommand({ path, command: "iI" });
expect(received?.stopSignal).toBe("SIGTERM");
} finally {
await rm(directory, { recursive: true, force: true });
}
});
it.skipIf(process.platform === "win32")(
"waits for a cancelled Rizin process to exit before returning",
async () => {
@@ -9,20 +9,19 @@ import { analysisErrorProjectionSchema } from "../../src/contracts/errorSchemas.
import { projectAnalysisError } from "../../src/domain/analysisErrorProjection.js";
import { ok } from "../../src/domain/result.js";
import { createReverseEngineeringCommandPort } from "../../src/composition/reverseEngineering.js";
import { execFileOutput } from "../../src/process/ExecFileOutput.js";
type ExecFileOutputOptions = NonNullable<Parameters<typeof execFileOutput>[2]>;
import type { runOwnedCommand } from "../../src/process/OwnedCommand.js";
import {
fixtureCommandRepair,
ownedLaunchRefusal,
ownedOutput,
} from "../support/reverseEngineeringCompositionFixtures.js";
it("uses provider profiles supplied through the application port", async () => {
const directory = await mkdtemp(join(tmpdir(), "rea-reverse-port-"));
const path = join(directory, "fixture.bin");
await writeFile(path, Buffer.from([0x7f, 0x45, 0x4c, 0x46]));
const run = vi.fn(
async (
_command: string,
_args: readonly string[],
_options?: ExecFileOutputOptions,
) => ({ stdout: "injected", stderr: "" }),
const run = vi.fn<typeof runOwnedCommand>(async () =>
ownedOutput("injected"),
);
const service = new ReverseEngineeringService({
environment: { REA_OBJDUMP_COMMAND: "ambient-objdump" },
@@ -31,6 +30,7 @@ it("uses provider profiles supplied through the application port", async () => {
ok({
executable: "injected-objdump",
arguments: ["--injected", path],
repair: fixtureCommandRepair,
identity: {
id: "test.objdump",
name: "Injected objdump",
@@ -42,10 +42,11 @@ it("uses provider profiles supplied through the application port", async () => {
ok({
executable: "injected-rizin",
arguments: ["--injected", path],
repair: fixtureCommandRepair,
identity: { id: "test.rizin", name: "Injected Rizin", version: null },
}),
},
run,
runOwned: run,
});
try {
@@ -54,10 +55,10 @@ it("uses provider profiles supplied through the application port", async () => {
operation: "file_headers",
});
expect(result.ok).toBe(true);
const call = run.mock.calls[0];
expect(call?.[0]).toBe("injected-objdump");
expect(call?.[1]).toEqual(["--injected", path]);
expect(call?.[2]?.env?.INJECTED_PROFILE).toBe("yes");
const spawn = run.mock.calls[0]?.[0];
expect(spawn?.command).toBe("injected-objdump");
expect(spawn?.arguments).toEqual(["--injected", path]);
expect(spawn?.env?.INJECTED_PROFILE).toBe("yes");
if (result.ok) expect(result.value.provider.id).toBe("test.objdump");
} finally {
await rm(directory, { recursive: true, force: true });
@@ -71,12 +72,8 @@ it("does not reintroduce ambient variables absent from the captured provider env
const previous = process.env[variable];
await writeFile(path, Buffer.from([0x7f, 0x45, 0x4c, 0x46]));
process.env[variable] = "late-ambient-value";
const run = vi.fn(
async (
_command: string,
_args: readonly string[],
_options?: ExecFileOutputOptions,
) => ({ stdout: "captured", stderr: "" }),
const run = vi.fn<typeof runOwnedCommand>(async () =>
ownedOutput("captured"),
);
const service = new ReverseEngineeringService({
environment: { REA_OBJDUMP_COMMAND: "captured-objdump" },
@@ -85,6 +82,7 @@ it("does not reintroduce ambient variables absent from the captured provider env
ok({
executable: "captured-objdump",
arguments: [path],
repair: fixtureCommandRepair,
identity: {
id: "test.objdump",
name: "Captured objdump",
@@ -96,15 +94,16 @@ it("does not reintroduce ambient variables absent from the captured provider env
ok({
executable: "captured-rizin",
arguments: [path],
repair: fixtureCommandRepair,
identity: { id: "test.rizin", name: "Captured Rizin", version: null },
}),
},
run,
runOwned: run,
});
try {
await service.inspectWithObjdump({ path, operation: "file_headers" });
expect(run.mock.calls[0]?.[2]?.env).toEqual({
expect(run.mock.calls[0]?.[0].env).toEqual({
REA_OBJDUMP_COMMAND: "captured-objdump",
PROFILE_VALUE: "explicit",
});
@@ -120,13 +119,14 @@ it("projects missing and non-file objdump targets with actionable path reasons",
join(tmpdir(), "rea-reverse-invalid-target-"),
);
const missing = join(directory, "missing.bin");
const run = vi.fn(async () => ({ stdout: "", stderr: "" }));
const run = vi.fn(async () => ownedOutput());
const service = new ReverseEngineeringService({
commands: {
objdump: () =>
ok({
executable: "unused-objdump",
arguments: [missing],
repair: fixtureCommandRepair,
identity: {
id: "test.objdump",
name: "Test objdump",
@@ -137,10 +137,11 @@ it("projects missing and non-file objdump targets with actionable path reasons",
ok({
executable: "unused-rizin",
arguments: [path],
repair: fixtureCommandRepair,
identity: { id: "test.rizin", name: "Test Rizin", version: null },
}),
},
run,
runOwned: run,
});
try {
@@ -195,7 +196,7 @@ it("keeps target preflight I/O failures out of invalid-input classification", as
const stat = vi.fn(async () => {
throw ioFailure;
});
const run = vi.fn(async () => ({ stdout: "", stderr: "" }));
const run = vi.fn(async () => ownedOutput());
const service = new ReverseEngineeringService({
stat,
commands: {
@@ -203,6 +204,7 @@ it("keeps target preflight I/O failures out of invalid-input classification", as
ok({
executable: "unused-objdump",
arguments: [path],
repair: fixtureCommandRepair,
identity: {
id: "test.objdump",
name: "Test objdump",
@@ -213,10 +215,11 @@ it("keeps target preflight I/O failures out of invalid-input classification", as
ok({
executable: "unused-rizin",
arguments: [path],
repair: fixtureCommandRepair,
identity: { id: "test.rizin", name: "Test Rizin", version: null },
}),
},
run,
runOwned: run,
});
try {
@@ -263,7 +266,7 @@ it.each([
const stat = vi.fn(async () => {
throw pathFailure;
});
const run = vi.fn(async () => ({ stdout: "", stderr: "" }));
const run = vi.fn(async () => ownedOutput());
const service = new ReverseEngineeringService({
stat,
commands: {
@@ -271,6 +274,7 @@ it.each([
ok({
executable: "unused-objdump",
arguments: [path],
repair: fixtureCommandRepair,
identity: {
id: "test.objdump",
name: "Test objdump",
@@ -281,10 +285,11 @@ it.each([
ok({
executable: "unused-rizin",
arguments: [path],
repair: fixtureCommandRepair,
identity: { id: "test.rizin", name: "Test Rizin", version: null },
}),
},
run,
runOwned: run,
});
try {
@@ -347,11 +352,11 @@ it.each([
])(
"refuses $operation on Windows when the bare command is not found on PATH, launching nothing",
async ({ operation, environment, run: execute, command, reason }) => {
const run = vi.fn(async () => ({ stdout: "", stderr: "" }));
const run = vi.fn(async () => ownedOutput());
const service = new ReverseEngineeringService({
environment,
commands: createReverseEngineeringCommandPort(environment, "win32"),
run,
runOwned: run,
});
const result = await execute(service);
if (result.ok) throw new Error("Expected a lookup refusal");
@@ -386,3 +391,39 @@ it.each([
expect(run).not.toHaveBeenCalled();
},
);
it("reports a launch refusal with the repair the command port names", async () => {
const profile = {
executable: "fixture-command",
arguments: [],
repair: fixtureCommandRepair,
identity: { id: "test.fixture", name: "Fixture", version: null },
};
const service = new ReverseEngineeringService({
commands: { objdump: () => ok(profile), rizin: () => ok(profile) },
runOwned: async (spawn) => {
throw ownedLaunchRefusal("ENOENT", spawn.command);
},
});
try {
const result = await service.inspectWithObjdump({
operation: "architectures",
});
if (result.ok) throw new Error("Expected a launch refusal");
const projection = projectAnalysisError(result.error);
expect(projection.message).toContain(
'selected fixture executable "fixture-command"',
);
expect(projection.remediation.action).toBe(
fixtureCommandRepair.remediationAction,
);
expect(service.observedLaunchFailures()).toEqual({
inspect_with_objdump: {
reason: projection.message,
remediation: fixtureCommandRepair.remediationAction,
},
});
} finally {
await service.close();
}
});
@@ -6,6 +6,8 @@ import { registerSharedReverseEngineeringEdgeCaseTests } from "../support/revers
import { registerOwnedRizinCommandEvidenceTests } from "../support/ownedRizinCommandEvidenceTests.js";
import {
createArtifact,
ownedFailure,
ownedOutput,
providerSnapshot,
} from "../support/reverseEngineeringCompositionFixtures.js";
@@ -93,7 +95,7 @@ it("records pathless objdump architecture support as provider capability evidenc
const service = new CoreReverseEngineeringService({
commands: createReverseEngineeringCommandPort(process.env),
digest,
run: async () => ({ stdout: "elf64-x86-64", stderr: "" }),
runOwned: async () => ownedOutput("elf64-x86-64"),
});
try {
const result = await service.inspectWithObjdump({
@@ -136,9 +138,9 @@ it("uses the host environment when the service environment is omitted", async ()
let observedEnvironment: NodeJS.ProcessEnv | undefined;
const service = new CoreReverseEngineeringService({
commands: createReverseEngineeringCommandPort(process.env),
run: async (_command, _args, options) => {
observedEnvironment = options?.env;
return { stdout: "ok", stderr: "" };
runOwned: async (spawn) => {
observedEnvironment = spawn.env;
return ownedOutput("ok");
},
});
@@ -173,7 +175,7 @@ it.each(["cancellation", "deadline"] as const)(
rejectStat = reject;
});
},
run: async () => ({ stdout: "", stderr: "" }),
runOwned: async () => ownedOutput(),
});
const resultPromise = service.inspectWithObjdump(
@@ -231,8 +233,8 @@ it("handles cancellation that races with stat listener registration", async () =
throwIfAborted: () => {},
} as AbortSignal;
const stat = vi.fn(async () => ({ isFile: () => true }) as unknown as Stats);
const run = vi.fn(async () => ({ stdout: "", stderr: "" }));
const service = new ReverseEngineeringService({ stat, run });
const runOwned = vi.fn(async () => ownedOutput());
const service = new ReverseEngineeringService({ stat, runOwned });
try {
const result = await service.inspectWithObjdump(
@@ -245,7 +247,7 @@ it("handles cancellation that races with stat listener registration", async () =
error: { _tag: "AnalysisCancelledError" },
});
expect(stat).not.toHaveBeenCalled();
expect(run).not.toHaveBeenCalled();
expect(runOwned).not.toHaveBeenCalled();
} finally {
await rm(directory, { recursive: true, force: true });
}
@@ -258,10 +260,10 @@ it("handles a synchronous stat provider throw as an artifact input failure", asy
code: "ENOENT",
});
});
const run = vi.fn(async () => ({ stdout: "", stderr: "" }));
const runOwned = vi.fn(async () => ownedOutput());
const service = new ReverseEngineeringService({
stat: stat as unknown as (path: string) => Promise<Stats>,
run,
runOwned,
});
try {
@@ -275,7 +277,7 @@ it("handles a synchronous stat provider throw as an artifact input failure", asy
error: { _tag: "AnalysisInputError" },
});
expect(stat).toHaveBeenCalledTimes(1);
expect(run).not.toHaveBeenCalled();
expect(runOwned).not.toHaveBeenCalled();
} finally {
await rm(directory, { recursive: true, force: true });
}
@@ -307,8 +309,8 @@ it("cancels an artifact stream when cancellation races with its listener registr
throwIfAborted: () => {},
} as AbortSignal;
const stat = vi.fn(async () => ({ isFile: () => true }) as unknown as Stats);
const run = vi.fn(async () => ({ stdout: "", stderr: "" }));
const service = new ReverseEngineeringService({ stat, run });
const runOwned = vi.fn(async () => ownedOutput());
const service = new ReverseEngineeringService({ stat, runOwned });
try {
const result = await service.inspectWithObjdump(
@@ -322,7 +324,7 @@ it("cancels an artifact stream when cancellation races with its listener registr
});
expect(registrations).toBe(2);
expect(stat).toHaveBeenCalledTimes(1);
expect(run).not.toHaveBeenCalled();
expect(runOwned).not.toHaveBeenCalled();
} finally {
await rm(directory, { recursive: true, force: true });
}
@@ -344,8 +346,8 @@ it("cancels before stream listeners when the signal changes after stat", async (
throwIfAborted: () => {},
} as AbortSignal;
const stat = vi.fn(async () => ({ isFile: () => true }) as unknown as Stats);
const run = vi.fn(async () => ({ stdout: "", stderr: "" }));
const service = new ReverseEngineeringService({ stat, run });
const runOwned = vi.fn(async () => ownedOutput());
const service = new ReverseEngineeringService({ stat, runOwned });
try {
const result = await service.inspectWithObjdump(
@@ -360,15 +362,15 @@ it("cancels before stream listeners when the signal changes after stat", async (
// Cancellation checks may be repeated by the digest cleanup path.
expect(abortedReads).toBeGreaterThanOrEqual(5);
expect(stat).toHaveBeenCalledTimes(1);
expect(run).not.toHaveBeenCalled();
expect(runOwned).not.toHaveBeenCalled();
} finally {
await rm(directory, { recursive: true, force: true });
}
});
it("rejects malformed Rizin requests before touching the provider", async () => {
const run = vi.fn(async () => ({ stdout: "", stderr: "" }));
const service = new ReverseEngineeringService({ run });
const runOwned = vi.fn(async () => ownedOutput());
const service = new ReverseEngineeringService({ runOwned });
const result = await service.executeRizinCommand({ path: "sample.bin" });
@@ -382,13 +384,13 @@ it("rejects malformed Rizin requests before touching the provider", async () =>
],
},
});
expect(run).not.toHaveBeenCalled();
expect(runOwned).not.toHaveBeenCalled();
});
it("rejects new operations after service shutdown begins", async () => {
const { directory, path } = await createArtifact();
const run = vi.fn(async () => ({ stdout: "", stderr: "" }));
const service = new ReverseEngineeringService({ run });
const runOwned = vi.fn(async () => ownedOutput());
const service = new ReverseEngineeringService({ runOwned });
try {
await service.close();
@@ -401,7 +403,7 @@ it("rejects new operations after service shutdown begins", async () => {
"Reverse-engineering service is closed.",
);
}
expect(run).not.toHaveBeenCalled();
expect(runOwned).not.toHaveBeenCalled();
} finally {
await rm(directory, { recursive: true, force: true });
}
@@ -415,10 +417,10 @@ it("rejects work after reaching the concurrent provider-operation limit", async
});
let providerCalls = 0;
const service = new ReverseEngineeringService({
run: async () => {
runOwned: async () => {
providerCalls += 1;
await providerGate;
return { stdout: "ok", stderr: "" };
return ownedOutput("ok");
},
});
@@ -472,8 +474,8 @@ it("cancels when an AbortSignal becomes aborted during listener registration", a
return typeof value === "function" ? value.bind(target) : value;
},
});
const run = vi.fn(async () => ({ stdout: "", stderr: "" }));
const service = new ReverseEngineeringService({ run });
const runOwned = vi.fn(async () => ownedOutput());
const service = new ReverseEngineeringService({ runOwned });
try {
const result = await service.inspectWithObjdump(
@@ -486,7 +488,7 @@ it("cancels when an AbortSignal becomes aborted during listener registration", a
error: { _tag: "AnalysisCancelledError" },
});
expect(abortedReads).toBe(2);
expect(run).not.toHaveBeenCalled();
expect(runOwned).not.toHaveBeenCalled();
} finally {
await rm(directory, { recursive: true, force: true });
}
@@ -504,11 +506,11 @@ it("drains an active provider operation before service shutdown resolves", async
runStarted = resolve;
});
const service = new ReverseEngineeringService({
run: async (_command, _args, options) => {
runOwned: async (_spawn, _limits, options) => {
signal = options?.signal;
runStarted?.();
await runGate;
return { stdout: "finished", stderr: "" };
return ownedOutput("finished");
},
});
@@ -557,11 +559,11 @@ it("relays caller cancellation to the admitted provider signal", async () => {
let providerSignal: AbortSignal | undefined;
const service = new CoreReverseEngineeringService({
commands: createReverseEngineeringCommandPort(process.env),
run: async (_command, _args, options) => {
runOwned: async (_spawn, _limits, options) => {
providerSignal = options?.signal;
announceStarted?.();
await runGate;
return { stdout: "captured", stderr: "" };
return ownedOutput("captured");
},
});
const operation = service.inspectWithObjdump(
@@ -608,14 +610,16 @@ it("passes an AbortSignal-like caller value through without relaying it", async
expect(receivedSignal).toBe(signal);
return "a".repeat(64);
});
const run = vi.fn(async (_command, _args, options) => {
expect(options?.signal).toBe(signal);
return { stdout: "ok", stderr: "" };
});
const runOwned = vi.fn<typeof runOwnedCommand>(
async (_spawn, _limits, options) => {
expect(options?.signal).toBe(signal);
return ownedOutput("ok");
},
);
const service = new CoreReverseEngineeringService({
commands: createReverseEngineeringCommandPort(process.env),
digest,
run,
runOwned,
});
try {
@@ -628,7 +632,7 @@ it("passes an AbortSignal-like caller value through without relaying it", async
expect(signal.addEventListener).not.toHaveBeenCalled();
expect(signal.removeEventListener).toHaveBeenCalledTimes(1);
expect(digest).toHaveBeenCalledTimes(2);
expect(run).toHaveBeenCalledTimes(1);
expect(runOwned).toHaveBeenCalledTimes(1);
} finally {
await rm(directory, { recursive: true, force: true });
}
@@ -898,14 +902,13 @@ it("preserves a provider timeout when cancellation arrives during the final dige
if (digests === 2) controller.abort();
return "a".repeat(64);
},
run: async () => {
throw Object.assign(new Error("provider timed out"), {
stdout: "partial timeout output",
stderr: "timeout diagnostic",
code: "ETIMEDOUT",
signal: null,
killed: true,
});
runOwned: async () => {
throw ownedFailure(
"timeout",
ownedOutput("partial timeout output", "timeout diagnostic", {
exitCode: null,
}),
);
},
});
@@ -9,6 +9,7 @@ import { projectAnalysisError } from "../../src/domain/analysisErrorProjection.j
import { ok } from "../../src/domain/result.js";
import { OwnedCommandFailure } from "../../src/process/OwnedCommand.js";
import { createTestTempDirectory } from "../fixtures/temporaryDirectory.js";
import { fixtureCommandRepair } from "../support/reverseEngineeringCompositionFixtures.js";
it.each([false, true])(
"keeps owned output collection failure primary after late cancellation=%s",
@@ -33,6 +34,7 @@ it.each([false, true])(
const profile = {
executable: "unused",
arguments: [],
repair: fixtureCommandRepair,
identity: { id: "fixture", name: "fixture", version: null },
};
const service = new ReverseEngineeringService({
@@ -68,6 +70,7 @@ it("keeps the owned producer cancellation reason authoritative", async () => {
const profile = {
executable: "unused",
arguments: [],
repair: fixtureCommandRepair,
identity: { id: "fixture", name: "fixture", version: null },
};
const service = new ReverseEngineeringService({
@@ -109,12 +112,13 @@ it.each([
throw cause;
}
: stat,
run,
runOwned: run,
commands: {
objdump: () =>
ok({
executable: "unused-objdump",
arguments: [path],
repair: fixtureCommandRepair,
identity: {
id: "test.objdump",
name: "Test objdump",
@@ -125,6 +129,7 @@ it.each([
ok({
executable: "unused-rizin",
arguments: [path],
repair: fixtureCommandRepair,
identity: { id: "test.rizin", name: "Test Rizin", version: null },
}),
},
@@ -5,6 +5,8 @@ import { expect, it, vi } from "vitest";
import { TestReverseEngineeringService as ReverseEngineeringService } from "./reverseEngineeringService.js";
import {
createArtifact,
ownedFailure,
ownedOutput,
providerSnapshot,
} from "./reverseEngineeringCompositionFixtures.js";
import { objdumpCommand } from "../../src/objdump/ObjdumpCommand.js";
@@ -29,9 +31,9 @@ const registerSharedReverseEngineeringEdgeCasesPart1 = (): void => {
const { directory, path } = await createArtifact();
const calls: string[][] = [];
const service = new ReverseEngineeringService({
run: async (_command, args) => {
calls.push([...args]);
return { stdout: "DWARF output", stderr: "" };
runOwned: async (spawn) => {
calls.push([...spawn.arguments]);
return ownedOutput("DWARF output");
},
});
@@ -52,7 +54,7 @@ const registerSharedReverseEngineeringEdgeCasesPart1 = (): void => {
it("marks opted-in external DWARF debug files as unbound Evidence sources", async () => {
const { directory, path } = await createArtifact();
const service = new ReverseEngineeringService({
run: async () => ({ stdout: "DWARF output", stderr: "" }),
runOwned: async () => ownedOutput("DWARF output"),
});
try {
@@ -74,9 +76,9 @@ const registerSharedReverseEngineeringEdgeCasesPart1 = (): void => {
it("rejects malformed objdump requests before touching the provider", async () => {
let invoked = false;
const service = new ReverseEngineeringService({
run: async () => {
runOwned: async () => {
invoked = true;
return { stdout: "", stderr: "" };
return ownedOutput();
},
});
@@ -297,19 +299,19 @@ const registerSharedReverseEngineeringEdgeCasesPart3 = (): void => {
});
it.each([
["ETIMEDOUT", "AnalysisTimeoutError"],
["EACCES", "AnalysisCapabilityUnavailableError"],
["EPERM", "AnalysisCapabilityUnavailableError"],
["ABORT_ERR", "AnalysisCancelledError"],
["timeout", "AnalysisTimeoutError"],
["cancelled", "AnalysisCancelledError"],
["unknown", "AnalysisCapabilityUnavailableError"],
])(
] as const)(
"maps provider failure %s to its tagged analysis error",
async (code, tag) => {
const { directory, path } = await createArtifact();
const service = new ReverseEngineeringService({
run: async () => {
runOwned: async () => {
if (code === "unknown") throw new Error("provider failure");
throw Object.assign(new Error("provider failure"), { code });
throw ownedFailure(code, null, {
cause: new Error("provider failure"),
});
},
});
@@ -323,20 +325,10 @@ const registerSharedReverseEngineeringEdgeCasesPart3 = (): void => {
error: {
_tag: tag,
operation: "inspect_with_objdump",
cause: { message: "provider failure" },
...(code === "ETIMEDOUT" ? { timeoutMs: 120_000 } : {}),
...(code === "EACCES" || code === "EPERM"
? {
providerId: "objdump.command",
diagnostics: {
boundary: "provider-launch",
command: "objdump",
system_code: code,
},
}
: {}),
...(code === "timeout" ? { timeoutMs: 120_000 } : {}),
...(code === "unknown"
? {
cause: { message: "provider failure" },
providerId: "objdump.command",
reason: "Unable to run configured command (unknown error)",
}
@@ -354,15 +346,15 @@ const registerSharedReverseEngineeringEdgeCasesPart4 = (): void => {
it("records a changed artifact and unknown post-run digest separately", async () => {
const { directory, path } = await createArtifact();
const changed = new ReverseEngineeringService({
run: async () => {
runOwned: async () => {
await writeFile(path, "changed during provider execution");
return { stdout: "observed", stderr: "" };
return ownedOutput("observed");
},
});
const removed = new ReverseEngineeringService({
run: async () => {
runOwned: async () => {
await rm(path);
return { stdout: "observed", stderr: "" };
return ownedOutput("observed");
},
});
@@ -399,54 +391,10 @@ const registerSharedReverseEngineeringEdgeCasesPart4 = (): void => {
await rm(directory, { recursive: true, force: true });
}
});
it.each(["EACCES", "EPERM"] as const)(
"retains raw failure output on a permission-denied provider launch (%s)",
async (code) => {
const { directory, path } = await createArtifact();
const service = new ReverseEngineeringService({
run: async () => {
throw Object.assign(new Error("provider permission denied"), {
stdout: "partial provider output",
stderr: "permission diagnostic",
code,
signal: null,
killed: false,
});
},
});
try {
const result = await service.inspectWithObjdump({
path,
operation: "file_headers",
});
expect(result).toMatchObject({
ok: false,
error: {
_tag: "AnalysisCapabilityUnavailableError",
providerId: "objdump.command",
diagnostics: {
boundary: "provider-launch",
command: "objdump",
system_code: code,
},
cause: {
code,
stdout: "partial provider output",
stderr: "permission diagnostic",
},
},
});
} finally {
await rm(directory, { recursive: true, force: true });
}
},
);
};
const registerSharedReverseEngineeringEdgeCasesPart5 = (): void => {
it("cancels after captured output when a provider reports a non-numeric status", async () => {
it("cancels after captured output when the provider exit status is unknown", async () => {
const { directory, path } = await createArtifact();
const controller = new AbortController();
let digests = 0;
@@ -456,14 +404,11 @@ const registerSharedReverseEngineeringEdgeCasesPart5 = (): void => {
if (digests === 2) controller.abort();
return digests === 1 ? "a".repeat(64) : "b".repeat(64);
},
run: async () => {
throw Object.assign(new Error("provider status unavailable"), {
stdout: "captured output",
stderr: "",
code: "provider-status-unknown",
signal: null,
killed: false,
});
runOwned: async () => {
throw ownedFailure(
"process",
ownedOutput("captured output", "", { exitCode: null }),
);
},
});
@@ -485,65 +430,6 @@ const registerSharedReverseEngineeringEdgeCasesPart5 = (): void => {
await rm(directory, { recursive: true, force: true });
}
});
it("maps an unavailable Rizin command to the Rizin capability error", async () => {
const { directory, path } = await createArtifact();
const service = new ReverseEngineeringService({
run: async () => {
throw Object.assign(new Error("not found"), { code: "ENOENT" });
},
});
try {
const result = await service.executeRizinCommand({ path, command: "iI" });
expect(result).toMatchObject({
ok: false,
error: {
_tag: "AnalysisCapabilityUnavailableError",
providerId: "rizin",
operation: "execute_rizin_command",
reason: "Unable to run configured command (ENOENT)",
cause: { message: "not found" },
},
});
} finally {
await rm(directory, { recursive: true, force: true });
}
});
it("classifies a captured ENOENT as provider unavailability", async () => {
const { directory, path } = await createArtifact();
const cause = Object.assign(new Error("launch failed"), {
stdout: "",
stderr: "",
code: "ENOENT",
signal: null,
killed: false,
});
const service = new ReverseEngineeringService({
run: async () => {
throw cause;
},
});
try {
const result = await service.inspectWithObjdump({
path,
operation: "file_headers",
});
expect(result).toMatchObject({
ok: false,
error: {
_tag: "AnalysisCapabilityUnavailableError",
providerId: "objdump.command",
reason: "Unable to run configured command (ENOENT)",
cause: { message: "launch failed" },
},
});
} finally {
await rm(directory, { recursive: true, force: true });
}
});
};
const registerSharedReverseEngineeringEdgeCasesPart6 = (): void => {
@@ -698,7 +584,7 @@ const registerSharedReverseEngineeringEdgeCasesPart8 = (): void => {
const { directory, path } = await createArtifact();
const controller = new AbortController();
const service = new ReverseEngineeringService({
run: async () => ({ stdout: "completed output", stderr: "" }),
runOwned: async () => ownedOutput("completed output"),
});
try {
@@ -1,5 +1,6 @@
import { mkdtemp, writeFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import { OwnedCommandFailure } from "../../src/process/OwnedCommand.js";
import type { ProviderProcessSnapshot } from "../../src/process/ProviderProcess.js";
import { join } from "node:path";
@@ -22,3 +23,52 @@ export const providerSnapshot = (
signal: null,
...overrides,
});
/** What the owned supervisor returns for a provider process that ended. */
export const ownedOutput = (
stdout = "",
stderr = "",
overrides: Partial<ProviderProcessSnapshot> = {},
): ProviderProcessSnapshot => {
const stdoutBytes = Buffer.byteLength(stdout);
const stderrBytes = Buffer.byteLength(stderr);
return {
stdout: { text: stdout, bytes: stdoutBytes, observedBytes: stdoutBytes },
stderr: { text: stderr, bytes: stderrBytes, observedBytes: stderrBytes },
exitCode: 0,
signal: null,
...overrides,
};
};
/** What the owned supervisor throws when a command does not finish normally. */
export const ownedFailure = (
reason: OwnedCommandFailure["reason"],
snapshot: ProviderProcessSnapshot | null,
options?: ConstructorParameters<typeof OwnedCommandFailure>[4],
): OwnedCommandFailure =>
new OwnedCommandFailure(
reason,
`owned command ${reason}`,
snapshot,
null,
options,
);
/**
* A launcher's refusal to start the command. The owned supervisor rethrows
* the launcher's spawn error unchanged.
*/
export const ownedLaunchRefusal = (code: string, command = "provider"): Error =>
Object.assign(new Error(`spawn ${command} ${code}`), {
code,
syscall: `spawn ${command}`,
path: command,
});
/** Repair guidance for a test-built command profile. */
export const fixtureCommandRepair = {
provider: "fixture",
setting: "REA_FIXTURE_COMMAND",
remediationAction: "Configure the fixture command.",
} as const;