Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
fix(mcp): cancel evidence imports before session mutation
Ysopwnablee5699d23b173
diff --git a/src/application/EvidenceBundleFiles.ts b/src/application/EvidenceBundleFiles.tsindex 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.tsindex 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.tsindex 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.tsindex 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.tsnew file mode 100644index 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();+});