@pi-harness/pi-harness 0.1.13 → 0.1.14

package/packages/core/test/better-sidebar.test.ts

@@ -1,6 +1,11 @@
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Context } from "@deepseek-ai/cordis";
 import { describe, expect, test } from "vitest";
-import { createSidebarInspector, summarizeSidebar } from "../src/plugins/better-sidebar.js";
+import betterSidebarPlugin, { createSidebarInspector, summarizeSidebar } from "../src/plugins/better-sidebar.js";
 import type { WorkspaceGitStatus } from "../src/plugins/workspace-navigator.js";
+import { PiPluginUiRegistry, PiToolRegistry, provideLaunchContext } from "../src/services.js";
 
 describe("better sidebar", () => {
   test("summarizes workspace, Git, and session context without exposing full paths", () => {
@@ -70,6 +75,7 @@ describe("better sidebar", () => {
     expect(report.summary).toBe("detached HEAD · 20 个变更");
     expect(report.changedCount).toBe(20);
     expect(report.changedFiles).toHaveLength(12);
+    expect(report.truncated).toBe(true);
   });
 
   test("refreshes live Git state while reusing the bounded workspace tree", async () => {
@@ -122,4 +128,105 @@ describe("better sidebar", () => {
     await expect(first).resolves.toMatchObject({ branch: "main" });
     expect(gitReads).toBe(1);
   });
+
+  test("retries a failed workspace scan on the next refresh", async () => {
+    let treeReads = 0;
+    const inspect = createSidebarInspector({
+      cwd: "/workspace/project",
+      getSessionId: () => "session",
+      listNodes() {
+        treeReads += 1;
+        return treeReads === 1
+          ? Promise.reject(new Error("temporary scan failure"))
+          : Promise.resolve({ nodes: [], directoryCount: 1, fileCount: 2, truncated: false });
+      },
+      readGitStatus: () => Promise.resolve({ available: false, branch: null, clean: false, entries: [] }),
+    });
+
+    await expect(inspect()).rejects.toThrow(/temporary scan failure/iu);
+    await expect(inspect()).resolves.toMatchObject({ directoryCount: 1, fileCount: 2 });
+    expect(treeReads).toBe(2);
+  });
+
+  test("reuses a successful workspace scan when only Git refresh fails", async () => {
+    let treeReads = 0;
+    let gitReads = 0;
+    const inspect = createSidebarInspector({
+      cwd: "/workspace/project",
+      getSessionId: () => "session",
+      listNodes() {
+        treeReads += 1;
+        return Promise.resolve({ nodes: [], directoryCount: 1, fileCount: 2, truncated: false });
+      },
+      readGitStatus() {
+        gitReads += 1;
+        return gitReads === 1
+          ? Promise.reject(new Error("temporary Git failure"))
+          : Promise.resolve({ available: true, branch: "main", clean: true, entries: [] });
+      },
+    });
+
+    await expect(inspect()).rejects.toThrow(/temporary Git failure/iu);
+    await expect(inspect()).resolves.toMatchObject({ branch: "main", directoryCount: 1, fileCount: 2 });
+    expect(treeReads).toBe(1);
+    expect(gitReads).toBe(2);
+  });
+
+  test("registers the overview tool and panel for the current session", async () => {
+    const root = await mkdtemp(join(tmpdir(), "pi-harness-better-sidebar-"));
+    const context = new Context();
+    const tools = new PiToolRegistry();
+    const panels = new PiPluginUiRegistry();
+    try {
+      await writeFile(join(root, "README.md"), "# workspace\n", "utf8");
+      provideLaunchContext(context, { cwd: root, agentDir: root, args: [], requestExit() {} });
+      context.provide("piSession", { manager: { getSessionId: () => "session-sidebar" } } as never);
+      context.provide("piTools", tools);
+      context.provide("piPluginUi", panels);
+      await context.plugin(betterSidebarPlugin);
+      const tool = tools.snapshot().customTools.find((candidate) => candidate.name === "sidebar_overview");
+      if (tool === undefined) throw new Error("sidebar_overview was not registered");
+      expect(tool.executionMode).toBe("sequential");
+      expect(tool.parameters).toMatchObject({ additionalProperties: false });
+
+      const result = await tool.execute("inspect", {}, undefined, undefined, {} as never);
+      expect(result.details).toMatchObject({ cwd: root, gitAvailable: false, fileCount: 1, sessionId: "session-sidebar" });
+      expect(result.content[0]?.type === "text" ? result.content[0].text : "").toContain("非 Git 工作区");
+      await expect(panels.snapshot()).resolves.toMatchObject([
+        { id: "better-sidebar-panel", data: { gitAvailable: false, fileCount: 1, sessionId: "session-sidebar" } },
+      ]);
+
+      await context.fiber.dispose();
+      expect(tools.snapshot().customTools).toEqual([]);
+      await expect(panels.snapshot()).resolves.toEqual([]);
+    } finally {
+      await context.fiber.dispose();
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  test("does not alias concurrent tool and panel results", async () => {
+    const root = await mkdtemp(join(tmpdir(), "pi-harness-better-sidebar-"));
+    const context = new Context();
+    const tools = new PiToolRegistry();
+    const panels = new PiPluginUiRegistry();
+    try {
+      await writeFile(join(root, "README.md"), "# workspace\n", "utf8");
+      provideLaunchContext(context, { cwd: root, agentDir: root, args: [], requestExit() {} });
+      context.provide("piSession", { manager: { getSessionId: () => "session-sidebar" } } as never);
+      context.provide("piTools", tools);
+      context.provide("piPluginUi", panels);
+      await context.plugin(betterSidebarPlugin);
+      const tool = tools.snapshot().customTools.find((candidate) => candidate.name === "sidebar_overview");
+      if (tool === undefined) throw new Error("sidebar_overview was not registered");
+
+      const [result, snapshot] = await Promise.all([tool.execute("inspect", {}, undefined, undefined, {} as never), panels.snapshot()]);
+      (result.details as { cwd: string }).cwd = "mutated";
+
+      expect((snapshot[0]?.data as { cwd: string }).cwd).toBe(root);
+    } finally {
+      await context.fiber.dispose();
+      await rm(root, { recursive: true, force: true });
+    }
+  });
 });

package/packages/core/test/boot.test.ts

@@ -2,13 +2,15 @@ import { mkdtemp, readFile, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";
-import { afterEach, describe, expect, test } from "vitest";
+import { afterEach, describe, expect, test, vi } from "vitest";
 import { bootHarness, type BootedHarness } from "../src/boot.js";
 
 const booted: BootedHarness[] = [];
+const consoleLoggerEntry = import.meta.resolve("@deepseek-ai/cordis-plugin-logger-console");
 
 afterEach(async () => {
   await Promise.all(booted.splice(0).map(async (harness) => harness.dispose()));
+  vi.restoreAllMocks();
 });
 
 async function createProfile(entries: unknown[]): Promise<{ directory: string; profilePath: string }> {
@@ -119,6 +121,132 @@ describe("bootHarness", () => {
     await expect(bootHarness({ configPath: profile.profilePath })).rejects.toThrow(/Duplicate loader entry id "shared"/);
   });
 
+  test("accepts exactly 512 disabled profile entries and rejects the next one", async () => {
+    const exact = await createProfile(Array.from({ length: 512 }, (_, index) => ({ id: `entry-${index}`, name: "./disabled-fixture.mjs", disabled: true })));
+    const harness = await bootHarness({ configPath: exact.profilePath });
+    booted.push(harness);
+
+    const oversized = await createProfile(
+      Array.from({ length: 513 }, (_, index) => ({ id: `entry-${index}`, name: "./disabled-fixture.mjs", disabled: true })),
+    );
+    await expect(bootHarness({ configPath: oversized.profilePath })).rejects.toThrow(/512-entry limit/iu);
+  });
+
+  test("accepts 16 nested groups and rejects a seventeenth level", async () => {
+    const nested = (depth: number): unknown[] => {
+      let entry: Record<string, unknown> = { id: "leaf", name: "./disabled-fixture.mjs", disabled: true };
+      for (let index = 0; index < depth; index += 1) {
+        entry = { id: `group-${index}`, name: "cordis:group", group: true, config: [entry] };
+      }
+      return [entry];
+    };
+    const exact = await createProfile(nested(16));
+    const harness = await bootHarness({ configPath: exact.profilePath });
+    booted.push(harness);
+
+    const tooDeep = await createProfile(nested(17));
+    await expect(bootHarness({ configPath: tooDeep.profilePath })).rejects.toThrow(/16-level nesting limit/iu);
+  });
+
+  test("rejects malformed group entries before the external plugin runs", async () => {
+    const malformedGroup = await createProfile([{ id: "group", name: "cordis:group", group: true, config: {} }]);
+    await expect(bootHarness({ configPath: malformedGroup.profilePath })).rejects.toThrow(/group config must be an array/iu);
+
+    const malformedName = await createProfile([{ id: "entry", name: 7, disabled: true }]);
+    await expect(bootHarness({ configPath: malformedName.profilePath })).rejects.toThrow(/plugin name must be a non-empty string/iu);
+
+    const oversizedId = await createProfile([{ id: "x".repeat(129), name: "./disabled-fixture.mjs", disabled: true }]);
+    await expect(bootHarness({ configPath: oversizedId.profilePath })).rejects.toThrow(/entry id.*128/iu);
+  });
+
+  test("makes the console logger emit warnings with its safe default profile", async () => {
+    const output = vi.spyOn(console, "log").mockImplementation(() => {});
+    const profile = await createProfile([{ id: "logger", name: consoleLoggerEntry, config: {} }]);
+    const harness = await bootHarness({ configPath: profile.profilePath });
+    booted.push(harness);
+    output.mockClear();
+
+    harness.context.logger("audit").warn("warning diagnostic");
+
+    expect(output).toHaveBeenCalledOnce();
+    expect(output.mock.calls[0]?.[0]).toContain("warning diagnostic");
+  });
+
+  test("retains warnings and debug diagnostics in the bounded logger buffer", async () => {
+    const profile = await createProfile([]);
+    const harness = await bootHarness({ configPath: profile.profilePath });
+    booted.push(harness);
+    harness.context.logger.buffer = [];
+
+    const logger = harness.context.logger("audit");
+    logger.warn("warning diagnostic");
+    logger.debug("debug diagnostic");
+
+    expect(harness.context.logger.buffer.map((message) => message.type)).toEqual(["warn", "debug"]);
+  });
+
+  test("disposes the console logger without removing a later exporter", async () => {
+    const output = vi.spyOn(console, "log").mockImplementation(() => {});
+    const profile = await createProfile([]);
+    const collector = await createPlugin(
+      profile.directory,
+      "collector",
+      `export default function collector(ctx) {
+        const messages = [];
+        ctx.provide("fixtureLoggerMessages", messages);
+        ctx.logger.exporter({ levels: { default: 3 }, export(message) { messages.push(message.args[0]); } });
+      }`,
+    );
+    await writeFile(
+      profile.profilePath,
+      JSON.stringify([
+        { id: "logger", name: consoleLoggerEntry, config: {} },
+        { id: "collector", name: collector },
+      ]),
+      "utf8",
+    );
+    const harness = await bootHarness({ configPath: profile.profilePath });
+    booted.push(harness);
+    const messages = harness.context.get("fixtureLoggerMessages") as string[];
+    messages.length = 0;
+    output.mockClear();
+
+    const entry = [...harness.context.loader.entries()].find((item) => item.options.id === "logger");
+    await entry?.update({ disabled: true });
+    harness.context.logger("audit").info("after logger disposal");
+
+    expect(messages).toEqual(["after logger disposal"]);
+    expect(output).not.toHaveBeenCalled();
+  });
+
+  test.each([
+    ["non-object config", []],
+    ["unknown option", { destination: "remote" }],
+    ["color level", { colors: 4 }],
+    ["line length", { maxLength: 0 }],
+    ["oversized line length", { maxLength: 65_537 }],
+    ["levels map", { levels: [] }],
+    ["levels count", { levels: Object.fromEntries(Array.from({ length: 65 }, (_, index) => [`logger-${index}`, 1])) }],
+    ["empty logger name", { levels: { "": 1 } }],
+    ["oversized logger name", { levels: { ["x".repeat(129)]: 1 } }],
+    ["logger level", { levels: { default: 4 } }],
+    ["diff flag", { showDiff: "yes" }],
+    ["timestamp template", { showTime: "x".repeat(65) }],
+    ["label object", { label: [] }],
+    ["unknown label option", { label: { color: "red" } }],
+    ["label width", { label: { width: 257 } }],
+    ["label margin", { label: { margin: -1 } }],
+    ["label alignment", { label: { align: "center" } }],
+  ])("rejects unsafe console logger %s before activation", async (_label, config) => {
+    const profile = await createProfile([{ id: "logger", name: consoleLoggerEntry, config }]);
+
+    await expect(
+      bootHarness({ configPath: profile.profilePath }).then((harness) => {
+        booted.push(harness);
+      }),
+    ).rejects.toThrow(/console logger config/iu);
+  });
+
   test("forwards Cordis full-reload requests to the host", async () => {
     const profile = await createProfile([]);
     let reloads = 0;

package/packages/core/test/bounded-file.test.ts

@@ -0,0 +1,55 @@
+import { mkdir, mkdtemp, rm, symlink, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, test } from "vitest";
+import { readBoundedFile, readBoundedTextFile } from "../src/bounded-file.js";
+
+const temporaryDirectories: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(temporaryDirectories.splice(0).map((directory) => rm(directory, { recursive: true, force: true })));
+});
+
+describe("bounded file reads", () => {
+  test("reads a regular file through one bounded file handle", async () => {
+    const root = await mkdtemp(join(tmpdir(), "pi-harness-bounded-file-"));
+    temporaryDirectories.push(root);
+    const path = join(root, "input.txt");
+    await writeFile(path, "hello", "utf8");
+
+    await expect(readBoundedTextFile(path, 5, "Input file")).resolves.toBe("hello");
+    await expect(readBoundedFile(path, 5, "Input file")).resolves.toEqual(Buffer.from("hello"));
+  });
+
+  test("rejects a file larger than its hard byte limit", async () => {
+    const root = await mkdtemp(join(tmpdir(), "pi-harness-bounded-file-"));
+    temporaryDirectories.push(root);
+    const path = join(root, "input.txt");
+    await writeFile(path, "123456", "utf8");
+
+    await expect(readBoundedTextFile(path, 5, "Input file")).rejects.toThrow(/Input file exceeds the 5-byte limit/iu);
+  });
+
+  test("rejects directories and symbolic links", async () => {
+    const root = await mkdtemp(join(tmpdir(), "pi-harness-bounded-file-"));
+    temporaryDirectories.push(root);
+    const directory = join(root, "directory");
+    const target = join(root, "target.txt");
+    const link = join(root, "link.txt");
+    await mkdir(directory);
+    await writeFile(target, "secret", "utf8");
+    await symlink(target, link);
+
+    await expect(readBoundedFile(directory, 100, "Input file")).rejects.toThrow(/regular file/iu);
+    await expect(readBoundedFile(link, 100, "Input file")).rejects.toThrow(/symbolic link/iu);
+  });
+
+  test("rejects invalid UTF-8 instead of returning replacement characters", async () => {
+    const root = await mkdtemp(join(tmpdir(), "pi-harness-bounded-file-"));
+    temporaryDirectories.push(root);
+    const path = join(root, "invalid.txt");
+    await writeFile(path, Buffer.from([0xc3, 0x28]));
+
+    await expect(readBoundedTextFile(path, 5, "Input file")).rejects.toThrow(/valid UTF-8/iu);
+  });
+});

package/packages/core/test/browser-fetch-rebinding.test.ts

@@ -0,0 +1,93 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { createServer } from "node:http";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Context } from "@deepseek-ai/cordis";
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import browserFetchPlugin from "../src/plugins/browser-fetch.js";
+import { PiPluginUiRegistry, PiToolRegistry, provideLaunchContext } from "../src/services.js";
+
+const lookup = vi.hoisted(() => vi.fn(() => Promise.resolve([{ address: "1.1.1.1", family: 4 as const }])));
+
+vi.mock("node:dns/promises", async (importOriginal) => ({ ...(await importOriginal()), lookup }));
+
+describe("browser-fetch DNS pinning", () => {
+  beforeEach(() => {
+    lookup.mockReset();
+    lookup.mockResolvedValue([{ address: "1.1.1.1", family: 4 }]);
+  });
+
+  test("does not reconnect to an address that was not validated", async () => {
+    const root = await mkdtemp(join(tmpdir(), "pi-harness-browser-fetch-rebinding-"));
+    const context = new Context();
+    const tools = new PiToolRegistry();
+    let requests = 0;
+    const server = createServer((_request, response) => {
+      requests += 1;
+      response.end("private data");
+    });
+    await new Promise<void>((resolve, reject) => {
+      server.once("error", reject);
+      server.listen(0, resolve);
+    });
+    try {
+      const address = server.address();
+      if (address === null || typeof address === "string") throw new Error("Browser fetch rebinding test server did not bind to a port");
+      provideLaunchContext(context, { cwd: root, agentDir: root, args: [], requestExit() {} });
+      context.provide("piTools", tools);
+      context.provide("piPluginUi", new PiPluginUiRegistry());
+      await context.plugin(browserFetchPlugin, { timeoutMs: 100 });
+      const tool = tools.snapshot().customTools.find((candidate) => candidate.name === "browser_fetch");
+      if (tool === undefined) throw new Error("browser_fetch was not registered");
+
+      await expect(tool.execute("fetch", { url: `http://localhost:${address.port}/secret` }, undefined, undefined, {} as never)).rejects.toThrow();
+      expect(lookup).toHaveBeenCalledWith("localhost", { all: true, verbatim: true });
+      expect(requests).toBe(0);
+    } finally {
+      await context.fiber.dispose();
+      await new Promise<void>((resolve, reject) => server.close((error) => (error === undefined ? resolve() : reject(error))));
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  test("applies the request timeout while DNS resolution is pending", async () => {
+    const root = await mkdtemp(join(tmpdir(), "pi-harness-browser-fetch-dns-timeout-"));
+    const context = new Context();
+    const tools = new PiToolRegistry();
+    let resolveLookup!: (addresses: Array<{ address: string; family: 4 }>) => void;
+    const pendingLookup = new Promise<Array<{ address: string; family: 4 }>>((resolve) => {
+      resolveLookup = resolve;
+    });
+    lookup.mockImplementationOnce(() => pendingLookup);
+    let fallback: ReturnType<typeof setTimeout> | undefined;
+    let execution: Promise<unknown> | undefined;
+    try {
+      provideLaunchContext(context, { cwd: root, agentDir: root, args: [], requestExit() {} });
+      context.provide("piTools", tools);
+      context.provide("piPluginUi", new PiPluginUiRegistry());
+      await context.plugin(browserFetchPlugin, { timeoutMs: 100 });
+      const tool = tools.snapshot().customTools.find((candidate) => candidate.name === "browser_fetch");
+      if (tool === undefined) throw new Error("browser_fetch was not registered");
+
+      execution = tool.execute("fetch", { url: "https://example.com/" }, undefined, undefined, {} as never);
+      const outcome = await Promise.race([
+        execution.then(
+          () => new Error("Browser fetch unexpectedly succeeded"),
+          (error: unknown) => error,
+        ),
+        new Promise<string>((resolve) => {
+          fallback = setTimeout(() => resolve("DNS lookup remained pending"), 500);
+        }),
+      ]);
+
+      expect(outcome).toBeInstanceOf(Error);
+      expect(String(outcome)).toMatch(/timed out after 100 ms/iu);
+    } finally {
+      if (fallback !== undefined) clearTimeout(fallback);
+      resolveLookup([{ address: "1.1.1.1", family: 4 }]);
+      await context.fiber.dispose();
+      await execution?.catch(() => undefined);
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+});