Skip to content

armgit / rea

Public Imported from GitHub
0

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

fix(mcp): cancel evidence imports before session mutation

Ysopwnablee5699d23b173
diff --git a/src/application/EvidenceBundleFiles.ts b/src/application/EvidenceBundleFiles.ts
index f3441c64d..dfc63b884 100644
--- a/src/application/EvidenceBundleFiles.ts
+++ b/src/application/EvidenceBundleFiles.ts
@@ -20,11 +20,13 @@ import {
canonicalJsonParts,
} from "../domain/jsonSerialization.js";
import { readJsonFile, writeTextParts } from "./JsonFiles.js";
+import { RegularFileCleanupFailure } from "./RegularFileRead.js";
type EvidenceReadFailure =
| EvidenceFileError
| EvidenceIntegrityError
- | AnalysisResourceConstraintError;
+ | AnalysisResourceConstraintError
+ | AnalysisCancelledError;
type EvidenceWriteFailure =
| EvidenceFileError
| EvidenceIntegrityError
@@ -39,18 +41,38 @@ export const readEvidenceBundle = (
/** Read an authenticated immutable snapshot for a subsequent session import. */
export const readImmutableEvidenceBundle = (
path: string,
+ signal?: AbortSignal,
): Promise<Result<EvidenceBundle, EvidenceReadFailure>> =>
- readBundle(path, (input) => {
- const bundle = parseEvidenceBundle(input);
- return createImmutableEvidenceBundle(bundle.records, bundle.unknowns);
- });
+ readBundle(
+ path,
+ (input) => {
+ const bundle = parseEvidenceBundle(input);
+ return createImmutableEvidenceBundle(bundle.records, bundle.unknowns);
+ },
+ signal,
+ );
const readBundle = async (
path: string,
parseBundle: (input: unknown) => EvidenceBundle,
+ signal?: AbortSignal,
): Promise<Result<EvidenceBundle, EvidenceReadFailure>> => {
- const loaded = await readJsonFile(path);
+ if (signal?.aborted)
+ return err(new AnalysisCancelledError("import_evidence_bundle"));
+ const loaded = await readJsonFile(path, signal).catch((cause: unknown) => {
+ // A failed close transfers a live handle owner; preserve that failure.
+ if (
+ signal?.aborted === true &&
+ !(cause instanceof RegularFileCleanupFailure)
+ )
+ return err(
+ new AnalysisCancelledError("import_evidence_bundle", { cause }),
+ );
+ throw cause;
+ });
if (!loaded.ok) return loaded;
+ if (signal?.aborted)
+ return err(new AnalysisCancelledError("import_evidence_bundle"));
let bundle: EvidenceBundle;
try {
bundle = parseBundle(loaded.value);
diff --git a/src/application/JsonFiles.ts b/src/application/JsonFiles.ts
index 3bb79b39e..1eb9a7650 100644
--- a/src/application/JsonFiles.ts
+++ b/src/application/JsonFiles.ts
@@ -35,11 +35,14 @@ type TextWriteResult<Failure = EvidenceFileError | AnalysisCancelledError> =
/** Read JSON data from a regular file at the caller-supplied path. */
export const readJsonFile = async (
path: string,
+ signal?: AbortSignal,
): Promise<
Result<unknown, EvidenceFileError | AnalysisResourceConstraintError>
> =>
- readJsonFileInput(path, (selected) =>
- readJsonInputFile(selected, "read_evidence_file"),
+ readJsonFileInput(
+ path,
+ (selected) => readJsonInputFile(selected, "read_evidence_file", signal),
+ signal,
);
/** Read selected JSON members through the same regular-file error boundary. */
diff --git a/src/server/registerSessionRecordTools.ts b/src/server/registerSessionRecordTools.ts
index 4b8856bfd..a1558fed4 100644
--- a/src/server/registerSessionRecordTools.ts
+++ b/src/server/registerSessionRecordTools.ts
@@ -7,7 +7,8 @@ import {
} from "../application/EvidenceBundleFiles.js";
import { toolContract } from "../contracts/toolContracts.js";
import type { EvidenceBundle } from "../domain/evidenceBundle.js";
-import { ok } from "../domain/result.js";
+import { err, ok } from "../domain/result.js";
+import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
import { inspectEvidenceBundle } from "../application/investigation/InspectEvidenceBundle.js";
import { toolRegistrationOptions } from "./toolRegistrationOptions.js";
@@ -89,9 +90,10 @@ const registerImportEvidenceTool = ({
server.registerTool(
importContract.name,
toolRegistrationOptions(importContract),
- async (input) => {
+ async (input, context) => {
const path = input.path;
- const loaded = await readImmutableEvidenceBundle(path);
+ const signal = context.mcpReq.signal;
+ const loaded = await readImmutableEvidenceBundle(path, signal);
if (!loaded.ok)
return server.delivery.toCallToolResult(loaded, importContract);
const retainedUnknownRevisions = new Set(
@@ -99,6 +101,11 @@ const registerImportEvidenceTool = ({
unknownRevisionKey(unknown),
),
);
+ if (signal.aborted)
+ return server.delivery.toCallToolResult(
+ err(new AnalysisCancelledError("import_evidence_bundle")),
+ importContract,
+ );
const imported = session.importEvidenceBundle(loaded.value);
return imported.ok
? server.delivery.toCallToolResult(
diff --git a/tests/boundary/filesystem/evidenceBundleFiles.test.ts b/tests/boundary/filesystem/evidenceBundleFiles.test.ts
index 661a2b18a..267d381ce 100644
--- a/tests/boundary/filesystem/evidenceBundleFiles.test.ts
+++ b/tests/boundary/filesystem/evidenceBundleFiles.test.ts
@@ -8,7 +8,7 @@ import {
} from "node:fs/promises";
import { join } from "node:path";
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, vi } from "vitest";
import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";
@@ -19,6 +19,8 @@ import {
} from "../../../src/application/EvidenceBundleFiles.js";
import { compareEvidenceBundlesCommand } from "../../../src/application/EvidenceBundleCommands.js";
import { EvidenceLedger } from "../../../src/application/investigation/EvidenceLedger.js";
+import { RegularFileCleanupFailure } from "../../../src/application/RegularFileRead.js";
+import { OwnedFileHandle } from "../../../src/filesystem/OwnedFileHandle.js";
import { projectAnalysisError } from "../../../src/domain/analysisErrorProjection.js";
import { createEvidence } from "../../../src/domain/evidence.js";
import { writeTextParts } from "../../../src/application/JsonFiles.js";
@@ -36,6 +38,56 @@ const bundle = (result = true) =>
),
]);
+it("returns import cancellation before inspecting a selected path", async () => {
+ const root = await createTestTempDirectory("rea-import-pre-cancel-");
+ const controller = new AbortController();
+ controller.abort(new Error("cancel before import"));
+ expect(
+ await readImmutableEvidenceBundle(
+ join(root, "missing.json"),
+ controller.signal,
+ ),
+ ).toMatchObject({
+ ok: false,
+ error: {
+ _tag: "AnalysisCancelledError",
+ operation: "import_evidence_bundle",
+ },
+ });
+ expect(await readdir(root)).toEqual([]);
+});
+
+it("preserves the failed-close owner when import is also cancelled", async () => {
+ const root = await createTestTempDirectory("rea-import-cancel-cleanup-");
+ const path = join(root, "bundle.json");
+ await writeFile(path, JSON.stringify(bundle()));
+ const controller = new AbortController();
+ const cleanupCause = new Error("fixture close failure");
+ const close = vi
+ .spyOn(OwnedFileHandle.prototype, "close")
+ .mockImplementationOnce(async () => {
+ controller.abort(new Error("cancel during cleanup"));
+ throw cleanupCause;
+ });
+ let failure: unknown;
+ try {
+ try {
+ await readImmutableEvidenceBundle(path, controller.signal);
+ } catch (cause: unknown) {
+ failure = cause;
+ }
+ expect(failure).toBeInstanceOf(RegularFileCleanupFailure);
+ if (!(failure instanceof RegularFileCleanupFailure))
+ throw new Error("Expected the retained file handle owner");
+ expect(failure.cleanupCause).toBe(cleanupCause);
+ } finally {
+ close.mockRestore();
+ if (failure instanceof RegularFileCleanupFailure)
+ await failure.owner.close();
+ }
+ expect(await readEvidenceBundle(path)).toMatchObject({ ok: true });
+});
+
describe("evidence bundle export cancellation", () => {
it("does not inspect the path or advance a source cancelled before writing", async () => {
const root = await createTestTempDirectory("rea-export-pre-cancel-");
diff --git a/tests/boundary/mcp/evidenceImportCancellation.test.ts b/tests/boundary/mcp/evidenceImportCancellation.test.ts
new file mode 100644
index 000000000..cb65dc71a
--- /dev/null
+++ b/tests/boundary/mcp/evidenceImportCancellation.test.ts
@@ -0,0 +1,139 @@
+import { Client, InMemoryTransport } from "@modelcontextprotocol/client";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { expect, it, onTestFinished, vi } from "vitest";
+import { AnalysisCancelledError } from "../../../src/domain/analysisErrorCore.js";
+import { createEvidence } from "../../../src/domain/evidence.js";
+import { createEvidenceBundle } from "../../../src/domain/evidenceBundle.js";
+import { createServer } from "../../../src/server/createServer.js";
+import { ToolResultDelivery } from "../../../src/server/toolResult.js";
+import { createTestBinarySession } from "../../fixtures/binarySession.js";
+import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";
+
+it("keeps the complete session unchanged after SDK import cancellation and permits a retry", async () => {
+ const root = await createTestTempDirectory("rea-mcp-import-cancel-");
+ const path = join(root, "bundle.json");
+ const session = createTestBinarySession(() => {
+ throw new Error("Evidence import must not start a binary provider");
+ });
+ const provider = { id: "fixture", name: "Fixture", version: "1" };
+ const existing = createEvidence(undefined, provider, {
+ operation: "existing_observation",
+ parameters: {},
+ result: { retained: true },
+ });
+ const recorded = session.recordEvidence(existing);
+ if (!recorded.ok) throw recorded.error;
+ const imported = createEvidence(undefined, provider, {
+ operation: "imported_observation",
+ parameters: {},
+ result: { retained: "雪😀" },
+ });
+ const bundle = createEvidenceBundle([imported]);
+ // Valid whitespace crosses the streaming threshold without a large JSON tree.
+ await writeFile(path, " ".repeat(9 * 1024 * 1024) + JSON.stringify(bundle));
+ const server = createServer({ kind: "session", session });
+ const client = new Client({
+ name: "evidence-import-cancellation",
+ version: "1",
+ });
+ const controller = new AbortController();
+ onTestFinished(async () => {
+ controller.abort();
+ vi.restoreAllMocks();
+ await client.close();
+ await server.close();
+ await session.close();
+ });
+ const [clientTransport, serverTransport] =
+ InMemoryTransport.createLinkedPair();
+ await server.connect(serverTransport);
+ await client.connect(clientTransport);
+ const unknown = await client.callTool({
+ name: "record_unknown",
+ arguments: {
+ question: "Which boundary remains unknown?",
+ domain: "fixture",
+ severity: "medium",
+ required_authority: null,
+ required_confidence: "derived",
+ required_environment: null,
+ recommended_probes: [],
+ relationships: [],
+ },
+ });
+ expect(unknown.isError, JSON.stringify(unknown)).not.toBe(true);
+ const before = session.exportEvidenceBundle();
+
+ let resolveDispatched: (() => void) | undefined;
+ const dispatched = new Promise<void>((resolve) => {
+ resolveDispatched = resolve;
+ });
+ const send = clientTransport.send.bind(clientTransport);
+ vi.spyOn(clientTransport, "send").mockImplementation(
+ async (message, ...args) => {
+ await send(message, ...args);
+ if ("method" in message && message.method === "tools/call")
+ resolveDispatched?.();
+ },
+ );
+ let resolveCompleted: (() => void) | undefined;
+ const completed = new Promise<void>((resolve) => {
+ resolveCompleted = resolve;
+ });
+ let settledResult: unknown;
+ const deliver = ToolResultDelivery.prototype.toCallToolResult;
+ vi.spyOn(ToolResultDelivery.prototype, "toCallToolResult").mockImplementation(
+ function (this: ToolResultDelivery, result, contract) {
+ const reply = deliver.call(this, result, contract);
+ if (contract.name === "import_evidence_bundle") {
+ settledResult = result;
+ resolveCompleted?.();
+ }
+ return reply;
+ },
+ );
+ const cancellation = client
+ .callTool(
+ { name: "import_evidence_bundle", arguments: { path } },
+ { signal: controller.signal },
+ )
+ .then(
+ () => "completed",
+ (error: unknown) => error,
+ );
+ await dispatched;
+ // The real SDK ping completes while the dispatched file reader awaits I/O.
+ await client.ping();
+ controller.abort(new Error("SDK import cancellation verification"));
+ expect(await cancellation).toMatchObject({
+ message: expect.stringContaining("SDK import cancellation verification"),
+ });
+ // Observe handler settlement, not just the client's local rejection.
+ await completed;
+ expect(session.exportEvidenceBundle()).toEqual(before);
+ expect(settledResult).toMatchObject({
+ ok: false,
+ error: expect.any(AnalysisCancelledError),
+ });
+ await client.ping();
+ const retry = await client.callTool({
+ name: "import_evidence_bundle",
+ arguments: { path },
+ });
+ expect(retry.isError, JSON.stringify(retry)).not.toBe(true);
+ expect(retry.structuredContent).toMatchObject({
+ result: {
+ imported: 1,
+ unknowns_added: 0,
+ total: before.records.length + 1,
+ },
+ });
+ const after = session.exportEvidenceBundle();
+ expect(after.unknowns).toEqual(before.unknowns);
+ expect(after.records).toHaveLength(before.records.length + 1);
+ expect(after.records).toEqual(
+ expect.arrayContaining([...before.records, imported]),
+ );
+ await client.ping();
+});