@pi-harness/pi-harness 0.1.14 → 0.1.16

package/packages/core/test/vision-toolkit.test.ts

@@ -1,511 +0,0 @@
-import { mkdir, mkdtemp, rm, symlink, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { Context } from "@deepseek-ai/cordis";
-import { afterEach, describe, expect, test } from "vitest";
-import visionToolkitPlugin, { catalogImages, imageInfo } from "../src/plugins/vision-toolkit.js";
-import { PiPluginUiRegistry, PiToolRegistry, provideLaunchContext } from "../src/services.js";
-
-const temporaryDirectories: string[] = [];
-const contexts: Context[] = [];
-
-function asRecord(value: unknown): Record<string, unknown> {
-  if (value === null || typeof value !== "object") throw new Error("Expected an object in the Vision Toolkit test fixture");
-  return value as Record<string, unknown>;
-}
-
-function png(width: number, height: number): Buffer {
-  const data = Buffer.alloc(24);
-  Buffer.from("89504e470d0a1a0a", "hex").copy(data);
-  data.writeUInt32BE(13, 8);
-  data.write("IHDR", 12, "ascii");
-  data.writeUInt32BE(width, 16);
-  data.writeUInt32BE(height, 20);
-  return data;
-}
-
-function jpegWithLateDimensions(width: number, height: number): Buffer {
-  const segments = Array.from({ length: 5 }, () => {
-    const segment = Buffer.alloc(65_537);
-    segment[0] = 0xff;
-    segment[1] = 0xe1;
-    segment.writeUInt16BE(65_535, 2);
-    return segment;
-  });
-  const sof = Buffer.from([
-    0xff,
-    0xc0,
-    0x00,
-    0x11,
-    0x08,
-    height >> 8,
-    height & 0xff,
-    width >> 8,
-    width & 0xff,
-    0x03,
-    0x01,
-    0x11,
-    0x00,
-    0x02,
-    0x11,
-    0x00,
-    0x03,
-    0x11,
-    0x00,
-  ]);
-  return Buffer.concat([Buffer.from([0xff, 0xd8]), ...segments, sof]);
-}
-
-afterEach(async () => {
-  await Promise.all(contexts.splice(0).map(async (context) => context.fiber.dispose()));
-  await Promise.all(temporaryDirectories.splice(0).map((directory) => rm(directory, { recursive: true, force: true })));
-});
-
-async function fixture() {
-  const cwd = await mkdtemp(join(tmpdir(), "pi-vision-toolkit-"));
-  const agentDir = await mkdtemp(join(tmpdir(), "pi-vision-toolkit-agent-"));
-  temporaryDirectories.push(cwd, agentDir);
-  const context = new Context();
-  contexts.push(context);
-  provideLaunchContext(context, { cwd, agentDir, args: [], requestExit() {} });
-  const tools = new PiToolRegistry();
-  const panels = new PiPluginUiRegistry();
-  context.provide("piTools", tools);
-  context.provide("piPluginUi", panels);
-  return { context, cwd, tools, panels };
-}
-
-describe("vision toolkit", () => {
-  test("catalogs supported workspace images with dimensions", async () => {
-    const root = await mkdtemp(join(tmpdir(), "pi-vision-toolkit-"));
-    temporaryDirectories.push(root);
-    await mkdir(join(root, "designs"));
-    await writeFile(join(root, "designs", "hero.png"), png(320, 180));
-    await writeFile(join(root, "notes.txt"), "not an image");
-
-    await expect(catalogImages(root)).resolves.toEqual([
-      { path: "designs/hero.png", mimeType: "image/png", bytes: 24, width: 320, height: 180, headerTruncated: false },
-    ]);
-  });
-
-  test("rejects image paths outside the workspace", async () => {
-    const root = await mkdtemp(join(tmpdir(), "pi-vision-toolkit-"));
-    const outside = await mkdtemp(join(tmpdir(), "pi-vision-toolkit-outside-"));
-    temporaryDirectories.push(root);
-    temporaryDirectories.push(outside);
-    await expect(imageInfo(root, "../outside.png")).rejects.toThrow(/inside the workspace/);
-    await writeFile(join(outside, "outside.png"), Buffer.alloc(24));
-    await symlink(outside, join(root, "linked"));
-    await expect(imageInfo(root, "linked/outside.png")).rejects.toThrow(/inside the workspace/);
-  });
-
-  test("rejects image extensions whose bytes are not the claimed format", async () => {
-    const root = await mkdtemp(join(tmpdir(), "pi-vision-toolkit-"));
-    temporaryDirectories.push(root);
-    await writeFile(join(root, "fake.png"), "not a PNG", "utf8");
-
-    await expect(imageInfo(root, "fake.png")).rejects.toThrow(/bytes do not match.*png/iu);
-  });
-
-  test("reads dimensions from PNG, GIF, JPEG, and every WebP bitstream form", async () => {
-    const root = await mkdtemp(join(tmpdir(), "pi-vision-toolkit-"));
-    temporaryDirectories.push(root);
-    const gif = Buffer.alloc(10);
-    gif.write("GIF89a", 0, "ascii");
-    gif.writeUInt16LE(321, 6);
-    gif.writeUInt16LE(181, 8);
-    const jpeg = Buffer.from([0xff, 0xd8, 0xff, 0xc0, 0x00, 0x11, 0x08, 0x00, 0xb6, 0x01, 0x42, 0x03, 0x01, 0x11, 0x00, 0x02, 0x11, 0x00, 0x03, 0x11, 0x00]);
-    const vp8x = Buffer.alloc(30);
-    vp8x.write("RIFF", 0, "ascii");
-    vp8x.writeUInt32LE(22, 4);
-    vp8x.write("WEBPVP8X", 8, "ascii");
-    vp8x.writeUInt32LE(10, 16);
-    vp8x.writeUIntLE(322 - 1, 24, 3);
-    vp8x.writeUIntLE(182 - 1, 27, 3);
-    const vp8l = Buffer.alloc(25);
-    vp8l.write("RIFF", 0, "ascii");
-    vp8l.writeUInt32LE(17, 4);
-    vp8l.write("WEBPVP8L", 8, "ascii");
-    vp8l.writeUInt32LE(5, 16);
-    vp8l[20] = 0x2f;
-    const losslessWidth = 323 - 1;
-    const losslessHeight = 183 - 1;
-    vp8l[21] = losslessWidth & 0xff;
-    vp8l[22] = ((losslessWidth >> 8) & 0x3f) | ((losslessHeight & 0x03) << 6);
-    vp8l[23] = (losslessHeight >> 2) & 0xff;
-    vp8l[24] = (losslessHeight >> 10) & 0x0f;
-    const vp8 = Buffer.alloc(30);
-    vp8.write("RIFF", 0, "ascii");
-    vp8.writeUInt32LE(22, 4);
-    vp8.write("WEBPVP8 ", 8, "ascii");
-    vp8.writeUInt32LE(10, 16);
-    Buffer.from([0x00, 0x00, 0x00, 0x9d, 0x01, 0x2a]).copy(vp8, 20);
-    vp8.writeUInt16LE(324, 26);
-    vp8.writeUInt16LE(184, 28);
-    const fixtures = [
-      ["image.png", png(320, 180), 320, 180],
-      ["image.gif", gif, 321, 181],
-      ["image.jpg", jpeg, 322, 182],
-      ["extended.webp", vp8x, 322, 182],
-      ["lossless.webp", vp8l, 323, 183],
-      ["lossy.webp", vp8, 324, 184],
-    ] as const;
-    await Promise.all(fixtures.map(async ([name, data]) => writeFile(join(root, name), data)));
-
-    await expect(Promise.all(fixtures.map(async ([name]) => imageInfo(root, name)))).resolves.toMatchObject(
-      fixtures.map(([path, , width, height]) => ({ path, width, height })),
-    );
-  });
-
-  test("rejects a recognized image signature with a malformed or zero-sized header", async () => {
-    const root = await mkdtemp(join(tmpdir(), "pi-vision-toolkit-"));
-    temporaryDirectories.push(root);
-    await writeFile(join(root, "zero.png"), png(0, 180));
-    await writeFile(join(root, "truncated.jpg"), Buffer.from([0xff, 0xd8, 0xff]));
-
-    await expect(imageInfo(root, "zero.png")).rejects.toThrow(/malformed.*dimensions/iu);
-    await expect(imageInfo(root, "truncated.jpg")).rejects.toThrow(/malformed.*dimensions/iu);
-  });
-
-  test("bounds header reads and reports when late JPEG dimensions were not reached", async () => {
-    const root = await mkdtemp(join(tmpdir(), "pi-vision-toolkit-"));
-    temporaryDirectories.push(root);
-    const jpeg = jpegWithLateDimensions(640, 360);
-    await writeFile(join(root, "late.jpg"), jpeg);
-
-    await expect(imageInfo(root, "late.jpg")).resolves.toEqual({
-      path: "late.jpg",
-      mimeType: "image/jpeg",
-      bytes: jpeg.length,
-      width: null,
-      height: null,
-      headerTruncated: true,
-    });
-  });
-
-  test("accepts JPEG fill bytes and standalone markers before the dimensions segment", async () => {
-    const root = await mkdtemp(join(tmpdir(), "pi-vision-toolkit-"));
-    temporaryDirectories.push(root);
-    const sof = Buffer.from([0xff, 0xc0, 0x00, 0x11, 0x08, 0x00, 0xb4, 0x01, 0x40, 0x03, 0x01, 0x11, 0x00, 0x02, 0x11, 0x00, 0x03, 0x11, 0x00]);
-    const jpeg = Buffer.concat([Buffer.from([0xff, 0xd8, 0xff, 0xff, 0xe0, 0x00, 0x02, 0xff, 0x01]), sof]);
-    await writeFile(join(root, "markers.jpg"), jpeg);
-
-    await expect(imageInfo(root, "markers.jpg")).resolves.toMatchObject({ width: 320, height: 180, headerTruncated: false });
-  });
-
-  test("continues cataloging valid assets when another image is malformed", async () => {
-    const root = await mkdtemp(join(tmpdir(), "pi-vision-toolkit-"));
-    temporaryDirectories.push(root);
-    await writeFile(join(root, "bad.png"), "not a PNG", "utf8");
-    await writeFile(join(root, "good.png"), png(640, 360));
-
-    await expect(catalogImages(root)).resolves.toEqual([
-      { path: "good.png", mimeType: "image/png", bytes: 24, width: 640, height: 360, headerTruncated: false },
-    ]);
-  });
-
-  test("bounds catalog traversal and reports when directory discovery is truncated", async () => {
-    const { context, cwd, tools, panels } = await fixture();
-    for (let index = 0; index < 513; index += 1) await mkdir(join(cwd, `directory-${String(index).padStart(3, "0")}`));
-    await context.plugin(visionToolkitPlugin, {});
-    const tool = tools.snapshot().customTools.find((candidate) => candidate.name === "vision_catalog");
-    if (tool === undefined) throw new Error("vision_catalog was not registered");
-
-    const result = await tool.execute("catalog", {}, undefined, undefined, {} as never);
-
-    expect(result.details).toMatchObject({ assets: [], scannedDirectories: 512, truncated: true });
-    await expect(panels.snapshot()).resolves.toMatchObject([{ data: { report: { scannedDirectories: 512, truncated: true } } }]);
-  });
-
-  test("rejects hostile image-info parameters without invoking accessors", async () => {
-    const { context, cwd, tools } = await fixture();
-    await writeFile(join(cwd, "valid.png"), png(32, 18));
-    await context.plugin(visionToolkitPlugin, {});
-    const tool = tools.snapshot().customTools.find((candidate) => candidate.name === "vision_image_info");
-    if (tool === undefined) throw new Error("vision_image_info was not registered");
-    let getterCalls = 0;
-    const getter = Object.defineProperty({}, "path", {
-      enumerable: true,
-      get() {
-        getterCalls += 1;
-        return "valid.png";
-      },
-    });
-    const inherited = Object.create({ path: "valid.png" }) as Record<string, unknown>;
-    const cases: unknown[] = [
-      null,
-      [],
-      getter,
-      inherited,
-      { path: "valid.png", unknown: true },
-      { path: " " },
-      { path: "valid\0.png" },
-      { path: "x".repeat(4_097) },
-    ];
-
-    for (const [index, params] of cases.entries()) await expect(tool.execute(`invalid-${index}`, params, undefined, undefined, {} as never)).rejects.toThrow();
-
-    expect(getterCalls).toBe(0);
-    expect(tool.parameters).toMatchObject({ additionalProperties: false, properties: { path: { minLength: 1, maxLength: 4_096 } } });
-  });
-
-  test("rolls back both tools when panel registration fails", async () => {
-    const { context, tools, panels } = await fixture();
-    panels.register({ id: "vision-toolkit-panel", pluginId: "fixture", title: "Fixture", read: () => ({}) });
-
-    await expect(context.plugin(visionToolkitPlugin, {})).rejects.toThrow(/panel is already registered: vision-toolkit-panel/iu);
-
-    expect(tools.snapshot().customTools).toEqual([]);
-    await expect(panels.snapshot()).resolves.toMatchObject([{ id: "vision-toolkit-panel", pluginId: "fixture" }]);
-  });
-
-  test("rejects unknown configuration before registering surfaces", async () => {
-    const { context, tools, panels } = await fixture();
-    let failure: unknown;
-
-    try {
-      await context.plugin(visionToolkitPlugin, { unexpected: true });
-    } catch (error) {
-      failure = error;
-    }
-
-    expect(failure).toBeInstanceOf(Error);
-    expect((failure as Error).message).toMatch(/unknown.*unexpected/iu);
-    expect(tools.snapshot().customTools).toEqual([]);
-    await expect(panels.snapshot()).resolves.toEqual([]);
-  });
-
-  test("honors caller cancellation for both tools and exposes cancelled status", async () => {
-    const { context, cwd, tools, panels } = await fixture();
-    await writeFile(join(cwd, "valid.png"), png(32, 18));
-    await context.plugin(visionToolkitPlugin, {});
-    const catalog = tools.snapshot().customTools.find((candidate) => candidate.name === "vision_catalog");
-    const info = tools.snapshot().customTools.find((candidate) => candidate.name === "vision_image_info");
-    if (catalog === undefined || info === undefined) throw new Error("vision toolkit tools were not registered");
-    const abort = new AbortController();
-    abort.abort(new Error("caller stopped vision inspection"));
-
-    await expect(catalog.execute("catalog", {}, abort.signal, undefined, {} as never)).rejects.toThrow(/cancelled/iu);
-    await expect(info.execute("info", { path: "valid.png" }, abort.signal, undefined, {} as never)).rejects.toThrow(/cancelled/iu);
-
-    const status = asRecord(asRecord((await panels.snapshot())[0]?.data).status);
-    expect(status).toMatchObject({ state: "cancelled", operation: "info", path: "valid.png" });
-    expect(typeof status.error).toBe("string");
-    if (typeof status.error !== "string") throw new Error("Expected a cancellation error in the panel status");
-    expect(status.error).toMatch(/cancelled/iu);
-  });
-
-  test("rejects hostile catalog parameters without invoking accessors", async () => {
-    const { context, tools } = await fixture();
-    await context.plugin(visionToolkitPlugin, {});
-    const catalog = tools.snapshot().customTools.find((candidate) => candidate.name === "vision_catalog");
-    if (catalog === undefined) throw new Error("vision_catalog was not registered");
-    let getterCalls = 0;
-    const getter = Object.defineProperty({}, "unknown", {
-      enumerable: true,
-      get() {
-        getterCalls += 1;
-        return true;
-      },
-    });
-
-    for (const [index, params] of [null, [], getter, { unknown: true }].entries())
-      await expect(catalog.execute(`invalid-${index}`, params, undefined, undefined, {} as never)).rejects.toThrow(/parameters/iu);
-
-    expect(getterCalls).toBe(0);
-    expect(catalog.parameters).toMatchObject({ additionalProperties: false, properties: {} });
-  });
-
-  test("reports malformed catalog entries without hiding valid assets or absolute workspace paths", async () => {
-    const { context, cwd, tools, panels } = await fixture();
-    await writeFile(join(cwd, "bad.png"), "not a PNG", "utf8");
-    await writeFile(join(cwd, "good.png"), png(80, 45));
-    await context.plugin(visionToolkitPlugin, {});
-    const catalog = tools.snapshot().customTools.find((candidate) => candidate.name === "vision_catalog");
-    if (catalog === undefined) throw new Error("vision_catalog was not registered");
-
-    const result = await catalog.execute("catalog", {}, undefined, undefined, {} as never);
-
-    const details = asRecord(result.details);
-    expect(details.assets).toMatchObject([{ path: "good.png", width: 80, height: 45 }]);
-    expect(Array.isArray(details.issues)).toBe(true);
-    if (!Array.isArray(details.issues)) throw new Error("Expected catalog issues to be an array");
-    const issue = asRecord(details.issues[0]);
-    expect(issue.path).toBe("bad.png");
-    expect(typeof issue.reason).toBe("string");
-    if (typeof issue.reason !== "string") throw new Error("Expected a catalog issue reason");
-    expect(issue.reason).toMatch(/bytes do not match/iu);
-    expect(details.truncated).toBe(false);
-    const content = result.content[0];
-    expect(content?.type).toBe("text");
-    if (content?.type !== "text") throw new Error("Expected Vision Toolkit Agent content to be text");
-    expect(content.text).toMatch(/1 image issue/iu);
-    expect(JSON.stringify(result)).not.toContain(cwd);
-    await expect(panels.snapshot()).resolves.toMatchObject([{ data: { report: { issues: [{ path: "bad.png" }] } } }]);
-  });
-
-  test("bounds catalog text sent to the Agent on a valid UTF-8 boundary", async () => {
-    const { context, cwd, tools } = await fixture();
-    await Promise.all(
-      Array.from({ length: 100 }, async (_, index) => writeFile(join(cwd, `${String(index).padStart(3, "0")}-${"界".repeat(70)}.png`), png(16, 9))),
-    );
-    await context.plugin(visionToolkitPlugin, {});
-    const catalog = tools.snapshot().customTools.find((candidate) => candidate.name === "vision_catalog");
-    if (catalog === undefined) throw new Error("vision_catalog was not registered");
-
-    const result = await catalog.execute("catalog", {}, undefined, undefined, {} as never);
-    const content = result.content[0];
-    if (content?.type !== "text") throw new Error("expected catalog text");
-
-    expect(Buffer.byteLength(content.text, "utf8")).toBeLessThanOrEqual(16 * 1_024);
-    expect(content.text).toContain("metadata truncated");
-    expect(content.text).not.toContain("�");
-  });
-
-  test("bounds malformed image candidates and issue details", async () => {
-    const { context, cwd, tools } = await fixture();
-    await Promise.all(Array.from({ length: 257 }, async (_, index) => writeFile(join(cwd, `${String(index).padStart(3, "0")}.png`), "not a PNG", "utf8")));
-    await context.plugin(visionToolkitPlugin, {});
-    const catalog = tools.snapshot().customTools.find((candidate) => candidate.name === "vision_catalog");
-    if (catalog === undefined) throw new Error("vision_catalog was not registered");
-
-    const result = await catalog.execute("catalog", {}, undefined, undefined, {} as never);
-
-    expect(result.details).toMatchObject({
-      assets: [],
-      inspectedCandidates: 256,
-      issuesTruncated: true,
-      truncated: true,
-    });
-    expect((result.details as { issues: unknown[] }).issues).toHaveLength(20);
-  });
-
-  test("bounds non-image directory entries before catalog discovery can grow without limit", async () => {
-    const { context, cwd, tools } = await fixture();
-    for (let offset = 0; offset < 4_097; offset += 256) {
-      await Promise.all(
-        Array.from({ length: Math.min(256, 4_097 - offset) }, async (_, index) =>
-          writeFile(join(cwd, `${String(offset + index).padStart(4, "0")}.txt`), "", "utf8"),
-        ),
-      );
-    }
-    await context.plugin(visionToolkitPlugin, {});
-    const catalog = tools.snapshot().customTools.find((candidate) => candidate.name === "vision_catalog");
-    if (catalog === undefined) throw new Error("vision_catalog was not registered");
-
-    await expect(catalog.execute("catalog", {}, undefined, undefined, {} as never)).resolves.toMatchObject({
-      details: { assets: [], scannedEntries: 4_096, scannedDirectories: 1, truncated: true },
-    });
-  });
-
-  test("bounds the number of valid assets returned by a catalog", async () => {
-    const { context, cwd, tools } = await fixture();
-    await Promise.all(Array.from({ length: 101 }, async (_, index) => writeFile(join(cwd, `${String(index).padStart(3, "0")}.png`), png(16, 9))));
-    await context.plugin(visionToolkitPlugin, {});
-    const catalog = tools.snapshot().customTools.find((candidate) => candidate.name === "vision_catalog");
-    if (catalog === undefined) throw new Error("vision_catalog was not registered");
-
-    const result = await catalog.execute("catalog", {}, undefined, undefined, {} as never);
-
-    expect((result.details as { assets: unknown[] }).assets).toHaveLength(100);
-    expect(result.details).toMatchObject({ inspectedCandidates: 100, truncated: true });
-  });
-
-  test("escapes control and bidi characters in Agent-facing image paths", async () => {
-    const { context, cwd, tools } = await fixture();
-    const path = "diagram\u202e.png";
-    await writeFile(join(cwd, path), png(16, 9));
-    await context.plugin(visionToolkitPlugin, {});
-    const catalog = tools.snapshot().customTools.find((candidate) => candidate.name === "vision_catalog");
-    const info = tools.snapshot().customTools.find((candidate) => candidate.name === "vision_image_info");
-    if (catalog === undefined || info === undefined) throw new Error("vision toolkit tools were not registered");
-
-    const catalogResult = await catalog.execute("catalog", {}, undefined, undefined, {} as never);
-    const infoResult = await info.execute("info", { path }, undefined, undefined, {} as never);
-    const texts = [catalogResult.content[0], infoResult.content[0]].map((content) => (content?.type === "text" ? content.text : ""));
-
-    for (const text of texts) {
-      expect(text).toContain("Untrusted workspace image metadata");
-      expect(text).toContain("\\u202e");
-      expect(text).not.toMatch(/\p{Cf}/u);
-      expect(
-        [...text].some((character) => {
-          const codePoint = character.codePointAt(0);
-          return codePoint !== undefined && (codePoint <= 0x09 || (codePoint >= 0x0b && codePoint <= 0x1f) || (codePoint >= 0x7f && codePoint <= 0x9f));
-        }),
-      ).toBe(false);
-    }
-  });
-
-  test("publishes an explicit bounded panel contract and unregisters every surface on dispose", async () => {
-    const { context, tools, panels } = await fixture();
-    await context.plugin(visionToolkitPlugin, {});
-
-    await expect(panels.snapshot()).resolves.toMatchObject([
-      {
-        id: "vision-toolkit-panel",
-        data: {
-          status: { state: "idle" },
-          report: null,
-          supportedTypes: ["gif", "jpeg", "jpg", "png", "webp"],
-          limits: {
-            imageBytes: 20_971_520,
-            pathCharacters: 4_096,
-            assets: 100,
-            scannedEntries: 4_096,
-            scannedDirectories: 512,
-            depth: 16,
-            issues: 20,
-            issueCharacters: 500,
-            agentTextBytes: 16_384,
-          },
-        },
-      },
-    ]);
-
-    await context.fiber.dispose();
-    expect(tools.snapshot().customTools).toEqual([]);
-    await expect(panels.snapshot()).resolves.toEqual([]);
-  });
-
-  test("cancels an in-flight catalog when the plugin is disposed", async () => {
-    const { context, cwd, tools, panels } = await fixture();
-    for (let index = 0; index < 513; index += 1) await mkdir(join(cwd, `scan-${String(index).padStart(3, "0")}`));
-    await context.plugin(visionToolkitPlugin, {});
-    const catalog = tools.snapshot().customTools.find((candidate) => candidate.name === "vision_catalog");
-    if (catalog === undefined) throw new Error("vision_catalog was not registered");
-
-    const execution = catalog.execute("catalog", {}, undefined, undefined, {} as never);
-    await expect(panels.snapshot()).resolves.toMatchObject([{ data: { status: { state: "running", operation: "catalog" } } }]);
-    await context.fiber.dispose();
-
-    await expect(execution).rejects.toThrow(/cancelled/iu);
-    expect(tools.snapshot().customTools).toEqual([]);
-    await expect(panels.snapshot()).resolves.toEqual([]);
-  });
-
-  test("bounds and sanitizes image-info failures without leaking the absolute workspace path", async () => {
-    const { context, cwd, tools, panels } = await fixture();
-    await context.plugin(visionToolkitPlugin, {});
-    const info = tools.snapshot().customTools.find((candidate) => candidate.name === "vision_image_info");
-    if (info === undefined) throw new Error("vision_image_info was not registered");
-    let failure: unknown;
-
-    try {
-      await info.execute("missing", { path: "missing\u202e.png" }, undefined, undefined, {} as never);
-    } catch (error) {
-      failure = error;
-    }
-
-    expect(failure).toBeInstanceOf(Error);
-    expect((failure as Error).message.length).toBeLessThanOrEqual(500);
-    expect((failure as Error).message).not.toMatch(/[\p{Cc}\p{Cf}]/u);
-    expect((failure as Error).message).not.toContain(cwd);
-    expect((failure as Error).cause).toBeInstanceOf(Error);
-    const status = asRecord(asRecord((await panels.snapshot())[0]?.data).status);
-    expect(status).toMatchObject({ state: "failed", operation: "info" });
-    expect(typeof status.error).toBe("string");
-    if (typeof status.error !== "string") throw new Error("Expected a failure error in the panel status");
-    expect(status.error).not.toContain(cwd);
-  });
-});

package/packages/core/test/web-research.test.ts

@@ -1,63 +0,0 @@
-import { Context } from "@deepseek-ai/cordis";
-import { afterEach, describe, expect, test, vi } from "vitest";
-import webResearchPlugin from "../src/plugins/web-research.js";
-import { PiPluginUiRegistry, PiToolRegistry } from "../src/services.js";
-
-const contexts: Context[] = [];
-
-async function fixture() {
-  const context = new Context();
-  const tools = new PiToolRegistry();
-  const panels = new PiPluginUiRegistry();
-  context.provide("piTools", tools);
-  context.provide("piPluginUi", panels);
-  await context.plugin(webResearchPlugin, { baseUrl: "https://api.firecrawl.dev", apiKey: "", maxResults: 5, timeoutMs: 2_000 });
-  contexts.push(context);
-  const find = (name: string) => {
-    const tool = tools.snapshot().customTools.find((item) => item.name === name);
-    if (tool === undefined) throw new Error(`${name} was not registered`);
-    return tool;
-  };
-  return { context, tools, panels, search: find("web_search"), read: find("read_page") };
-}
-
-afterEach(async () => {
-  vi.unstubAllGlobals();
-  await Promise.all(contexts.splice(0).map((context) => context.fiber.dispose()));
-});
-
-describe("web research", () => {
-  test("returns bounded structured web evidence and strict metadata", async () => {
-    vi.stubGlobal(
-      "fetch",
-      vi.fn().mockResolvedValue(
-        new Response(JSON.stringify({ success: true, data: { web: [{ title: "Docs", url: "https://docs.example.test/a", description: "Useful" }] } }), {
-          status: 200,
-        }),
-      ),
-    );
-    const { search, panels } = await fixture();
-    for (const tool of [search]) {
-      expect(tool.executionMode).toBe("sequential");
-      expect(tool.parameters).toMatchObject({ type: "object", additionalProperties: false });
-    }
-    await expect(search.execute("search", { query: "pi harness" }, undefined, undefined, {} as never)).resolves.toMatchObject({
-      details: { status: "ok", items: [{ title: "Docs", source: "docs.example.test" }] },
-    });
-    await expect(panels.snapshot()).resolves.toMatchObject([{ data: { latest: { status: "ok" }, readPageAvailable: false } }]);
-  });
-
-  test("fails clearly without Browser Fetch and cleans up", async () => {
-    const { context, tools, panels, read } = await fixture();
-    await expect(read.execute("read", { url: "https://docs.example.test" }, undefined, undefined, {} as never)).rejects.toThrow(/Browser Fetch/iu);
-    await context.fiber.dispose();
-    expect(tools.snapshot().customTools).toHaveLength(0);
-    await expect(panels.snapshot()).resolves.toHaveLength(0);
-  });
-
-  test("rejects invalid UTF-8 provider responses", async () => {
-    vi.stubGlobal("fetch", vi.fn().mockResolvedValue(new Response(new Uint8Array([0xc3, 0x28]), { status: 200 })));
-    const { search } = await fixture();
-    await expect(search.execute("search", { query: "pi" }, undefined, undefined, {} as never)).rejects.toThrow(/valid UTF-8/iu);
-  });
-});

package/packages/core/test/workspace-git-status.test.ts

@@ -1,54 +0,0 @@
-import { chmod, mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { delimiter, join } from "node:path";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { afterEach, describe, expect, test } from "vitest";
-import { readWorkspaceGitStatus } from "../src/plugins/workspace-navigator.js";
-
-const execFileAsync = promisify(execFile);
-const temporaryDirectories: string[] = [];
-
-afterEach(async () => {
-  await Promise.all(temporaryDirectories.splice(0).map((directory) => rm(directory, { recursive: true, force: true })));
-});
-
-describe("workspace git status", () => {
-  test("reads branch and untracked files from a real git repository", async () => {
-    const directory = await mkdtemp(join(tmpdir(), "pi-harness-git-status-"));
-    temporaryDirectories.push(directory);
-    await execFileAsync("git", ["init", "-q", "-b", "main"], { cwd: directory });
-    await writeFile(join(directory, "notes.md"), "hello\n", "utf8");
-
-    await expect(readWorkspaceGitStatus(directory)).resolves.toEqual({
-      available: true,
-      branch: "main",
-      clean: false,
-      entries: [{ path: "notes.md", status: "??" }],
-    });
-  });
-
-  test("returns an unavailable report outside git", async () => {
-    const directory = await mkdtemp(join(tmpdir(), "pi-harness-not-git-"));
-    temporaryDirectories.push(directory);
-
-    await expect(readWorkspaceGitStatus(directory)).resolves.toMatchObject({ available: false, branch: null, clean: false, entries: [] });
-  });
-
-  test("returns unavailable after the configured timeout when Git hangs", async () => {
-    if (process.platform === "win32") return;
-    const directory = await mkdtemp(join(tmpdir(), "pi-harness-git-timeout-"));
-    temporaryDirectories.push(directory);
-    const bin = join(directory, "bin");
-    await mkdir(bin);
-    await writeFile(join(bin, "git"), "#!/bin/sh\nexec sleep 1\n", "utf8");
-    await chmod(join(bin, "git"), 0o700);
-    const originalPath = process.env.PATH;
-    process.env.PATH = `${bin}${delimiter}${originalPath ?? ""}`;
-    try {
-      await expect(readWorkspaceGitStatus(directory, 500)).resolves.toMatchObject({ available: false, branch: null, clean: false, entries: [] });
-    } finally {
-      process.env.PATH = originalPath;
-    }
-  });
-});

package/packages/core/test/workspace-navigator.test.ts

@@ -1,43 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { describe, expect, test } from "vitest";
-import { listWorkspaceNodes } from "../src/plugins/workspace-navigator.js";
-
-describe("workspace navigator", () => {
-  test("lists a bounded tree while skipping dependency and build directories", async () => {
-    const root = await mkdtemp(join(tmpdir(), "pi-harness-navigator-"));
-    await mkdir(join(root, "src", "nested"), { recursive: true });
-    await mkdir(join(root, "node_modules", "dep"), { recursive: true });
-    await mkdir(join(root, "dist"), { recursive: true });
-    await writeFile(join(root, "README.md"), "# app\n", "utf8");
-    await writeFile(join(root, "src", "index.ts"), "export const value = 1;\n", "utf8");
-    await writeFile(join(root, "src", "nested", "deep.ts"), "export const deep = true;\n", "utf8");
-    await writeFile(join(root, "node_modules", "dep", "index.js"), "export const hidden = true;\n", "utf8");
-    try {
-      await expect(listWorkspaceNodes(root, { maxDepth: 2, maxNodes: 10 })).resolves.toMatchObject({
-        nodes: [
-          { kind: "file", path: "README.md", depth: 1 },
-          { kind: "directory", path: "src", depth: 1 },
-          { kind: "file", path: "src/index.ts", depth: 2 },
-          { kind: "directory", path: "src/nested", depth: 2 },
-        ],
-        directoryCount: 2,
-        fileCount: 2,
-        truncated: true,
-      });
-    } finally {
-      await rm(root, { recursive: true, force: true });
-    }
-  });
-
-  test("does not mark an empty directory beyond the depth limit as truncated", async () => {
-    const root = await mkdtemp(join(tmpdir(), "pi-harness-navigator-"));
-    await mkdir(join(root, "one"));
-    try {
-      await expect(listWorkspaceNodes(root, { maxDepth: 1 })).resolves.toMatchObject({ truncated: false });
-    } finally {
-      await rm(root, { recursive: true, force: true });
-    }
-  });
-});