@pi-harness/pi-harness 0.1.13 → 0.1.14

package/packages/core/test/mcp-panel.test.ts

@@ -0,0 +1,91 @@
+import { mkdtemp, readFile } 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 mcpPanelPlugin from "../src/plugins/mcp-panel.js";
+import { provideLaunchContext, PiPluginUiRegistry, PiToolRegistry } from "../src/services.js";
+
+const contexts: Context[] = [];
+
+async function fixture() {
+  const root = await mkdtemp(join(tmpdir(), "pi-harness-mcp-panel-"));
+  const context = new Context();
+  const tools = new PiToolRegistry();
+  const panels = new PiPluginUiRegistry();
+  provideLaunchContext(context, { cwd: root, agentDir: root, args: [], requestExit() {} });
+  context.provide("piMcp", { snapshot: () => ({ servers: [{ id: "docs", command: ["node", "server.mjs"], status: "running", startedAt: 10 }] }) } as never);
+  context.provide("piTools", tools);
+  context.provide("piPluginUi", panels);
+  await context.plugin(mcpPanelPlugin, { patchPath: "patch.yml" });
+  contexts.push(context);
+  const tool = tools.snapshot().customTools.find((item) => item.name === "mcp_panel");
+  if (tool === undefined) throw new Error("mcp_panel was not registered");
+  return { root, context, tools, panels, tool };
+}
+
+afterEach(async () => {
+  await Promise.all(contexts.splice(0).map((context) => context.fiber.dispose()));
+});
+
+describe("MCP panel", () => {
+  test("reports status and previews a validated profile patch", async () => {
+    const { tool, panels } = await fixture();
+    expect(tool.executionMode).toBe("sequential");
+    expect(tool.parameters).toMatchObject({ type: "object", additionalProperties: false });
+    await expect(tool.execute("status", { action: "status" }, undefined, undefined, {} as never)).resolves.toMatchObject({
+      details: { action: "status", servers: [{ id: "docs", status: "running", executable: "node" }] },
+    });
+    const preview = await tool.execute(
+      "preview",
+      { action: "preview", serverId: "new-server", command: ["node", "new.mjs"] },
+      undefined,
+      undefined,
+      {} as never,
+    );
+    expect((preview.details as { fragment: string }).fragment).toContain('id: "new-server"');
+    await expect(panels.snapshot()).resolves.toMatchObject([{ data: { writesEnabled: true } }]);
+  });
+
+  test("requires confirmation for writes, writes a backup, and cleans up", async () => {
+    const { root, context, tools, panels, tool } = await fixture();
+    await expect(
+      tool.execute("apply", { action: "apply", serverId: "new-server", command: ["node", "new.mjs"], confirm: false }, undefined, undefined, {} as never),
+    ).rejects.toThrow(/confirm=true/iu);
+    const result = await tool.execute(
+      "apply",
+      { action: "apply", serverId: "new-server", command: ["node", "new.mjs"], confirm: true },
+      undefined,
+      undefined,
+      {} as never,
+    );
+    expect((result.details as { path: string }).path).toContain("patch.yml");
+    expect(await readFile(join(root, "patch.yml"), "utf8")).toContain("new-server");
+    expect(await readFile(join(root, "patch.yml.bak"), "utf8")).toBe("");
+    await context.fiber.dispose();
+    expect(tools.snapshot().customTools).toHaveLength(0);
+    await expect(panels.snapshot()).resolves.toHaveLength(0);
+  });
+
+  test("refreshes the backup with the profile immediately preceding each apply", async () => {
+    const { root, tool } = await fixture();
+    await tool.execute(
+      "apply-first",
+      { action: "apply", serverId: "first-server", command: ["node", "first.mjs"], confirm: true },
+      undefined,
+      undefined,
+      {} as never,
+    );
+    const profileAfterFirstApply = await readFile(join(root, "patch.yml"), "utf8");
+
+    await tool.execute(
+      "apply-second",
+      { action: "apply", serverId: "second-server", command: ["node", "second.mjs"], confirm: true },
+      undefined,
+      undefined,
+      {} as never,
+    );
+
+    expect(await readFile(join(root, "patch.yml.bak"), "utf8")).toBe(profileAfterFirstApply);
+  });
+});

package/packages/core/test/memory.test.ts

@@ -0,0 +1,125 @@
+import { lstat, mkdir, mkdtemp, readFile, rm, utimes, 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 memoryPlugin from "../src/plugins/memory.js";
+import { provideLaunchContext, PiPluginUiRegistry, PiToolRegistry } from "../src/services.js";
+
+const contexts: Context[] = [];
+
+async function fixture(config: { fileName?: string; maxEntries?: number } = { fileName: "memory.json", maxEntries: 5 }) {
+  const root = await mkdtemp(join(tmpdir(), "pi-harness-memory-"));
+  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(memoryPlugin, config);
+  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 { root, context, tools, panels, set: find("memory_set"), search: find("memory_search"), remove: find("memory_delete") };
+}
+
+afterEach(async () => {
+  await Promise.all(contexts.splice(0).map((context) => context.fiber.dispose()));
+});
+
+describe("memory", () => {
+  test("falls back to a finite entry limit for non-finite configuration", async () => {
+    const { set } = await fixture({ fileName: "memory.json", maxEntries: Number.NaN });
+
+    await expect(set.execute("finite-limit", { key: "safe", value: "bounded" }, undefined, undefined, {} as never)).resolves.toMatchObject({
+      details: { key: "safe", value: "bounded" },
+    });
+  });
+
+  test("reclaims a stale memory lock owned by a dead process after restart", async () => {
+    const { root, set } = await fixture();
+    const lockPath = join(root, "memory.json.lock");
+    const ownerPath = join(lockPath, "abandoned.owner");
+    await mkdir(lockPath);
+    await writeFile(ownerPath, JSON.stringify({ pid: 999_999_999, token: "abandoned" }), "utf8");
+    const old = new Date(Date.now() - 60_000);
+    await utimes(ownerPath, old, old);
+    await utimes(lockPath, old, old);
+    const pending = set.execute("restart", { key: "restart", value: "recovered" }, undefined, undefined, {} as never);
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    try {
+      const outcome = await Promise.race([
+        pending.then(() => "completed"),
+        new Promise<string>((resolve) => {
+          timer = setTimeout(() => resolve("waiting"), 500);
+        }),
+      ]);
+      expect(outcome).toBe("completed");
+      await expect(pending).resolves.toMatchObject({ details: { key: "restart", value: "recovered" } });
+      await expect(lstat(lockPath)).rejects.toMatchObject({ code: "ENOENT" });
+    } finally {
+      if (timer !== undefined) clearTimeout(timer);
+      await rm(lockPath, { recursive: true, force: true });
+      await pending.catch(() => undefined);
+    }
+  });
+
+  test("does not reclaim a stale memory lock owned by a live process", async () => {
+    const { root, set } = await fixture();
+    const lockPath = join(root, "memory.json.lock");
+    const ownerPath = join(lockPath, "live.owner");
+    const owner = JSON.stringify({ pid: process.pid, token: "live" });
+    await mkdir(lockPath);
+    await writeFile(ownerPath, owner, "utf8");
+    const old = new Date(Date.now() - 60_000);
+    await utimes(ownerPath, old, old);
+    await utimes(lockPath, old, old);
+    const pending = set.execute("live-lock", { key: "live", value: "must wait" }, undefined, undefined, {} as never);
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    try {
+      const outcome = await Promise.race([
+        pending.then(() => "completed"),
+        new Promise<string>((resolve) => {
+          timer = setTimeout(() => resolve("waiting"), 500);
+        }),
+      ]);
+      expect(outcome).toBe("waiting");
+      await expect(readFile(ownerPath, "utf8")).resolves.toBe(owner);
+    } finally {
+      if (timer !== undefined) clearTimeout(timer);
+      await rm(lockPath, { recursive: true, force: true });
+      await pending.catch(() => undefined);
+    }
+  });
+
+  test("persists, searches, and confirms deletion of explicit facts", async () => {
+    const { set, search, remove, panels } = await fixture();
+    for (const tool of [set, search, remove]) {
+      expect(tool.executionMode).toBe("sequential");
+      expect(tool.parameters).toMatchObject({ type: "object", additionalProperties: false });
+    }
+    await expect(set.execute("set", { key: "language", value: "TypeScript", tags: ["code"] }, undefined, undefined, {} as never)).resolves.toMatchObject({
+      details: { key: "language", value: "TypeScript", tags: ["code"] },
+    });
+    await expect(search.execute("search", { query: "script" }, undefined, undefined, {} as never)).resolves.toMatchObject({ details: { total: 1 } });
+    await expect(remove.execute("delete", { key: "language", confirm: false }, undefined, undefined, {} as never)).rejects.toThrow(/confirm=true/iu);
+    await expect(remove.execute("delete", { key: "language", confirm: true }, undefined, undefined, {} as never)).resolves.toMatchObject({
+      details: { key: "language", removed: true },
+    });
+    await expect(panels.snapshot()).resolves.toMatchObject([{ data: { count: 0 } }]);
+  });
+
+  test("fails closed on malformed persisted records and cleans up", async () => {
+    const { root, context, tools, panels } = await fixture();
+    await writeFile(join(root, "memory.json"), JSON.stringify({ version: 1, memories: [{ id: "x", key: "x", value: "ok", tags: [] }] }));
+    const search = tools.snapshot().customTools.find((item) => item.name === "memory_search");
+    if (search === undefined) throw new Error("memory_search was not registered");
+    await expect(search.execute("search", { query: "ok" }, undefined, undefined, {} as never)).rejects.toThrow(/invalid memories/iu);
+    await context.fiber.dispose();
+    expect(tools.snapshot().customTools).toHaveLength(0);
+    await expect(panels.snapshot()).resolves.toHaveLength(0);
+  });
+});

package/packages/core/test/mirage-bridge.test.ts

@@ -38,6 +38,10 @@ else console.log(JSON.stringify(process.argv.slice(2)));
       const execute = tools.snapshot().customTools.find((tool) => tool.name === "mirage_execute");
       expect(doctor).toBeDefined();
       expect(execute).toBeDefined();
+      expect(doctor!.executionMode).toBe("sequential");
+      expect(doctor!.parameters).toMatchObject({ additionalProperties: false });
+      expect(execute!.executionMode).toBe("sequential");
+      expect(execute!.parameters).toMatchObject({ additionalProperties: false });
       await expect(doctor!.execute("doctor-1", {}, undefined, undefined, {} as never)).resolves.toMatchObject({
         details: { available: true, version: "mirage 0.9.0", workspaceId: "review-sandbox" },
       });

package/packages/core/test/mock-server.test.ts

@@ -0,0 +1,63 @@
+import { request } from "node:http";
+import { Context } from "@deepseek-ai/cordis";
+import { afterEach, describe, expect, test } from "vitest";
+import mockServerPlugin from "../src/plugins/mock-server.js";
+import { PiPluginUiRegistry, PiToolRegistry } from "../src/services.js";
+
+const contexts: Context[] = [];
+
+function get(url: string): Promise<{ status: number; body: string }> {
+  return new Promise((resolve, reject) => {
+    const req = request(url, (res) => {
+      const chunks: Buffer[] = [];
+      res.on("data", (chunk: Buffer) => chunks.push(chunk));
+      res.on("end", () => resolve({ status: res.statusCode ?? 0, body: Buffer.concat(chunks).toString("utf8") }));
+    });
+    req.on("error", reject);
+    req.end();
+  });
+}
+
+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(mockServerPlugin, { routes: [{ path: "/hello", method: "GET", body: "world" }] });
+  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, start: find("mock_server_start"), stop: find("mock_server_stop"), status: find("mock_server_status") };
+}
+
+afterEach(async () => {
+  await Promise.all(contexts.splice(0).map((context) => context.fiber.dispose()));
+});
+
+describe("mock server", () => {
+  test("serves configured loopback routes and exposes strict sequential tools", async () => {
+    const { start, stop, status } = await fixture();
+    for (const tool of [start, stop, status]) {
+      expect(tool.executionMode).toBe("sequential");
+      expect(tool.parameters).toMatchObject({ type: "object", additionalProperties: false });
+    }
+    const started = await start.execute("start", { port: 0 }, undefined, undefined, {} as never);
+    const url = (started.details as { url: string }).url;
+    expect(await get(`${url}/hello`)).toEqual({ status: 200, body: "world" });
+    expect(await get(`${url}/missing`)).toMatchObject({ status: 404 });
+    await expect(status.execute("status", {}, undefined, undefined, {} as never)).resolves.toMatchObject({ details: { running: true } });
+    await expect(stop.execute("stop", {}, undefined, undefined, {} as never)).resolves.toMatchObject({ details: { stopped: true } });
+  });
+
+  test("cleans up server and registrations on disposal", async () => {
+    const { context, tools, panels, start } = await fixture();
+    await start.execute("start", { port: 0 }, undefined, undefined, {} as never);
+    await context.fiber.dispose();
+    expect(tools.snapshot().customTools).toHaveLength(0);
+    await expect(panels.snapshot()).resolves.toHaveLength(0);
+  });
+});

package/packages/core/test/model.test.ts

@@ -0,0 +1,62 @@
+import { Context } from "@deepseek-ai/cordis";
+import { ModelRuntime } from "@earendil-works/pi-coding-agent";
+import { afterEach, describe, expect, test } from "vitest";
+import modelPlugin from "../src/plugins/model.js";
+
+const contexts: Context[] = [];
+
+afterEach(async () => {
+  await Promise.all(contexts.splice(0).map(async (context) => context.fiber.dispose()));
+});
+
+async function createContext(provider = "deepseek", model = "deepseek-v4-flash"): Promise<Context> {
+  const context = new Context();
+  contexts.push(context);
+  const runtime = await ModelRuntime.create({ modelsPath: null, refreshOnCreate: false });
+  context.provide("piModelRuntime", { runtime, provider, model });
+  context.provide("piResources", {} as never);
+  return context;
+}
+
+describe("model plugin", () => {
+  test("rejects a non-object configuration instead of treating it as empty", async () => {
+    const context = await createContext();
+    let activationError: unknown;
+    try {
+      await context.plugin(modelPlugin, 42 as never);
+    } catch (error) {
+      activationError = error;
+    }
+
+    expect(activationError).toBeInstanceOf(Error);
+    expect(context.get("piModels")).toBeUndefined();
+  });
+
+  test("rejects unknown configuration without publishing a partial selection", async () => {
+    const context = await createContext();
+
+    await expect(context.plugin(modelPlugin, { fallback: true })).rejects.toThrow(/Unknown pi-model config keys: fallback/u);
+    expect(context.get("piModels")).toBeUndefined();
+  });
+
+  test("publishes the exact registered model from the shared runtime", async () => {
+    const context = await createContext();
+    const expected = context.piModelRuntime.runtime.getModel("deepseek", "deepseek-v4-flash");
+    expect(expected).toBeDefined();
+
+    await context.plugin(modelPlugin);
+
+    expect(context.piModels.runtime).toBe(context.piModelRuntime.runtime);
+    expect(context.piModels.model).toBe(expected);
+  });
+
+  test("removes the selected model service on disposal", async () => {
+    const context = await createContext();
+    await context.plugin(modelPlugin);
+    expect(context.get("piModels")).toBeDefined();
+
+    await context.fiber.dispose();
+
+    expect(context.get("piModels")).toBeUndefined();
+  });
+});

package/packages/core/test/models.test.ts

@@ -0,0 +1,85 @@
+import { mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Context } from "@deepseek-ai/cordis";
+import { ModelRuntime } from "@earendil-works/pi-coding-agent";
+import { afterEach, describe, expect, test, vi } from "vitest";
+import modelsPlugin, { Config as ModelsConfig } from "../src/plugins/models.js";
+import { provideLaunchContext } from "../src/services.js";
+
+const contexts: Context[] = [];
+
+afterEach(async () => {
+  await Promise.all(contexts.splice(0).map(async (context) => context.fiber.dispose()));
+});
+
+async function createContext(): Promise<{ context: Context; agentDir: string }> {
+  const cwd = await mkdtemp(join(tmpdir(), "pi-harness-models-cwd-"));
+  const agentDir = await mkdtemp(join(tmpdir(), "pi-harness-models-agent-"));
+  const context = new Context();
+  contexts.push(context);
+  provideLaunchContext(context, { cwd, agentDir, args: [], requestExit() {} });
+  return { context, agentDir };
+}
+
+describe("models plugin", () => {
+  test.each([
+    [{ provider: "   ", model: "deepseek-v4-flash" }, /provider/u],
+    [{ provider: "deep\nseek", model: "deepseek-v4-flash" }, /provider/u],
+    [{ provider: "p".repeat(129), model: "deepseek-v4-flash" }, /provider/u],
+    [{ provider: "deepseek", model: "\t" }, /model/u],
+    [{ provider: "deepseek", model: "bad\0model" }, /model/u],
+    [{ provider: "deepseek", model: "m".repeat(513) }, /model/u],
+  ])("rejects an unsafe or unbounded model selection %#", (config, expected) => {
+    expect(() => ModelsConfig(config)).toThrow(expected);
+  });
+
+  test("fails activation instead of silently ignoring an invalid models file", async () => {
+    const { context, agentDir } = await createContext();
+    await writeFile(join(agentDir, "models.json"), "{ not-json", "utf8");
+
+    let activationError: unknown;
+    try {
+      await context.plugin(modelsPlugin, { provider: "deepseek", model: "deepseek-v4-flash", refreshOnCreate: false });
+    } catch (error) {
+      activationError = error;
+    }
+
+    expect(activationError).toBeInstanceOf(Error);
+    expect((activationError as Error).message).toMatch(/Failed to parse models\.json/u);
+    expect(context.get("piModelRuntime")).toBeUndefined();
+  });
+
+  test("rejects unknown configuration without publishing a partial service", async () => {
+    const { context } = await createContext();
+
+    await expect(
+      context.plugin(modelsPlugin, { provider: "deepseek", model: "deepseek-v4-flash", refreshOnCreate: false, refreshOnCreat: true } as never),
+    ).rejects.toThrow(/Unknown pi-models config keys: refreshOnCreat/u);
+    expect(context.get("piModelRuntime")).toBeUndefined();
+  });
+
+  test("removes the model runtime service on plugin disposal", async () => {
+    const { context } = await createContext();
+    await context.plugin(modelsPlugin, { provider: "deepseek", model: "deepseek-v4-flash", refreshOnCreate: false });
+
+    expect(context.get("piModelRuntime")?.provider).toBe("deepseek");
+    await context.fiber.dispose();
+
+    expect(context.get("piModelRuntime")).toBeUndefined();
+  });
+
+  test("bounds opt-in network refresh during startup", async () => {
+    const { context } = await createContext();
+    const runtime = await ModelRuntime.create({ modelsPath: null, refreshOnCreate: false });
+    const create = vi.spyOn(ModelRuntime, "create").mockResolvedValue(runtime);
+    try {
+      await context.plugin(modelsPlugin, { provider: "deepseek", model: "deepseek-v4-flash", refreshOnCreate: true });
+
+      expect(create).toHaveBeenCalledOnce();
+      expect(create.mock.calls[0]?.[0]?.modelRefreshTimeoutMs).toBe(15_000);
+    } finally {
+      create.mockRestore();
+    }
+  });
+});