From e5699d23b173bbd0b68e3ab177d0b7583d6df345 Mon Sep 17 00:00:00 2001 From: Ysopwnable <161784452+N0zoM1z0@users.noreply.github.com> Date: Sun, 11 Oct 2026 15:59:21 +0800 Subject: [PATCH] fix(mcp): cancel evidence imports before session mutation Propagate request cancellation through immutable JSON bundle reading and check it before committing session state. Preserve failed-close ownership. Fixes #1746 Assisted-by: Suika (gensokyo-skills:suika-scatter-gather-planning) --- src/application/EvidenceBundleFiles.ts | 34 ++++- src/application/JsonFiles.ts | 7 +- src/server/registerSessionRecordTools.ts | 13 +- .../filesystem/evidenceBundleFiles.test.ts | 54 ++++++- .../mcp/evidenceImportCancellation.test.ts | 139 ++++++++++++++++++ 5 files changed, 235 insertions(+), 12 deletions(-) create mode 100644 tests/boundary/mcp/evidenceImportCancellation.test.ts 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> => - 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> => { - 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 = /** Read JSON data from a regular file at the caller-supplied path. */ export const readJsonFile = async ( path: string, + signal?: AbortSignal, ): Promise< Result > => - 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((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((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(); +});