Files
reverse-engineering-anything/tests/process-global/commandFinalizationCancellation.test.ts
T
Paritosh LahreandClaude Opus 5.5 cb8096d522 fix(cutter): explain empty discovery when Cutter 2.5.0 rejects the plugin (#10310)
* fix(cutter): explain empty discovery when Cutter 2.5.0 rejects the plugin

Official Cutter 2.5.0 builds have been observed to reject Python plugins at
startup, including Cutter's own sample plugin and REA's bridge
(rizinorg/cutter#3659). No session is published, and list_cutter_sessions
returns no_live_bridge_found with nothing pointing at the Cutter release.

The list_cutter_sessions contract now says what no_live_bridge_found means
and names the observed 2.5.0 rejection. The Cutter bridge docs describe
installing the plugin, the startup log lines Cutter prints when it rejects
it, and that 2.4.1 loaded the bridge in the reported check. A minimal
independent plugin fails the same way, so the bridge itself is unchanged.

Refs #10299

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(cutter): report empty-discovery causes in the shared result

The guidance lived only in the MCP tool description, which
`rea list-cutter-sessions` never shows. The docs also assumed a known package
folder, which npx installations do not have.

The discovery result now carries limitations, owned by
cutterDiscoveryLimitations in the domain. For no_live_bridge_found they list
the causes discovery cannot tell apart, including the observed Cutter 2.5.0
Python-plugin rejection (rizinorg/cutter#3659). CLI and MCP project the same
text, and the tool description returns to its previous wording. The docs now
take the plugin from the published package of the matching version with
npm pack.

Refs #10299

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(cutter): name failed status probes among no-live causes

no_live_bridge_found also covers a published session whose status probe
fails: a stale descriptor after Cutter exited, an unresponsive bridge, or
an incompatible bridge version. The limitation named only process,
plugin-loading and directory causes. It now lists these too, and the
dead-status-endpoint test asserts that such a discovery carries it.

Refs #10299

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(cutter): give the finalization discovery fixture its limitations

commandFinalizationCancellation builds a Cutter discovery through the
list_cutter_sessions output schema, which now requires limitations. CI
shard 4 failed all five final-close cases with a ZodError. The fixture
now takes the owner's empty limitations for sessions_found.

Refs #10299

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(cutter): count unanswered sessions beside found ones

When one session answered and another published session failed its status
probe, discovery returned sessions_found with no limitation. The partial
result looked complete. The client already throws for live ceiling
mismatches, so every other descriptor without a session is a failed probe.
It now passes that count to cutterDiscoveryLimitations, which reports the
unlisted sessions for sessions_found. The stale-descriptor case in
cutterBridgeRequestLimit asserts it.

Refs #10299

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(cutter): name unpublished bridge sessions among no-live causes

When Cutter loads the plugin but the bridge cannot write its session
descriptor, for example in an unwritable or full bridge directory,
_BridgeServer.run closes the socket without logging. Cutter's log then shows
the plugin as loaded, yet discovery finds nothing. The no-live limitation now
names that cause and says the bridge does not log it. The Cutter docs say to
check the bridge directory when the plugin is loaded but no session appears.

Refs #10299

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(cutter): count unreadable descriptors among unlisted sessions

The descriptor loader dropped filename-matching candidates it could not read
before listSessions counted unanswered sessions, so a found session beside a
malformed, oversized, non-private or misnamed descriptor reported no
limitation. The loader now returns its unreadable count, and the discovery
limitation owner reports it beside failed status probes for both
sessions_found and no_live_bridge_found. The no-live text keeps only the
causes that leave nothing published; published sessions are now counted.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(cutter): leave session existence unknown for unreadable descriptors

A filename-matching candidate the loader could not read does not establish
that any session exists: it may be malformed, misnamed or removed while
reading. The limitation now counts unreadable descriptor candidates and
says whether they describe Cutter sessions is unknown, instead of saying
their sessions are not listed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* chore(mcp): record the list_cutter_sessions limitations in the advertised summary

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 10:49:22 -05:00

542 lines
18 KiB
TypeScript

import { createCommandCli } from "../support/cli/commandCli.js";
import { readdir, writeFile } from "node:fs/promises";
import { join } from "node:path";
import { afterEach, expect, it, vi } from "vitest";
import * as analysisViewService from "../../src/application/analysisView/AnalysisViewService.js";
import * as evidenceInputResolver from "../../src/application/EvidenceInputResolver.js";
import { WasmArtifactService } from "../../src/application/wasm/WasmArtifactService.js";
import { registerAnalysisViewCommands } from "../../src/cli/analysisViewCommands.js";
import { registerCutterCommands } from "../../src/cli/cutterCommands.js";
import { registerWasmCommands } from "../../src/cli/wasmCommands.js";
import { wasmArtifactModule } from "../../src/composition/wasm.js";
import { analysisErrorProjectionSchema } from "../../src/domain/analysisErrorProjectionSchema.js";
import { toolContract } from "../../src/contracts/toolContracts.js";
import { CutterBridgeService } from "../../src/cutter/CutterBridgeService.js";
import { AnalysisOutputError } from "../../src/domain/analysisErrorCore.js";
import { cutterDiscoveryLimitations } from "../../src/domain/cutterDiscovery.js";
import * as analysisView from "../../src/domain/analysisView/analysisView.js";
import { parseEvidence } from "../../src/domain/evidence.js";
import { createEvidenceBundle } from "../../src/domain/evidenceBundle.js";
import { ProviderCleanupError } from "../../src/domain/providerCleanupError.js";
import { err, ok } from "../../src/domain/result.js";
import { OwnedFileHandle } from "../../src/filesystem/OwnedFileHandle.js";
import { silentLogger } from "../../src/logger.js";
import { analysisViewLayoutEvidence } from "../fixtures/analysisView.js";
import { createTestTempDirectory } from "../fixtures/temporaryDirectory.js";
import {
wasmArtifactExecution,
wasmArtifactFixture,
} from "../fixtures/wasm/artifact.js";
const host = vi.hoisted(() => ({
listeners: new Map<string, () => void>(),
get exitCode() {
return process.exitCode;
},
set exitCode(value: typeof process.exitCode) {
process.exitCode = value;
},
on(signal: string, listener: () => void) {
this.listeners.set(signal, listener);
},
off(signal: string, listener: () => void) {
if (this.listeners.get(signal) === listener) this.listeners.delete(signal);
},
}));
vi.mock("../../src/cli/commandCancellation.js", async (importOriginal) => {
const original =
await importOriginal<
typeof import("../../src/cli/commandCancellation.js")
>();
return {
...original,
withCommandCancellation: <Value>(
operation: (signal: AbortSignal) => Promise<Value>,
) => original.withCommandCancellation(operation, host),
};
});
afterEach(() => {
vi.restoreAllMocks();
host.listeners.clear();
});
const cutterDiscoveryFixture = () =>
toolContract("list_cutter_sessions").outputSchema.parse({
sessions: [
{
session_id: "00000000-0000-4000-8000-000000000001",
pid: 41,
document_generation: 7,
current_file: "C:\\Caller files\\token=literal%2F.bin",
cutter_version: "2.3.4",
identity_status: "partial",
bridge_source: "unknown",
},
{
session_id: "00000000-0000-4000-8000-000000000002",
pid: 42,
document_generation: 0,
current_file: null,
cutter_version: null,
identity_status: "partial",
bridge_source: "unknown",
},
],
bridge_directory: "/caller/Cutter bridge/token=literal%2F/证据",
discovery_status: "sessions_found",
bridge_directory_security: "unverified_platform_acl",
limitations: cutterDiscoveryLimitations("sessions_found"),
});
const finalCloseGate = () => {
let enter!: () => void;
let release!: () => void;
const entered = new Promise<void>((resolve) => {
enter = resolve;
});
const pending = new Promise<void>((resolve) => {
release = resolve;
});
return { enter, release, entered, pending };
};
it.each([
"control",
"cleanup-failure",
"interrupt",
"interrupt-cleanup-failure",
"queued-interrupt",
] as const)(
"retains registered Cutter discovery through final close: %s",
async (scenario) => {
const discoverySchema = toolContract("list_cutter_sessions").outputSchema;
const discovery = cutterDiscoveryFixture();
const cleanup = new ProviderCleanupError(
"cutter",
[],
{ reason: "controlled discovery close failure" },
{ operation: "list_cutter_sessions" },
);
const failsCleanup =
scenario === "cleanup-failure" ||
scenario === "interrupt-cleanup-failure";
const expectsInterrupt =
scenario === "interrupt" ||
scenario === "interrupt-cleanup-failure" ||
scenario === "queued-interrupt";
const gate = finalCloseGate();
let closed = false;
let interruptHandled = false;
let queuedInterrupt: Promise<void> | undefined;
const interrupt = () => {
const listener = host.listeners.get("SIGINT");
interruptHandled = listener !== undefined;
listener?.();
};
const list = vi
.spyOn(CutterBridgeService.prototype, "listSessions")
.mockResolvedValue(ok(discovery));
const close = vi
.spyOn(CutterBridgeService.prototype, "close")
.mockImplementation(async () => {
gate.enter();
await gate.pending;
if (
scenario === "interrupt" ||
scenario === "interrupt-cleanup-failure"
)
interrupt();
if (scenario === "queued-interrupt")
queuedInterrupt = new Promise<void>((resolve) => {
setImmediate(() => {
interrupt();
resolve();
});
});
closed = true;
if (failsCleanup) throw cleanup;
});
const cli = createCommandCli();
registerCutterCommands(cli, silentLogger, {});
let output = "";
let settled = false;
let pending: Promise<void> | undefined;
const previousExitCode = process.exitCode;
let exitCode: typeof process.exitCode;
try {
process.exitCode = undefined;
pending = cli
.serve(["list-cutter-sessions", "--json"], {
stdout: (part) => {
expect(closed).toBe(true);
output += part;
},
exit: () => {},
})
.then(() => {
settled = true;
});
await Promise.race([gate.entered, pending]);
expect(close).toHaveBeenCalledOnce();
expect(settled).toBe(false);
expect(output).toBe("");
gate.release();
await pending;
await queuedInterrupt;
exitCode = process.exitCode;
} finally {
gate.release();
try {
try {
await pending;
} finally {
await queuedInterrupt;
}
} finally {
process.exitCode = previousExitCode;
}
}
expect(list).toHaveBeenCalledOnce();
expect(list).toHaveBeenCalledWith({ signal: expect.any(AbortSignal) });
expect(close).toHaveBeenCalledOnce();
expect(closed).toBe(true);
expect(interruptHandled).toBe(expectsInterrupt);
expect(host.listeners.size).toBe(0);
expect(exitCode).toBe(
expectsInterrupt ? 130 : failsCleanup ? 1 : undefined,
);
const result: unknown = JSON.parse(output);
if (scenario === "control") {
expect(result).toEqual(discovery);
return;
}
const error = analysisErrorProjectionSchema.parse(result);
expect(error.code).toBe(failsCleanup ? "cleanup_incomplete" : "cancelled");
expect(error.details?.partial_observation).toEqual(discovery);
expect(discoverySchema.parse(error.details?.partial_observation)).toEqual(
discovery,
);
if (expectsInterrupt) expect(error.category).toBe("cancelled");
if (failsCleanup) expect(error.details?.resources).toEqual([]);
if (scenario === "cleanup-failure")
expect(error.details?.diagnostics).toEqual({
reason: "controlled discovery close failure",
});
if (scenario === "interrupt-cleanup-failure")
expect(error.details?.diagnostics).toMatchObject({
primary_error: {
code: "cancelled",
details: { operation: "list_cutter_sessions" },
},
cleanup_error: {
code: "cleanup_incomplete",
details: {
resources: [],
diagnostics: { reason: "controlled discovery close failure" },
},
},
});
},
);
it.each([
"control",
"interrupt",
"primary-failure",
"cleanup-failure",
"interrupt-cleanup-failure",
] as const)(
"finishes the registered WASM command through final close: %s",
async (scenario) => {
const value = wasmArtifactFixture();
const primary = new AnalysisOutputError(
"inspect_wasm_artifact",
"primary reply failure",
);
const cleanup = new ProviderCleanupError(
"wabt-artifact",
["exact-owned-root"],
{ reason: "close refused" },
{ operation: "inspect_wasm_artifact" },
);
let closed = false;
const service = new WasmArtifactService({
inspect: async () =>
scenario === "primary-failure"
? err(primary)
: ok(wasmArtifactExecution(value)),
close: async () => {
await Promise.resolve();
if (scenario !== "control" && scenario !== "cleanup-failure")
host.listeners.get("SIGINT")?.();
closed = true;
if (
scenario === "cleanup-failure" ||
scenario === "interrupt-cleanup-failure"
)
throw cleanup;
},
});
vi.spyOn(wasmArtifactModule, "create").mockReturnValue(service);
const cli = createCommandCli();
registerWasmCommands(cli, silentLogger, {});
let output = "";
const previousExitCode = process.exitCode;
let exitCode;
try {
process.exitCode = undefined;
await cli.serve(
["inspect-wasm-artifact", value.artifact.path, "--json"],
{
stdout: (part) => {
output += part;
},
exit: () => {},
},
);
exitCode = process.exitCode;
} finally {
process.exitCode = previousExitCode;
}
const result = JSON.parse(output);
expect(closed).toBe(true);
expect(host.listeners.size).toBe(0);
if (scenario === "control") {
expect(result.normalized_result).toEqual(value);
expect(exitCode).toBeUndefined();
} else if (scenario === "primary-failure") {
expect(result).toMatchObject({
code: "unreadable_output",
details: { reason: "primary reply failure" },
});
expect(exitCode).toBe(130);
} else {
expect(result).toMatchObject({
code: scenario === "interrupt" ? "cancelled" : "cleanup_incomplete",
details: {
partial_observation: {
operation: "inspect_wasm_artifact",
normalized_result: value,
},
...(scenario === "interrupt"
? {}
: { resources: ["exact-owned-root"] }),
},
});
if (scenario !== "cleanup-failure") expect(exitCode).toBe(130);
}
},
);
const referenceViewEvidence = async (
request: Parameters<typeof analysisViewService.inspectAnalysisView>[0],
evidenceBundlePath: string,
phase: string,
) => {
if (phase !== "projection") return undefined;
const result = await analysisViewService.inspectAnalysisView(
request,
undefined,
{ evidenceBundlePath },
);
if (!result.ok) throw new Error("Expected completed reference Evidence");
return result.value;
};
type PreparedView = ReturnType<
typeof analysisView.prepareAnalysisViewProjection
>;
const expectRetainedProjection = (
observation: unknown,
reference: Awaited<ReturnType<typeof referenceViewEvidence>>,
projected: ReturnType<PreparedView["project"]> | undefined,
parent: ReturnType<typeof analysisViewLayoutEvidence>,
) => {
if (!projected?.ok || reference === undefined)
throw new Error("Expected a completed page and reference Evidence");
const partial = parseEvidence(observation);
expect(partial).toEqual(reference);
expect(partial.normalized_result).toEqual(projected.value);
expect(partial).toMatchObject({
operation: "inspect_analysis_view",
evidence_links: [parent.evidence_id],
subject: parent.subject,
});
};
it.each([
["bundle", "control", "close"],
["bundle", "SIGINT", "close"],
["bundle", "SIGTERM", "close"],
["evidence-file", "control", "close"],
["evidence-file", "SIGINT", "close"],
["evidence-file", "SIGTERM", "close"],
["request-file", "control", "close"],
["request-file", "SIGINT", "close"],
["request-file", "SIGTERM", "close"],
["bundle", "SIGINT", "authentication"],
["bundle", "SIGTERM", "authentication"],
["bundle", "SIGINT", "projection"],
["bundle", "SIGTERM", "projection"],
["bundle", "SIGINT", "authentication-failure"],
["bundle", "SIGTERM", "source-resolution-failure"],
] as const)(
"preserves the analysis-view result and exit status for %s: %s during %s",
async (source, signal, phase) => {
const root = await createTestTempDirectory("rea-analysis-view-signal-");
const parent = analysisViewLayoutEvidence();
const filename = `${source}.json`;
const path = join(root, filename);
const request = {
source:
source === "bundle"
? {
kind: "retained-evidence",
evidence_id:
phase === "source-resolution-failure"
? `ev_${"f".repeat(64)}`
: parent.evidence_id,
}
: source === "evidence-file"
? { kind: "evidence-file", path }
: { kind: "inline", evidence: parent },
view: { kind: "summary" },
};
await writeFile(
path,
JSON.stringify(
source === "bundle"
? {
...createEvidenceBundle([parent]),
...(phase === "authentication-failure"
? { records: [{ ...parent, normalized_result: "altered" }] }
: {}),
}
: source === "evidence-file"
? parent
: request,
),
);
let interruptHandled = false;
let pendingInterrupt: Promise<void> | undefined;
const interrupt = () => {
const listener = host.listeners.get(signal);
interruptHandled = listener !== undefined;
listener?.();
};
const queueInterrupt = () => {
pendingInterrupt = new Promise((resolve) => {
setImmediate(() => {
interrupt();
resolve();
});
});
};
const expectedProjection = await referenceViewEvidence(
request,
path,
phase,
);
// Intercept the prepared owner, whose project method keeps its admission
// budget and calls the domain projector lexically rather than by export.
const originalPrepare = analysisView.prepareAnalysisViewProjection;
let projected: ReturnType<PreparedView["project"]> | undefined;
const project = vi
.fn<(parent: Parameters<PreparedView["project"]>[0]) => void>()
.mockName("preparedProjection.project");
vi.spyOn(analysisView, "prepareAnalysisViewProjection").mockImplementation(
(...args) => {
const projection = originalPrepare(...args);
const originalProject = projection.project;
vi.spyOn(projection, "project").mockImplementation((parent) => {
project(parent);
projected = originalProject.call(projection, parent);
if (phase === "projection") queueInterrupt();
return projected;
});
return projection;
},
);
const originalResolve = evidenceInputResolver.resolveEvidenceInput;
const resolve = vi
.spyOn(evidenceInputResolver, "resolveEvidenceInput")
.mockImplementation((...args) => {
const resolved = originalResolve(...args);
if (phase === "source-resolution-failure") queueInterrupt();
return resolved;
});
const originalClose = OwnedFileHandle.prototype.close;
const close = vi
.spyOn(OwnedFileHandle.prototype, "close")
.mockImplementation(async function (this: OwnedFileHandle) {
await originalClose.call(this);
expect(this.handle.fd).toBe(-1);
if (signal !== "control" && phase === "close") interrupt();
if (phase.startsWith("authentication")) queueInterrupt();
});
const cli = createCommandCli();
registerAnalysisViewCommands(cli, silentLogger);
let output = "";
const previousExitCode = process.exitCode;
try {
process.exitCode = undefined;
await cli.serve(
[
"inspect-analysis-view",
source === "request-file" ? path : JSON.stringify(request),
...(source === "bundle" ? ["--evidence-bundle", path] : []),
"--json",
],
{
stdout: (part) => {
output += part;
},
exit: () => {},
},
);
expect(close).toHaveBeenCalledOnce();
expect(host.listeners.size).toBe(0);
expect(await readdir(root)).toEqual([filename]);
const result = JSON.parse(output);
expect(result).toMatchObject(
signal === "control"
? { operation: "inspect_analysis_view" }
: {
code: phase.endsWith("failure")
? "evidence_integrity_mismatch"
: "cancelled",
},
);
expect(process.exitCode ?? 0).toBe(
signal === "SIGINT" ? 130 : signal === "SIGTERM" ? 143 : 0,
);
if (signal !== "control") expect(interruptHandled).toBe(true);
expect(project).toHaveBeenCalledTimes(
Number(signal === "control" || phase === "projection"),
);
if (phase.startsWith("authentication"))
expect(resolve).not.toHaveBeenCalled();
if (phase === "projection" || phase === "source-resolution-failure")
expect(resolve).toHaveBeenCalledOnce();
if (phase === "projection") {
expectRetainedProjection(
result.details.partial_observation,
expectedProjection,
projected,
parent,
);
}
} finally {
await pendingInterrupt;
process.exitCode = previousExitCode;
}
},
);