@pi-harness/pi-harness 0.1.14 → 0.1.15

package/packages/core/test/stdio.test.ts

@@ -1,246 +0,0 @@
-import type { Context } from "@deepseek-ai/cordis";
-import { fauxAssistantMessage } from "@earendil-works/pi-ai/providers/faux";
-import { afterEach, describe, expect, test } from "vitest";
-import { provideStdioContext, type PiHarnessStdio } from "../src/stdio.js";
-import stdioPlugin from "../src/plugins/stdio.js";
-import { createTestRuntimeContext } from "./runtime-fixture.js";
-
-const contexts: Context[] = [];
-
-afterEach(async () => {
-  await Promise.all(contexts.splice(0).map(async (context) => context.fiber.dispose()));
-});
-
-function captureStdio(input: string): PiHarnessStdio & { output: string[]; errors: string[] } {
-  const output: string[] = [];
-  const errors: string[] = [];
-  return {
-    output,
-    errors,
-    readPrompt() {
-      return Promise.resolve(input);
-    },
-    writeOutput(text) {
-      output.push(text);
-    },
-    writeError(text) {
-      errors.push(text);
-    },
-  };
-}
-
-describe("stdio application plugin", () => {
-  test("rejects a non-object configuration before providing the application", async () => {
-    const { context } = await createTestRuntimeContext([]);
-    contexts.push(context);
-    provideStdioContext(context, captureStdio(""));
-    let activationError: unknown;
-    try {
-      await context.plugin(stdioPlugin, 42 as never);
-    } catch (error) {
-      activationError = error;
-    }
-
-    expect(activationError).toBeInstanceOf(Error);
-    expect(context.get("piApplication")).toBeUndefined();
-  });
-
-  test("rejects unknown configuration before providing the application", async () => {
-    const { context } = await createTestRuntimeContext([]);
-    contexts.push(context);
-    provideStdioContext(context, captureStdio(""));
-
-    await expect(context.plugin(stdioPlugin, { unexpected: true })).rejects.toThrow(/Unknown pi-stdio config keys: unexpected/u);
-    expect(context.get("piApplication")).toBeUndefined();
-  });
-
-  test("reads one prompt and streams the assistant response", async () => {
-    const { context, faux } = await createTestRuntimeContext([fauxAssistantMessage("stdio response")]);
-    contexts.push(context);
-    const stdio = captureStdio("user prompt");
-    provideStdioContext(context, stdio);
-    await context.plugin(stdioPlugin);
-
-    const exitCode = await context.piApplication.run();
-
-    expect(exitCode).toBe(0);
-    expect(stdio.output.join("")).toBe("stdio response\n");
-    expect(stdio.errors).toEqual([]);
-    expect(faux.state.callCount).toBe(1);
-    expect(context.piRuntime.session.messages.some((message) => message.role === "user")).toBe(true);
-  });
-
-  test("returns a usage error without calling the model for an empty prompt", async () => {
-    const { context, faux } = await createTestRuntimeContext([fauxAssistantMessage("unused")]);
-    contexts.push(context);
-    const stdio = captureStdio("   ");
-    provideStdioContext(context, stdio);
-    await context.plugin(stdioPlugin);
-
-    const exitCode = await context.piApplication.run();
-
-    expect(exitCode).toBe(2);
-    expect(stdio.errors.join("")).toMatch(/prompt is empty/i);
-    expect(faux.state.callCount).toBe(0);
-  });
-
-  test("reports a settled provider error as a failed application run", async () => {
-    const { context } = await createTestRuntimeContext([fauxAssistantMessage("", { stopReason: "error", errorMessage: "provider failed" })]);
-    contexts.push(context);
-    const stdio = captureStdio("trigger error");
-    provideStdioContext(context, stdio);
-    await context.plugin(stdioPlugin);
-
-    const exitCode = await context.piApplication.run();
-
-    expect(exitCode).toBe(1);
-    expect(stdio.errors.join("")).toContain("provider failed");
-  });
-
-  test("reports non-error resource diagnostics instead of dropping them", async () => {
-    const { context } = await createTestRuntimeContext([]);
-    contexts.push(context);
-    (context.piResources.diagnostics as unknown as Array<{ type: "warning"; message: string }>).push({ type: "warning", message: "extension warning" });
-    const stdio = captureStdio("");
-    provideStdioContext(context, stdio);
-
-    await context.plugin(stdioPlugin);
-
-    expect(stdio.errors).toEqual(["Resource warning: extension warning\n"]);
-  });
-
-  test("bounds resource diagnostics and reports omitted entries", async () => {
-    const { context } = await createTestRuntimeContext([]);
-    contexts.push(context);
-    const diagnostics = context.piResources.diagnostics as unknown as Array<{ type: "warning"; message: string }>;
-    for (let index = 0; index < 110; index += 1) diagnostics.push({ type: "warning", message: `warning-${index}` });
-    const stdio = captureStdio("");
-    provideStdioContext(context, stdio);
-
-    await context.plugin(stdioPlugin);
-
-    expect(stdio.errors).toHaveLength(101);
-    expect(stdio.errors[0]).toBe("Resource warning: warning-0\n");
-    expect(stdio.errors[99]).toBe("Resource warning: warning-99\n");
-    expect(stdio.errors[100]).toBe("Resource diagnostics: 10 additional entries omitted\n");
-  });
-
-  test("ignores hostile resource diagnostic accessors during activation", async () => {
-    const { context } = await createTestRuntimeContext([]);
-    contexts.push(context);
-    const accessed: string[] = [];
-    const diagnostic: Record<string, unknown> = {};
-    for (const key of ["type", "message"]) {
-      Object.defineProperty(diagnostic, key, {
-        get() {
-          accessed.push(key);
-          throw new Error(`${key} getter executed`);
-        },
-      });
-    }
-    (context.piResources.diagnostics as unknown as unknown[]).push(diagnostic);
-    const stdio = captureStdio("");
-    provideStdioContext(context, stdio);
-
-    await context.plugin(stdioPlugin);
-    expect(accessed).toEqual([]);
-    expect(stdio.errors).toEqual([]);
-  });
-
-  test("sanitizes and bounds resource diagnostics", async () => {
-    const { context } = await createTestRuntimeContext([]);
-    contexts.push(context);
-    (context.piResources.diagnostics as unknown as Array<{ type: string; message: string }>).push({
-      type: `warning\0\n${"t".repeat(100)}`,
-      message: `unsafe\0\n${"m".repeat(3_000)}`,
-    });
-    const stdio = captureStdio("");
-    provideStdioContext(context, stdio);
-
-    await context.plugin(stdioPlugin);
-
-    expect(stdio.errors).toHaveLength(1);
-    expect(stdio.errors[0]?.split("\n").filter(Boolean)).toHaveLength(1);
-    expect(stdio.errors[0]).not.toContain("\0");
-    expect(stdio.errors[0]?.length).toBeLessThanOrEqual(2_100);
-  });
-
-  test("ignores hostile extension error accessors", async () => {
-    const { context } = await createTestRuntimeContext([]);
-    contexts.push(context);
-    const stdio = captureStdio("");
-    provideStdioContext(context, stdio);
-    await context.plugin(stdioPlugin);
-    const accessed: string[] = [];
-    const error: Record<string, unknown> = {};
-    for (const key of ["extensionPath", "error"]) {
-      Object.defineProperty(error, key, {
-        get() {
-          accessed.push(key);
-          throw new Error(`${key} getter executed`);
-        },
-      });
-    }
-
-    expect(() => context.emit("pi/extension-error", error as never)).not.toThrow();
-    expect(accessed).toEqual([]);
-    expect(stdio.errors).toEqual([]);
-  });
-
-  test("uses a stable fallback for an extension failure without a safe message", async () => {
-    const { context } = await createTestRuntimeContext([]);
-    contexts.push(context);
-    const stdio = captureStdio("");
-    provideStdioContext(context, stdio);
-    await context.plugin(stdioPlugin);
-
-    context.emit("pi/extension-error", { extensionPath: "plugin.ts", event: "load", error: {} } as never);
-
-    expect(stdio.errors).toEqual(["Extension error (plugin.ts): Unknown extension failure\n"]);
-  });
-
-  test("sanitizes and bounds extension failure paths and messages", async () => {
-    const { context } = await createTestRuntimeContext([]);
-    contexts.push(context);
-    const stdio = captureStdio("");
-    provideStdioContext(context, stdio);
-    await context.plugin(stdioPlugin);
-
-    context.emit("pi/extension-error", {
-      extensionPath: `plugin\0\n${"p".repeat(1_000)}`,
-      event: "load",
-      error: `failure\0\n${"m".repeat(3_000)}`,
-    });
-
-    expect(stdio.errors).toHaveLength(1);
-    expect(stdio.errors[0]?.split("\n").filter(Boolean)).toHaveLength(1);
-    expect(stdio.errors[0]).not.toContain("\0");
-    expect(stdio.errors[0]?.length).toBeLessThanOrEqual(2_590);
-  });
-
-  test("removes session and extension listeners when disposed", async () => {
-    const { context } = await createTestRuntimeContext([]);
-    contexts.push(context);
-    const stdio = captureStdio("");
-    provideStdioContext(context, stdio);
-    await context.plugin(stdioPlugin);
-    await context.fiber.dispose();
-    let inspections = 0;
-    const hostile = new Proxy(
-      {},
-      {
-        getOwnPropertyDescriptor() {
-          inspections += 1;
-          return undefined;
-        },
-      },
-    );
-
-    context.emit("pi/session-event", hostile as never);
-    context.emit("pi/extension-error", hostile as never);
-
-    expect(inspections).toBe(0);
-    expect(stdio.errors).toEqual([]);
-    expect(context.get("piApplication")).toBeUndefined();
-  });
-});

package/packages/core/test/synapse.test.ts

@@ -1,67 +0,0 @@
-import { Context } from "@deepseek-ai/cordis";
-import { SessionManager } from "@earendil-works/pi-coding-agent";
-import { afterEach, describe, expect, test, vi } from "vitest";
-import synapsePlugin, { buildSynapseGraph } from "../src/plugins/synapse.js";
-import { provideLaunchContext, PiPluginUiRegistry, PiToolRegistry } from "../src/services.js";
-
-const contexts: Context[] = [];
-
-afterEach(async () => {
-  vi.restoreAllMocks();
-  await Promise.all(contexts.splice(0).map((context) => context.fiber.dispose()));
-});
-
-describe("synapse", () => {
-  test("builds fork graph with orphan accounting", () => {
-    const sessions = [
-      { id: "root", path: "/root.jsonl", cwd: "/workspace", firstMessage: "Root", messageCount: 2, modified: new Date("2026-01-01") },
-      {
-        id: "child",
-        path: "/child.jsonl",
-        cwd: "/workspace",
-        firstMessage: "Child",
-        messageCount: 3,
-        modified: new Date("2026-01-02"),
-        parentSessionPath: "/root.jsonl",
-      },
-      {
-        id: "orphan",
-        path: "/orphan.jsonl",
-        cwd: "/workspace",
-        firstMessage: "Orphan",
-        messageCount: 1,
-        modified: new Date("2026-01-03"),
-        parentSessionPath: "/missing.jsonl",
-      },
-    ];
-    const graph = buildSynapseGraph(sessions as never, "/child.jsonl");
-    expect(graph).toMatchObject({
-      activeSessionId: "child",
-      orphanCount: 1,
-      edges: [{ from: "root", to: "child", kind: "fork" }],
-    });
-    expect(graph.nodes.find((node) => node.id === "root")).toMatchObject({ branchCount: 1 });
-    expect(graph.nodes.find((node) => node.id === "child")).toMatchObject({ parentSessionId: "root", active: true });
-  });
-
-  test("refreshes native sessions and exposes strict sequential metadata", async () => {
-    vi.spyOn(SessionManager, "list").mockResolvedValue([
-      { id: "root", path: "/root.jsonl", cwd: "/workspace", firstMessage: "Root", messageCount: 1, modified: new Date("2026-01-01") } as never,
-    ]);
-    const context = new Context();
-    const tools = new PiToolRegistry();
-    const panels = new PiPluginUiRegistry();
-    provideLaunchContext(context, { cwd: "/workspace", agentDir: "/agent", args: [], requestExit() {} });
-    context.provide("piSession", { manager: { getSessionDir: () => "/agent/sessions", getSessionFile: () => "/root.jsonl" } } as never);
-    context.provide("piTools", tools);
-    context.provide("piPluginUi", panels);
-    await context.plugin(synapsePlugin, { maxSessions: 10 });
-    contexts.push(context);
-    const tool = tools.snapshot().customTools.find((item) => item.name === "synapse_session_map");
-    if (tool === undefined) throw new Error("synapse_session_map was not registered");
-    expect(tool.executionMode).toBe("sequential");
-    expect(tool.parameters).toMatchObject({ type: "object", additionalProperties: false });
-    await expect(tool.execute("map", {}, undefined, undefined, {} as never)).resolves.toMatchObject({ details: { nodes: [{ id: "root" }] } });
-    await expect(panels.snapshot()).resolves.toMatchObject([{ data: { nodes: [{ id: "root" }], refreshes: 2 } }]);
-  });
-});

package/packages/core/test/tab-manager.test.ts

@@ -1,58 +0,0 @@
-import { mkdtemp } 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 tabManagerPlugin from "../src/plugins/tab-manager.js";
-import { provideLaunchContext, PiPluginUiRegistry, PiToolRegistry } from "../src/services.js";
-
-const contexts: Context[] = [];
-
-async function fixture() {
-  const root = await mkdtemp(join(tmpdir(), "pi-harness-tabs-"));
-  const context = new Context();
-  const tools = new PiToolRegistry();
-  const panels = new PiPluginUiRegistry();
-  provideLaunchContext(context, { cwd: root, agentDir: root, args: [], requestExit() {} });
-  context.provide("piSession", { manager: { getSessionId: () => "session-1", getSessionFile: () => join(root, "session-1.jsonl") } } as never);
-  context.provide("piTools", tools);
-  context.provide("piPluginUi", panels);
-  await context.plugin(tabManagerPlugin);
-  contexts.push(context);
-  const tool = tools.snapshot().customTools.find((item) => item.name === "session_tab_manage");
-  if (tool === undefined) throw new Error("session_tab_manage was not registered");
-  return { root, context, tools, panels, tool };
-}
-
-afterEach(async () => {
-  await Promise.all(contexts.splice(0).map((context) => context.fiber.dispose()));
-});
-
-describe("tab manager", () => {
-  test("pins, renames, lists, and removes a session tab", async () => {
-    const { tool, panels } = await fixture();
-    expect(tool.executionMode).toBe("sequential");
-    expect(tool.parameters).toMatchObject({ type: "object", additionalProperties: false });
-    await expect(tool.execute("pin", { action: "pin", label: "Current" }, undefined, undefined, {} as never)).resolves.toMatchObject({
-      details: { id: "session-1", label: "Current", pinned: true },
-    });
-    await expect(tool.execute("rename", { action: "rename", label: "Renamed" }, undefined, undefined, {} as never)).resolves.toMatchObject({
-      details: { activeId: "session-1", tabs: [{ label: "Renamed", pinned: true }] },
-    });
-    await expect(tool.execute("list", { action: "list" }, undefined, undefined, {} as never)).resolves.toMatchObject({
-      details: { tabs: [{ label: "Renamed" }] },
-    });
-    await expect(tool.execute("remove", { action: "remove" }, undefined, undefined, {} as never)).resolves.toMatchObject({
-      details: { tabs: [], activeId: null },
-    });
-    await expect(panels.snapshot()).resolves.toMatchObject([{ data: { tabs: [], activeId: null } }]);
-  });
-
-  test("rejects invalid labels and disposes its registry entries", async () => {
-    const { context, tool, tools, panels } = await fixture();
-    await expect(tool.execute("rename", { action: "rename", label: "" }, undefined, undefined, {} as never)).rejects.toThrow(/label/iu);
-    await context.fiber.dispose();
-    expect(tools.snapshot().customTools).toHaveLength(0);
-    await expect(panels.snapshot()).resolves.toHaveLength(0);
-  });
-});

package/packages/core/test/taskboard.test.ts

@@ -1,73 +0,0 @@
-import { mkdtemp } 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 taskboardPlugin from "../src/plugins/taskboard.js";
-import { provideLaunchContext, PiPluginUiRegistry, PiToolRegistry } from "../src/services.js";
-
-const contexts: Context[] = [];
-
-async function fixture() {
-  const root = await mkdtemp(join(tmpdir(), "pi-harness-taskboard-"));
-  const context = new Context();
-  const tools = new PiToolRegistry();
-  const panels = new PiPluginUiRegistry();
-  provideLaunchContext(context, { cwd: root, agentDir: root, args: [], requestExit() {} });
-  context.provide("piTools", tools);
-  context.provide("piPluginUi", panels);
-  await context.plugin(taskboardPlugin, { fileName: "tasks.sqlite", keyPrefix: "TST" });
-  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,
-    create: find("taskboard_create"),
-    list: find("taskboard_list"),
-    update: find("taskboard_update"),
-    accept: find("taskboard_accept"),
-  };
-}
-
-afterEach(async () => {
-  await Promise.all(contexts.splice(0).map((context) => context.fiber.dispose()));
-});
-
-describe("taskboard", () => {
-  test("creates, updates, lists, and accepts a review task", async () => {
-    const { create, list, update, accept, panels } = await fixture();
-    for (const tool of [create, list, update, accept]) {
-      expect(tool.executionMode).toBe("sequential");
-      expect(tool.parameters).toMatchObject({ type: "object", additionalProperties: false });
-    }
-    const created = await create.execute(
-      "create",
-      { title: "Ship feature", description: "Review and release", priority: "high" },
-      undefined,
-      undefined,
-      {} as never,
-    );
-    expect(created.details).toMatchObject({ key: "TST-1", status: "backlog", priority: "high" });
-    await expect(update.execute("update", { key: "TST-1", status: "in_review" }, undefined, undefined, {} as never)).resolves.toMatchObject({
-      details: { key: "TST-1", status: "in_review" },
-    });
-    await expect(accept.execute("accept", { key: "TST-1", confirm: false }, undefined, undefined, {} as never)).rejects.toThrow(/confirm=true/iu);
-    await expect(accept.execute("accept", { key: "TST-1", confirm: true }, undefined, undefined, {} as never)).resolves.toMatchObject({
-      details: { key: "TST-1", status: "done" },
-    });
-    await expect(list.execute("list", { status: "done" }, undefined, undefined, {} as never)).resolves.toMatchObject({ details: { total: 1 } });
-    await expect(panels.snapshot()).resolves.toMatchObject([{ data: { total: 1, counts: { done: 1 } } }]);
-  });
-
-  test("cleans up all registrations on disposal", async () => {
-    const { context, tools, panels } = await fixture();
-    await context.fiber.dispose();
-    expect(tools.snapshot().customTools).toHaveLength(0);
-    await expect(panels.snapshot()).resolves.toHaveLength(0);
-  });
-});

package/packages/core/test/telemetry-blocker.test.ts

@@ -1,61 +0,0 @@
-import { Context } from "@deepseek-ai/cordis";
-import { afterEach, describe, expect, test } from "vitest";
-import telemetryBlockerPlugin from "../src/plugins/telemetry-blocker.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(telemetryBlockerPlugin);
-  contexts.push(context);
-  const tool = tools.snapshot().customTools.find((item) => item.name === "telemetry_status");
-  if (tool === undefined) throw new Error("telemetry_status was not registered");
-  return { context, tools, panels, tool };
-}
-
-afterEach(async () => {
-  await Promise.all(contexts.splice(0).map((context) => context.fiber.dispose()));
-});
-
-describe("telemetry blocker", () => {
-  test("blocks telemetry and reports only bounded event names", async () => {
-    const { context, tool, panels } = await fixture();
-    expect(tool.executionMode).toBe("sequential");
-    expect(tool.parameters).toMatchObject({ type: "object", additionalProperties: false });
-    context.emit("pi/telemetry", { name: "usage", properties: { secret: "should-not-retain" } });
-    const long = "x".repeat(200);
-    context.emit("pi/telemetry", { name: long });
-    await expect(tool.execute("status", {}, undefined, undefined, {} as never)).resolves.toMatchObject({
-      details: { blocked: 2, names: ["usage", long.slice(0, 80)] },
-    });
-    await expect(panels.snapshot()).resolves.toMatchObject([{ data: { enabled: false, blocked: 2, names: ["usage", long.slice(0, 80)] } }]);
-  });
-
-  test("rejects empty event names and cleans up registrations", async () => {
-    const { context, tools, panels } = await fixture();
-    expect(() => context.emit("pi/telemetry", { name: "   " })).toThrow(/must not be empty/iu);
-    await context.fiber.dispose();
-    expect(tools.snapshot().customTools).toHaveLength(0);
-    await expect(panels.snapshot()).resolves.toHaveLength(0);
-  });
-
-  test("rejects unknown plugin configuration before activation", async () => {
-    const context = new Context();
-    context.provide("piTools", new PiToolRegistry());
-    context.provide("piPluginUi", new PiPluginUiRegistry());
-    let error: unknown;
-    try {
-      await context.plugin(telemetryBlockerPlugin, { unexpected: true });
-    } catch (caught) {
-      error = caught;
-    }
-    expect(error).toBeInstanceOf(Error);
-    expect((error as Error).message).toMatch(/config keys: unexpected/iu);
-    await context.fiber.dispose();
-  });
-});