diff --git a/src/application/ArtifactInventory/scanReader.ts b/src/application/ArtifactInventory/scanReader.ts index 3cce29b67..27dceaf0b 100644 --- a/src/application/ArtifactInventory/scanReader.ts +++ b/src/application/ArtifactInventory/scanReader.ts @@ -73,6 +73,12 @@ export const scanReader = async ( registry: new ArtifactPathRegistry(), }; await visitArtifactEntries(context, reader, ""); + // Archive directories may appear after their children. Resolve containment + // against the complete index before directory identities are materialized. + for (const occurrence of occurrences) + occurrence.parent_occurrence_id = + nearestParent(occurrence.logical_path, context.occurrenceByPath) + ?.occurrence_id ?? null; return { nodes, occurrences, pendingContradictions }; }; @@ -115,12 +121,7 @@ const visitArtifactEntries = async ( logicalPath, expandableAsar ? "directory" : entry.kind, ); - const parent = nearestParent(logicalPath, context.occurrenceByPath); - const occurrence = createOccurrence( - entry, - logicalPath, - parent?.occurrence_id ?? null, - ); + const occurrence = createOccurrence(entry, logicalPath, null); let digested: | { readonly node: ArtifactNode; readonly mismatched: boolean } | undefined; diff --git a/tests/boundary/filesystem/artifactInventoryEntryOrder.test.ts b/tests/boundary/filesystem/artifactInventoryEntryOrder.test.ts new file mode 100644 index 000000000..d4532b659 --- /dev/null +++ b/tests/boundary/filesystem/artifactInventoryEntryOrder.test.ts @@ -0,0 +1,136 @@ +import { mkdir, writeFile } from "node:fs/promises"; +import { join } from "node:path"; + +import { createPackage } from "@electron/asar"; +import { describe, expect, it } from "vitest"; + +import { inventoryArtifact } from "../../../src/application/ArtifactInventory.js"; +import { + artifactOccurrenceAt, + artifactParentPaths, + writeOrderedZip, +} from "../../fixtures/artifactEntryOrder.js"; +import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js"; + +const permutations = [ + ["pkg/", "pkg/sub/", "pkg/sub/data.txt"], + ["pkg/", "pkg/sub/data.txt", "pkg/sub/"], + ["pkg/sub/", "pkg/", "pkg/sub/data.txt"], + ["pkg/sub/", "pkg/sub/data.txt", "pkg/"], + ["pkg/sub/data.txt", "pkg/", "pkg/sub/"], + ["pkg/sub/data.txt", "pkg/sub/", "pkg/"], +]; +const expectedParents = { + ".": null, + empty: ".", + pkg: ".", + "pkg/sub": "pkg", + "pkg/sub/data.txt": "pkg/sub", +}; + +describe("artifact inventory entry order", () => { + it.each(permutations.map((entries) => ({ entries })))( + "parents ZIP entries correctly for $entries", + async ({ entries }) => { + const root = await createTestTempDirectory("rea-entry-order-"); + const archive = join(root, "ordered.zip"); + const referencePath = join(root, "reference.zip"); + await writeOrderedZip(archive, [...entries, "empty/"]); + await writeOrderedZip(referencePath, [ + "pkg/", + "pkg/sub/", + "pkg/sub/data.txt", + "empty/", + ]); + const observed = await inventoryArtifact(archive); + const reference = await inventoryArtifact(referencePath); + expect(artifactParentPaths(observed)).toEqual(expectedParents); + expect( + observed.occurrences.map(({ logical_path }) => logical_path), + ).toEqual(Object.keys(expectedParents)); + for (const [path, parentPath] of Object.entries(expectedParents)) { + if (parentPath === null) continue; + const occurrence = artifactOccurrenceAt(observed, path); + const parent = artifactOccurrenceAt(observed, parentPath); + expect(observed.edges).toContainEqual( + expect.objectContaining({ + logical_path: path, + relation: "contains", + parent_artifact_id: parent.artifact_id, + child_artifact_id: occurrence.artifact_id, + }), + ); + } + const empty = artifactOccurrenceAt(observed, "empty").artifact_id; + for (const path of ["pkg", "pkg/sub"]) { + const identity = artifactOccurrenceAt(observed, path).artifact_id; + expect(identity).not.toBeNull(); + expect(identity).not.toBe(empty); + expect(identity).toBe( + artifactOccurrenceAt(reference, path).artifact_id, + ); + } + expect(await inventoryArtifact(archive)).toEqual(observed); + }, + ); + + it.each([ + { + entries: ["pkg/sub/data.txt"], + parents: { ".": null, "pkg/sub/data.txt": "." }, + }, + { + entries: ["pkg/sub/data.txt", "pkg/"], + parents: { ".": null, pkg: ".", "pkg/sub/data.txt": "pkg" }, + }, + { + entries: ["pkg/sub/data.txt", "pkg/sub/"], + parents: { ".": null, "pkg/sub": ".", "pkg/sub/data.txt": "pkg/sub" }, + }, + ])( + "uses only observed directory parents for $entries", + async ({ entries, parents }) => { + const root = await createTestTempDirectory("rea-implicit-directory-"); + const archive = join(root, "implicit.zip"); + await writeOrderedZip(archive, entries); + expect(artifactParentPaths(await inventoryArtifact(archive))).toEqual( + parents, + ); + }, + ); +}); + +describe("entry-order validation and reader controls", () => { + it.each([ + ["pkg/data.txt", "pkg/data.txt/"], + ["pkg/data.txt/", "pkg/data.txt"], + ["pkg/data.txt", "PKG/other.txt"], + ["pkg/data.txt", "pkg"], + ["../escape.txt"], + ])("keeps invalid/colliding paths rejected for %j", async (...entries) => { + const root = await createTestTempDirectory("rea-entry-order-invalid-"); + const archive = join(root, "invalid.zip"); + await writeOrderedZip(archive, entries); + await expect(inventoryArtifact(archive)).rejects.toMatchObject({ + reason: "path", + }); + }); + + it("preserves ordinary directory and ASAR structure", async () => { + const root = await createTestTempDirectory("rea-entry-order-readers-"); + const directory = join(root, "source"); + await mkdir(join(directory, "pkg", "sub"), { recursive: true }); + await mkdir(join(directory, "empty")); + await writeFile(join(directory, "pkg", "sub", "data.txt"), "evidence\n"); + const archive = join(root, "fixture.asar"); + await createPackage(directory, archive); + const filesystem = await inventoryArtifact(directory); + const asar = await inventoryArtifact(archive); + expect(artifactParentPaths(filesystem)).toEqual(expectedParents); + expect(artifactParentPaths(asar)).toEqual(expectedParents); + for (const path of ["empty", "pkg", "pkg/sub"]) + expect(artifactOccurrenceAt(asar, path).artifact_id).toBe( + artifactOccurrenceAt(filesystem, path).artifact_id, + ); + }); +}); diff --git a/tests/boundary/mcp/artifactEntryOrderMcp.test.ts b/tests/boundary/mcp/artifactEntryOrderMcp.test.ts new file mode 100644 index 000000000..9fe438994 --- /dev/null +++ b/tests/boundary/mcp/artifactEntryOrderMcp.test.ts @@ -0,0 +1,67 @@ +import { join } from "node:path"; + +import { Client, InMemoryTransport } from "@modelcontextprotocol/client"; +import { expect, it } from "vitest"; +import { z } from "zod"; + +import { parseConfig } from "../../../src/config.js"; +import { createBinarySession } from "../../../src/application/runtime.js"; +import { createServer } from "../../../src/server/createServer.js"; +import { artifactInspectionResultSchema } from "../../../src/domain/artifactInspection.js"; +import { artifactInventoryResultSchema } from "../../../src/domain/artifactGraph.js"; +import { + artifactParentPaths, + writeOrderedZip, +} from "../../fixtures/artifactEntryOrder.js"; +import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js"; + +it("returns correct child-first ZIP containment through MCP inspection", async () => { + const root = await createTestTempDirectory("rea-entry-order-mcp-"); + const archive = join(root, "child-first.zip"); + await writeOrderedZip(archive, ["pkg/sub/data.txt", "pkg/sub/", "pkg/"]); + const configured = parseConfig({}); + if (!configured.ok) throw configured.error; + const session = createBinarySession(configured.value); + const server = createServer(session, session); + const client = new Client({ name: "entry-order-test", version: "1" }); + const [clientTransport, serverTransport] = + InMemoryTransport.createLinkedPair(); + try { + await server.connect(serverTransport); + await client.connect(clientTransport); + expect( + ( + await client.callTool({ + name: "open_binary", + arguments: { path: archive }, + }) + ).isError, + ).not.toBe(true); + const called = await client.callTool({ + name: "inspect_artifact", + arguments: {}, + }); + expect(called.isError, JSON.stringify(called.structuredContent)).not.toBe( + true, + ); + const inspection = artifactInspectionResultSchema.parse( + z.object({ result: z.unknown() }).parse(called.structuredContent).result, + ); + const substep = inspection.substeps[0]; + if (substep === undefined) throw new Error("Missing inventory Evidence"); + const inventory = artifactInventoryResultSchema.parse( + substep.evidence.normalized_result, + ); + expect(artifactParentPaths(inventory)).toEqual({ + ".": null, + pkg: ".", + "pkg/sub": "pkg", + "pkg/sub/data.txt": "pkg/sub", + }); + expect(inspection.coverage.status).toBe("complete-within-substeps"); + } finally { + await client.close(); + await server.close(); + await session.close(); + } +}); diff --git a/tests/fixtures/artifactEntryOrder.ts b/tests/fixtures/artifactEntryOrder.ts new file mode 100644 index 000000000..5076ea865 --- /dev/null +++ b/tests/fixtures/artifactEntryOrder.ts @@ -0,0 +1,58 @@ +import { writeFile } from "node:fs/promises"; + +import { TextReader, Uint8ArrayWriter, ZipWriter } from "@zip.js/zip.js"; + +import type { ArtifactInventoryResult } from "../../src/domain/artifactGraph.js"; + +/** Write real ZIP entries in the supplied central-directory order. */ +export const writeOrderedZip = async ( + path: string, + entries: readonly string[], +): Promise => { + const writer = new ZipWriter(new Uint8ArrayWriter()); + for (const entry of entries) { + const directory = entry.endsWith("/"); + await writer.add( + entry, + directory ? undefined : new TextReader("evidence\n"), + { + directory, + lastModDate: new Date("2020-01-01T00:00:00Z"), + }, + ); + } + await writeFile(path, await writer.close()); +}; + +/** Express occurrence parents by logical path for structural assertions. */ +export const artifactParentPaths = ( + inventory: ArtifactInventoryResult, +): Record => { + const paths = new Map( + inventory.occurrences.map((item) => [ + item.occurrence_id, + item.logical_path, + ]), + ); + return Object.fromEntries( + inventory.occurrences.map((item) => [ + item.logical_path, + item.parent_occurrence_id === null + ? null + : (paths.get(item.parent_occurrence_id) ?? "missing-parent"), + ]), + ); +}; + +/** Require an explicitly observed occurrence in a real inventory. */ +export const artifactOccurrenceAt = ( + inventory: ArtifactInventoryResult, + path: string, +) => { + const occurrence = inventory.occurrences.find( + (item) => item.logical_path === path, + ); + if (occurrence === undefined) + throw new Error(`Missing inventory path: ${path}`); + return occurrence; +};