rea/tests/acceptance/inesContainer.test.ts

import { createHash } from "node:crypto";
import { readFile, rm, writeFile } from "node:fs/promises";
import { join } from "node:path";
import { expect } from "vitest";
import { artifactInspectionResultSchema } from "../../src/domain/artifactInspection.js";
import {
  artifactInventoryResultSchema,
  artifactExtractionResultSchema,
} from "../../src/domain/artifactGraph.js";
import { parseEvidence } from "../../src/domain/evidence.js";
import { cliTest } from "../support/cli/cliFixture.js";
import { createTestTempDirectory } from "../fixtures/temporaryDirectory.js";
import { connectLocalToolsMcp } from "../fixtures/localToolsMcp.js";
import { parseMcpToolError } from "../fixtures/mcpToolError.js";
import { inesFixture } from "../fixtures/ines.js";

const inventoryFrom = (input: unknown) => {
  const evidence = parseEvidence(input);
  expect(evidence.subject).toMatchObject({
    format: "ines",
    architecture: null,
  });
  const inspection = artifactInspectionResultSchema.parse(
    evidence.normalized_result,
  );
  expect(inspection.coverage.status).toBe("complete-within-substeps");
  expect(inspection.observations.map(({ kind }) => kind)).toEqual([
    "root-manifest",
    "container-header",
    "reconstruction",
  ]);
  const substep = inspection.substeps[0];
  if (substep === undefined) throw new Error("Missing inventory substep");
  parseEvidence(substep.evidence);
  return artifactInventoryResultSchema.parse(
    substep.evidence.normalized_result,
  );
};

cliTest(
  "classic iNES has the same complete byte inventory through compiled CLI and stdio MCP",
  async ({ cli }) => {
    const root = await createTestTempDirectory("rea-ines-public-");
    const path = join(root, "卡带.data");
    const bytes = inesFixture({
      trainer: true,
      trailing: Buffer.from([0, 255, 3, 0]),
    });
    await writeFile(path, bytes);
    const cliResult = await cli.run({
      arguments: ["inspect-artifact", path, "--json"],
    });
    expect(cliResult.exitCode, cliResult.stderr).toBe(0);
    const inventory = inventoryFrom(cliResult.json);
    const digest = createHash("sha256").update(bytes).digest("hex");
    expect(inventory.ines).toMatchObject({
      header: {
        mapper: 19,
        trainer_present: true,
        prg_rom_units_16k: 2,
        chr_rom_units_8k: 1,
      },
      reconstruction: { bytes: bytes.length, sha256: digest, verified: true },
    });
    const expected = [
      ["header.bin", 0, 16],
      ["trainer.bin", 16, 512],
      ["prg/000.bin", 528, 16_384],
      ["prg/001.bin", 16_912, 16_384],
      ["chr/000.bin", 33_296, 8_192],
      ["trailing.bin", 41_488, 4],
    ] as const;
    const nodes = new Map(
      inventory.nodes.map((node) => [node.artifact_id, node]),
    );
    for (const [logical_path, offset, length] of expected) {
      const occurrence = inventory.occurrences.find(
        (item) => item.logical_path === logical_path,
      );
      if (
        occurrence?.artifact_id === undefined ||
        occurrence.artifact_id === null
      )
        throw new Error(`Missing region ${logical_path}`);
      expect(occurrence.source_location).toEqual({ offset, length });
      expect(nodes.get(occurrence.artifact_id)?.sha256).toBe(
        createHash("sha256")
          .update(bytes.subarray(offset, offset + length))
          .digest("hex"),
      );
    }

    const { call } = await connectLocalToolsMcp();
    const opened = await call("open_binary", { path });
    if (opened.isError)
      throw new Error(JSON.stringify(parseMcpToolError(opened)));
    const inspected = await call("inspect_artifact", {});
    expect(
      inspected.isError,
      JSON.stringify(inspected.structuredContent),
    ).not.toBe(true);
    expect(inventoryFrom(inspected.structuredContent)).toEqual(inventory);
    const extracted = await call("extract_artifact", {});
    expect(
      extracted.isError,
      JSON.stringify(extracted.structuredContent),
    ).not.toBe(true);
    const extraction = artifactExtractionResultSchema.parse(
      parseEvidence(extracted.structuredContent).normalized_result,
    );
    try {
      expect(extraction.artifacts).toHaveLength(expected.length);
      expect(
        Buffer.concat(
          await Promise.all(
            expected.map(([region]) =>
              readFile(join(extraction.output_root, region)),
            ),
          ),
        ),
      ).toEqual(bytes);
    } finally {
      // The successful extraction transfers this exact output directory to the caller.
      await rm(extraction.output_root, { recursive: true, force: true });
    }
    await call("close_binary", {});
    expect(await readFile(path)).toEqual(bytes);
  },
);

cliTest(
  "unsupported NES containers fail explicitly and leave a valid MCP session usable",
  async ({ cli }) => {
    const root = await createTestTempDirectory("rea-ines-public-refusal-");
    const validPath = join(root, "valid.nes");
    await writeFile(validPath, inesFixture({ chrUnits: 0 }));
    const { call } = await connectLocalToolsMcp();
    const opened = await call("open_binary", { path: validPath });
    if (opened.isError)
      throw new Error(JSON.stringify(parseMcpToolError(opened)));
    for (const [name, bytes, reason] of [
      ["truncated", inesFixture().subarray(0, 20), "truncated iNES payload"],
      [
        "nes2",
        (() => {
          const bytes = inesFixture();
          bytes[7] = 8;
          return bytes;
        })(),
        "nes-2.0",
      ],
      ["unif", Buffer.from("UNIF"), "unif"],
    ] as const) {
      const path = join(root, `${name}.nes`);
      await writeFile(path, bytes);
      const refused = await cli.run({
        arguments: ["inspect-artifact", path, "--json"],
      });
      expect(refused.exitCode).not.toBe(0);
      expect(JSON.stringify(refused.json)).toContain(reason);
      const switched = await call("open_binary", { path });
      expect(switched.isError).toBe(true);
      expect(JSON.stringify(parseMcpToolError(switched))).toContain(reason);
    }
    const retained = await call("inspect_artifact", {});
    expect(
      retained.isError,
      JSON.stringify(retained.structuredContent),
    ).not.toBe(true);
    const inventory = inventoryFrom(retained.structuredContent);
    expect(inventory.ines?.header.chr_rom_units_8k).toBe(0);
    expect(
      inventory.occurrences.some(({ logical_path }) =>
        logical_path.startsWith("chr/"),
      ),
    ).toBe(false);
    await call("close_binary", {});
  },
);