nEngine/packages/mcp/test/bughunt-regressions.test.ts

import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
import { existsSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { describe, expect, it } from "vitest";
import { createEngine } from "@nengine/core";
import { createEngineNamespaces, McpGateway } from "../src/index.js";

/**
 * Regression tests for the 2026-08-14 full-repo bug-fix round:
 * - content ids must never escape the content dir (path traversal)
 * - a failed update write rolls the registry entry back
 * - patch.id renames are rejected loudly, not silently ignored
 * - callTool with undefined args returns a clean error result
 */

const TIME_YAML = [
  "id: default",
  "dayLengthTicks: 480",
  "seasons:",
  "  - { name: spring, dayCount: 28 }",
  "start: { day: 1, season: spring }",
  "",
].join("\n");

const FARM_YAML = [
  "id: farm",
  "width: 2",
  "height: 2",
  'tilesetRef: "tiles"',
  "spawn: { x: 0, y: 0 }",
  "layers:",
  "  - name: ground",
  "    data:",
  "      - [a, b]",
  "      - [b, a]",
  "",
].join("\n");

interface Setup {
  engine: ReturnType<typeof createEngine>;
  gateway: McpGateway;
  tmp: string;
  close: () => Promise<void>;
}

async function setup(): Promise<Setup> {
  const tmp = await mkdtemp(join(tmpdir(), "farm-bughunt-"));
  await mkdir(join(tmp, "maps"), { recursive: true });
  await writeFile(join(tmp, "time.yaml"), TIME_YAML);
  await writeFile(join(tmp, "maps", "farm.yaml"), FARM_YAML);

  const engine = createEngine({ contentDir: tmp });
  const gateway = new McpGateway();
  for (const namespace of createEngineNamespaces(engine, { gateway })) {
    gateway.register(namespace);
  }
  await engine.start();
  return {
    engine,
    gateway,
    tmp,
    close: async () => {
      await engine.stop();
      await rm(tmp, { recursive: true, force: true });
    },
  };
}

async function callText(gateway: McpGateway, name: string, args: Record<string, unknown> = {}): Promise<{
  ok: boolean;
  text: string;
}> {
  const result = await gateway.callTool(name, args);
  return { ok: result.isError !== true, text: result.content[0]?.text ?? "" };
}

describe("authoring path traversal (bug-fix round)", () => {
  it("item.create rejects an id with path separators — nothing is written outside content/", async () => {
    const { gateway, tmp, close } = await setup();
    try {
      const result = await callText(gateway, "item.create", {
        def: { id: "../../escape", name: "Escape", kind: "tool", stackable: false },
      });
      expect(result.ok).toBe(false);
      expect(result.text).toMatch(/unsafe content id/);
      expect(existsSync(join(tmp, "..", "escape.yaml"))).toBe(false);
      expect(existsSync(join(tmp, "..", "escape"))).toBe(false);
    } finally {
      await close();
    }
  });

  it("item.update rejects an unsafe target id", async () => {
    const { gateway, close } = await setup();
    try {
      const result = await callText(gateway, "item.update", {
        id: "../../escape",
        patch: { name: "X" },
      });
      expect(result.ok).toBe(false);
      // The traversal id can never be registered (create is guarded), so the
      // update is rejected either as not-found or as unsafe — never written.
      expect(result.text).toMatch(/unsafe content id|not found/);
    } finally {
      await close();
    }
  });

  it("patch.id renames are rejected loudly, never silently ignored", async () => {
    const { gateway, engine, close } = await setup();
    try {
      await callText(gateway, "item.create", {
        def: { id: "hoe", name: "Hoe", kind: "tool", stackable: false },
      });
      const result = await callText(gateway, "item.update", {
        id: "hoe",
        patch: { id: "renamed-hoe", name: "Renamed" },
      });
      expect(result.ok).toBe(false);
      expect(result.text).toMatch(/renaming via patch.id is not supported/);
      // the original is untouched
      expect(engine.registry.get("item", "hoe")?.name).toBe("Hoe");
    } finally {
      await close();
    }
  });
});

describe("update write-failure rollback (bug-fix round)", () => {
  it("a failed write leaves the live registry entry intact (old file + old def)", async () => {
    const { gateway, engine, tmp, close } = await setup();
    try {
      await callText(gateway, "item.create", {
        def: { id: "hoe", name: "Hoe", kind: "tool", stackable: false },
      });
      // Replace the item file with a DIRECTORY so the rewrite fails (EISDIR).
      await rm(join(tmp, "items", "hoe.yaml"));
      await mkdir(join(tmp, "items", "hoe.yaml"));
      const result = await callText(gateway, "item.update", {
        id: "hoe",
        patch: { name: "Renamed" },
      });
      expect(result.ok).toBe(false);
      expect(result.text).toMatch(/EISDIR|illegal operation|directory/i);
      // The registry entry survived the failed write.
      expect(engine.registry.get("item", "hoe")?.name).toBe("Hoe");
    } finally {
      await close();
    }
  });
});

describe("gateway.callTool argument handling (bug-fix round)", () => {
  it("undefined args return a clean error result, not a raw TypeError", async () => {
    const { gateway, close } = await setup();
    try {
      const result = await gateway.callTool("item.get", undefined as never);
      expect(result.isError).toBe(true);
      expect(result.content[0]?.text).toMatch(/missing required arguments/);
    } finally {
      await close();
    }
  });
});