From 966dc3acde2880a0f94b2658e2a02180d505cafa Mon Sep 17 00:00:00 2001 From: Ysopwnable <161784452+N0zoM1z0@users.noreply.github.com> Date: Sun, 11 Oct 2026 13:53:01 +0800 Subject: [PATCH] perf(evidence): reuse authenticated file snapshots during session import (#1721) Seal file-backed MCP imports at the session boundary while preserving mutable ordinary file reads. Validate internally constructed ledger candidates directly with the existing immutable bundle constructor. Assisted-by: Suika (gensokyo-skills:suika-scatter-gather-planning) --- src/application/EvidenceBundleFiles.ts | 20 +++- .../investigation/EvidenceLedger.ts | 5 +- src/server/registerSessionRecordTools.ts | 4 +- .../filesystem/evidenceBundleFiles.test.ts | 99 ++++++++++++++----- 4 files changed, 95 insertions(+), 33 deletions(-) diff --git a/src/application/EvidenceBundleFiles.ts b/src/application/EvidenceBundleFiles.ts index 4c7e310c7..f3441c64d 100644 --- a/src/application/EvidenceBundleFiles.ts +++ b/src/application/EvidenceBundleFiles.ts @@ -1,4 +1,5 @@ import { + createImmutableEvidenceBundle, describeEvidenceBundleFailure, describeValidationFailure, parseEvidenceBundle, @@ -30,14 +31,29 @@ type EvidenceWriteFailure = | AnalysisCancelledError; /** Read and validate an evidence bundle at the caller-supplied path. */ -export const readEvidenceBundle = async ( +export const readEvidenceBundle = ( path: string, +): Promise> => + readBundle(path, parseEvidenceBundle); + +/** Read an authenticated immutable snapshot for a subsequent session import. */ +export const readImmutableEvidenceBundle = ( + path: string, +): Promise> => + readBundle(path, (input) => { + const bundle = parseEvidenceBundle(input); + return createImmutableEvidenceBundle(bundle.records, bundle.unknowns); + }); + +const readBundle = async ( + path: string, + parseBundle: (input: unknown) => EvidenceBundle, ): Promise> => { const loaded = await readJsonFile(path); if (!loaded.ok) return loaded; let bundle: EvidenceBundle; try { - bundle = parseEvidenceBundle(loaded.value); + bundle = parseBundle(loaded.value); } catch (cause: unknown) { return err( new EvidenceIntegrityError("Evidence bundle validation failed", { diff --git a/src/application/investigation/EvidenceLedger.ts b/src/application/investigation/EvidenceLedger.ts index 6a2900c6f..1b88c5737 100644 --- a/src/application/investigation/EvidenceLedger.ts +++ b/src/application/investigation/EvidenceLedger.ts @@ -417,8 +417,9 @@ export class EvidenceLedger { unknowns: ReadonlyMap, ): Result { try { - parseEvidenceBundle( - createEvidenceBundle([...records.values()], [...unknowns.values()]), + createImmutableEvidenceBundle( + [...records.values()], + [...unknowns.values()], ); } catch (cause: unknown) { return err(new UnknownRegistryError("integrity", { cause })); diff --git a/src/server/registerSessionRecordTools.ts b/src/server/registerSessionRecordTools.ts index 998fa5d59..4b8856bfd 100644 --- a/src/server/registerSessionRecordTools.ts +++ b/src/server/registerSessionRecordTools.ts @@ -2,7 +2,7 @@ import type { EvidenceMcpServer } from "./EvidenceMcpServer.js"; import type { BinarySessionPort } from "../application/binary/BinarySessionPort.js"; import { - readEvidenceBundle, + readImmutableEvidenceBundle, writeEvidenceBundle, } from "../application/EvidenceBundleFiles.js"; import { toolContract } from "../contracts/toolContracts.js"; @@ -91,7 +91,7 @@ const registerImportEvidenceTool = ({ toolRegistrationOptions(importContract), async (input) => { const path = input.path; - const loaded = await readEvidenceBundle(path); + const loaded = await readImmutableEvidenceBundle(path); if (!loaded.ok) return server.delivery.toCallToolResult(loaded, importContract); const retainedUnknownRevisions = new Set( diff --git a/tests/boundary/filesystem/evidenceBundleFiles.test.ts b/tests/boundary/filesystem/evidenceBundleFiles.test.ts index d5a92938a..661a2b18a 100644 --- a/tests/boundary/filesystem/evidenceBundleFiles.test.ts +++ b/tests/boundary/filesystem/evidenceBundleFiles.test.ts @@ -14,9 +14,11 @@ import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js"; import { readEvidenceBundle, + readImmutableEvidenceBundle, writeEvidenceBundle, } from "../../../src/application/EvidenceBundleFiles.js"; import { compareEvidenceBundlesCommand } from "../../../src/application/EvidenceBundleCommands.js"; +import { EvidenceLedger } from "../../../src/application/investigation/EvidenceLedger.js"; import { projectAnalysisError } from "../../../src/domain/analysisErrorProjection.js"; import { createEvidence } from "../../../src/domain/evidence.js"; import { writeTextParts } from "../../../src/application/JsonFiles.js"; @@ -209,6 +211,46 @@ describe("evidence bundle publication", () => { }); }); +it("reuses authenticated file snapshots while isolating mutable public reads", async () => { + const directory = await createTestTempDirectory("rea-evidence-owned-"); + const path = join(directory, "bundle.json"); + const evidence = createEvidence( + { + path: "/local/observed-target", + sha256: "a".repeat(64), + format: "file", + }, + { id: "fixture", name: "Fixture", version: "1" }, + { operation: "health", parameters: {}, result: { nested: [true] } }, + ); + const source = serializeEvidenceBundle(createEvidenceBundle([evidence])); + await writeFile(path, source); + const mutable = await readEvidenceBundle(path); + if (!mutable.ok) throw mutable.error; + expect(Object.isFrozen(mutable.value.records[0])).toBe(false); + const loaded = await readImmutableEvidenceBundle(path); + if (!loaded.ok) throw loaded.error; + const record = loaded.value.records[0]; + if (record === undefined) throw new Error("Expected an imported record"); + expect(record).toEqual(evidence); + expect(Object.isFrozen(loaded.value)).toBe(true); + expect(Object.isFrozen(record.normalized_result)).toBe(true); + expect(Reflect.set(record, "operation", "forged")).toBe(false); + + const ledger = new EvidenceLedger(); + const imported = ledger.import(loaded.value); + if (!imported.ok) throw imported.error; + expect(imported.value).toMatchObject({ recordsAdded: 1, changed: true }); + expect(ledger.forAnalysis(evidence.evidence_id)).toBe(record); + const detached = ledger.get(evidence.evidence_id); + if (detached === undefined) throw new Error("Expected a detached record"); + expect(Reflect.set(detached, "normalized_result", false)).toBe(true); + expect(ledger.record(detached).ok).toBe(false); + expect(ledger.export()).toEqual(loaded.value); + expect(await readFile(path, "utf8")).toBe(source); + ledger.clear(); +}); + describe("evidence bundle filesystem adapter", () => { it("round trips canonical bytes and requires explicit overwrite", async () => { const directory = await createTestTempDirectory("rea-evidence-"); @@ -290,34 +332,37 @@ describe("evidence bundle filesystem adapter", () => { ); }); - it("rejects malformed and tampered input", async () => { - const directory = await createTestTempDirectory("rea-evidence-"); - const malformed = join(directory, "malformed.json"); - await writeFile(malformed, "{"); - expect(await readEvidenceBundle(malformed)).toMatchObject({ - ok: false, - error: { _tag: "EvidenceFileError", reason: "invalid-json" }, - }); + it.each([readEvidenceBundle, readImmutableEvidenceBundle])( + "rejects malformed and tampered input (%s)", + async (readBundle) => { + const directory = await createTestTempDirectory("rea-evidence-"); + const malformed = join(directory, "malformed.json"); + await writeFile(malformed, "{"); + expect(await readBundle(malformed)).toMatchObject({ + ok: false, + error: { _tag: "EvidenceFileError", reason: "invalid-json" }, + }); - const tampered = bundle(); - const tamperedPath = join(directory, "tampered.json"); - await writeFile( - tamperedPath, - JSON.stringify({ - ...tampered, - records: [{ ...tampered.records[0], normalized_result: "changed" }], - }), - ); - expect(await readEvidenceBundle(tamperedPath)).toMatchObject({ - ok: false, - error: { - _tag: "EvidenceIntegrityError", - userMessage: expect.stringContaining( - "at records.0.evidence_id: Evidence semantic identifier does not match its record", - ), - }, - }); - }); + const tampered = bundle(); + const tamperedPath = join(directory, "tampered.json"); + await writeFile( + tamperedPath, + JSON.stringify({ + ...tampered, + records: [{ ...tampered.records[0], normalized_result: "changed" }], + }), + ); + expect(await readBundle(tamperedPath)).toMatchObject({ + ok: false, + error: { + _tag: "EvidenceIntegrityError", + userMessage: expect.stringContaining( + "at records.0.evidence_id: Evidence semantic identifier does not match its record", + ), + }, + }); + }, + ); it("names the failed bundle constraint for a single record or schema mismatch", async () => { const directory = await createTestTempDirectory("rea-evidence-");