gentle-pi 4.0.0 → 4.2.0

package/tests/history-agent-home.test.ts

@@ -0,0 +1,81 @@
+import { after, test } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+// S9: in a bundled install the store, its legacy files and the transcript
+// scan follow the agent home Pi runs with (PI_CODING_AGENT_DIR). Everywhere
+// else they stay under ~/.pi/agent, where existing histories live.
+
+// The OS home is a temporary folder before the extension is imported, so even
+// a resolver that ignores PI_CODING_AGENT_DIR (or reads the OS home at import)
+// can never write into the real home.
+const osHome = fs.mkdtempSync(path.join(os.tmpdir(), "pi-history-os-home-"));
+const previousHome = { HOME: process.env.HOME, USERPROFILE: process.env.USERPROFILE };
+process.env.HOME = osHome;
+process.env.USERPROFILE = osHome;
+const { default: promptHistoryExtension } = await import("../extensions/history/index.ts");
+const { setBundledInstallForTesting } = await import("../lib/gentle-shell-bundled.ts");
+after(() => {
+  for (const [name, value] of Object.entries(previousHome)) {
+    if (value === undefined) delete process.env[name];
+    else process.env[name] = value;
+  }
+  fs.rmSync(osHome, { recursive: true, force: true });
+});
+
+type Handler = (...args: unknown[]) => unknown;
+
+function load(env: NodeJS.ProcessEnv) {
+  const handlers = new Map<string, Handler[]>();
+  const pi = {
+    on: (name: string, handler: Handler) => {
+      handlers.set(name, [...(handlers.get(name) ?? []), handler]);
+    },
+    registerShortcut: () => {},
+    registerCommand: () => {},
+  };
+  promptHistoryExtension(pi as never, {
+    env: { GENTLE_PI_HISTORY_CAPTURE: "1", ...env },
+    cwd: "/pi-history-test/project-agent-home",
+    instanceId: "inst-agent-home",
+    now: () => 1700000000000,
+    gentlePiConfigHome: fs.mkdtempSync(path.join(os.tmpdir(), "pi-history-agent-home-config-")),
+  });
+  return async (prompt: string) => {
+    await new Promise((resolve) => setImmediate(resolve));
+    for (const handler of handlers.get("before_agent_start") ?? []) await handler({ prompt }, {});
+  };
+}
+
+function holds(store: string, prompt: string): boolean {
+  if (!fs.existsSync(store)) return false;
+  return fs.readdirSync(store, { recursive: true }).map(String)
+    .map((file) => path.join(store, file))
+    .filter((file) => fs.statSync(file).isFile())
+    .some((file) => fs.readFileSync(file, "utf8").includes(prompt));
+}
+
+test("outside a bundled install prompt history stays under ~/.pi/agent, whatever agent home Pi runs with", async (t) => {
+  const agentHome = fs.mkdtempSync(path.join(os.tmpdir(), "pi-history-agent-home-"));
+  t.after(() => fs.rmSync(agentHome, { recursive: true, force: true }));
+  // The isolated launcher's home, and a prefix variable this package is not installed in.
+  await load({ PI_CODING_AGENT_DIR: agentHome, GENTLE_SHELL_PREFIX: agentHome })("isolated home prompt");
+  assert.ok(holds(path.join(osHome, ".pi", "agent", "history"), "isolated home prompt"));
+  assert.equal(fs.existsSync(path.join(agentHome, "history")), false);
+});
+
+test("in a bundled install prompt history lives under the agent home Pi runs with", async (t) => {
+  const agentHome = fs.mkdtempSync(path.join(os.tmpdir(), "pi-history-agent-home-"));
+  const prefix = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "pi-history-prefix-")));
+  // The testing overlay stands in for this package running from that prefix.
+  setBundledInstallForTesting({ root: prefix });
+  t.after(() => {
+    setBundledInstallForTesting(undefined);
+    for (const dir of [agentHome, prefix]) fs.rmSync(dir, { recursive: true, force: true });
+  });
+  await load({ PI_CODING_AGENT_DIR: agentHome, GENTLE_SHELL_PREFIX: prefix })("bundled prompt");
+  assert.ok(holds(path.join(agentHome, "history"), "bundled prompt"));
+  assert.equal(holds(path.join(osHome, ".pi", "agent", "history"), "bundled prompt"), false);
+});

package/tests/history-child-guard.test.ts

@@ -0,0 +1,70 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import promptHistoryExtension from "../extensions/history/index.ts";
+
+// gentle-shell#1690: delegated children (GENTLE_PI_AGENTS_CHILD=1) receive
+// the package too. Their before_agent_start prompt is a delegation brief,
+// not user history, so a child must never initialize, capture or GC the
+// store, even when capture is opted in. The selector may still register.
+
+const CWD = "/pi-history-test/project-child";
+
+type Handler = (...args: unknown[]) => unknown;
+
+function load(child: boolean) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-history-child-"));
+  const handlers = new Map<string, Handler[]>();
+  const commands: string[] = [];
+  const shortcuts: string[] = [];
+  const pi = {
+    on: (name: string, handler: Handler) => {
+      handlers.set(name, [...(handlers.get(name) ?? []), handler]);
+    },
+    registerShortcut: (key: string) => { shortcuts.push(key); },
+    registerCommand: (name: string) => { commands.push(name); },
+  };
+  promptHistoryExtension(pi as never, {
+    env: { GENTLE_PI_HISTORY_CAPTURE: "1", GENTLE_PI_AGENTS_CHILD: child ? "1" : "0" },
+    root,
+    cwd: CWD,
+    instanceId: `inst-${child ? "child" : "parent"}`,
+    now: () => 1700000000000,
+    agentDir: path.join(root, "agent"),
+    sessionsRoot: path.join(root, "sessions"),
+    gentlePiConfigHome: fs.mkdtempSync(path.join(os.tmpdir(), "pi-history-child-config-")),
+  });
+  const fire = async (name: string, event: unknown) => {
+    for (const handler of handlers.get(name) ?? []) await handler(event, {});
+  };
+  return { root, fire, commands, shortcuts };
+}
+
+const flush = () => new Promise((resolve) => setImmediate(resolve));
+
+test("a delegated child never initializes, captures or GCs prompt history", async () => {
+  const { root, fire, commands, shortcuts } = load(true);
+  await flush();
+  assert.deepEqual(fs.readdirSync(root), [], "no warm-up writer init");
+  await fire("before_agent_start", { prompt: "delegated task brief" });
+  assert.deepEqual(fs.readdirSync(root), [], "no prompt capture");
+  await fire("session_shutdown", {});
+  assert.deepEqual(fs.readdirSync(root), [], "no GC rewrite");
+  assert.deepEqual(commands, ["history"]);
+  assert.equal(shortcuts.length, 1);
+});
+
+test("an opted-in parent still captures prompt history", async () => {
+  const { root, fire } = load(false);
+  await flush();
+  await fire("before_agent_start", { prompt: "parent prompt" });
+  const files = fs.readdirSync(root, { recursive: true }).map(String);
+  assert.ok(files.length > 0, "the parent initializes its store");
+  const captured = files
+    .map((file) => path.join(root, file))
+    .filter((file) => fs.statSync(file).isFile())
+    .some((file) => fs.readFileSync(file, "utf8").includes("parent prompt"));
+  assert.ok(captured, `the parent prompt is persisted: ${JSON.stringify(files)}`);
+});

package/tests/inprocess-reviewer.test.ts

@@ -647,3 +647,23 @@ test("the no-apiKey options shape is identical on the composed-provider and deps
 	assert.deepEqual(providerKeys, completeKeys, "routing through the composed provider must not change which credential fields this module forwards");
 	assert.equal(providerKeys.includes("apiKey"), false, "neither path may carry an apiKey the registry did not resolve");
 });
+
+for (const transport of ["sse", "websocket", "websocket-cached", "auto", undefined] as const) {
+	for (const composed of [false, true]) {
+		test(`reviewer forwards transport ${transport ?? "absent"} through ${composed ? "composed provider" : "compat completion"} unchanged`, async () => {
+			const model = fakeModel();
+			const registry = fakeRegistry([model]);
+			const captured = capturingComplete(assistantText("review result"));
+			if (composed) registry.getProvider = () => ({
+				streamSimple: (model, context, options) => ({ result: () => captured.complete(model, context, options) }),
+			});
+			const outcome = await runInProcessReviewer(baseRequest({ transport }), { registry, complete: captured.complete });
+			assert.deepEqual(outcome, { kind: "text", text: "review result", reviewerModel: "openai/gpt-5" });
+			assert.equal(captured.calls.length, 1);
+			assert.equal(captured.calls[0]!.options?.transport, transport);
+			assert.equal(Object.hasOwn(captured.calls[0]!.options!, "transport"), transport !== undefined);
+			assert.equal(captured.calls[0]!.options?.apiKey, "test-key");
+			assert.equal(captured.calls[0]!.options?.timeoutMs, 30_000);
+		});
+	}
+}

package/tests/install-gentle-ai-failure.test.ts

@@ -0,0 +1,69 @@
+import assert from "node:assert/strict";
+import { copyFileSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import test from "node:test";
+
+// The postinstall entry with a stub installer that fails the way a Windows Go source
+// build does: GentleAiInstallerError caused by execFile's error, which carries stdout
+// and stderr. pnpm shows this stderr in its lifecycle output, and the installer wizard
+// reports the line its one-line detail rule selects.
+function postinstall(failure: string) {
+	const root = mkdtempSync(join(tmpdir(), "gentle-pi-postinstall-failure-"));
+	try {
+		const scripts = join(root, "node_modules", "gentle-pi", "scripts");
+		mkdirSync(scripts, { recursive: true });
+		copyFileSync(new URL("../scripts/install-gentle-ai.mjs", import.meta.url), join(scripts, "install-gentle-ai.mjs"));
+		copyFileSync(new URL("../scripts/install-tui-mode-setting.mjs", import.meta.url), join(scripts, "install-tui-mode-setting.mjs"));
+		writeFileSync(join(scripts, "gentle-ai-installer.mjs"), `export const INSTALLER_VERSION = "4.0.0";\nexport async function installGentleAi() {\n${failure}\n}\n`);
+		return spawnSync(process.execPath, [join(scripts, "install-gentle-ai.mjs")], { encoding: "utf8",
+			env: { ...process.env, GENTLE_PI_AGENT_HOME: join(root, "agent"), GENTLE_PI_SKIP_GENTLE_AI_INSTALL: "0" } });
+	} finally { rmSync(root, { recursive: true, force: true }); }
+}
+
+test("a failed postinstall prints the whole cause chain with codes and the failing command's output, and exits 1", () => {
+	const result = postinstall(`
+	const go = Object.assign(new Error("Command failed: C:\\\\go\\\\bin\\\\go.exe install pkg@v4.0.0\\ngo: downloading pkg v4.0.0\\ngo: verifying pkg@v4.0.0: checksum mismatch"),
+		{ code: 1, stdout: "", stderr: "go: downloading pkg v4.0.0\\ngo: verifying pkg@v4.0.0: checksum mismatch\\n" });
+	throw Object.assign(new Error("Gentle AI Go SumDB source installation failed for pkg@v4.0.0.", { cause: go }), { code: "GENTLE_AI_GO_INSTALL_FAILED" });`);
+	assert.equal(result.status, 1);
+	assert.equal(result.stderr, [
+		"gentle-pi could not install its package-local Gentle AI v4.0.0 binary: Gentle AI Go SumDB source installation failed for pkg@v4.0.0. (code GENTLE_AI_GO_INSTALL_FAILED)",
+		"  caused by Error: Command failed: C:\\go\\bin\\go.exe install pkg@v4.0.0 (code 1)",
+		"    stderr:",
+		"    | go: downloading pkg v4.0.0",
+		"    | go: verifying pkg@v4.0.0: checksum mismatch",
+		// Last, in the `Error:` form the installer wizard's one-line detail selects.
+		"  root cause Error: go: verifying pkg@v4.0.0: checksum mismatch",
+		"",
+	].join("\n"));
+});
+
+test("a failed postinstall without a cause reads exactly as before", () => {
+	for (const [failure, shown] of [["throw new Error(\"plain failure\");", "plain failure"], ["throw \"boom\";", "boom"]]) {
+		const result = postinstall(failure);
+		assert.equal(result.status, 1);
+		assert.equal(result.stderr, `gentle-pi could not install its package-local Gentle AI v4.0.0 binary: ${shown}\n`);
+	}
+});
+
+test("a failed postinstall bounds each output to its last 4000 characters, reports a signal, and ends a cause cycle", () => {
+	const bounded = postinstall(`
+	const timeout = Object.assign(new Error("Command failed: go.exe install"), { code: null, signal: "SIGTERM", stderr: "x".repeat(5000) + "\\nlast line", stdout: "progress\\n" });
+	throw new Error("top", { cause: timeout });`);
+	assert.equal(bounded.status, 1);
+	assert.match(bounded.stderr, /caused by Error: Command failed: go\.exe install \(signal SIGTERM\)/);
+	assert.match(bounded.stderr, /stderr \(last 4000 characters\):/);
+	assert.doesNotMatch(bounded.stderr, /x{3991}/);
+	assert.match(bounded.stderr, /stdout:\n {4}\| progress/);
+	assert.match(bounded.stderr, /root cause Error: last line\n$/, "stderr wins over stdout");
+	const cyclic = postinstall(`
+	const first = new Error("first");
+	const second = new Error("second", { cause: first });
+	Object.assign(first, { cause: second });
+	throw new Error("top", { cause: first });`);
+	assert.equal(cyclic.status, 1);
+	assert.equal(cyclic.stderr.split("\n").filter((line) => line.startsWith("  caused by ")).length, 6);
+	assert.match(cyclic.stderr, /further causes omitted\n$/);
+});

package/tests/install-tui-mode-setting.test.ts

@@ -378,3 +378,18 @@ for (const [name, packagePath] of [
 		});
 	}
 }
+
+// #1258 / #2109: on recent Windows, lstat by path reports dev 0 while fstat on
+// the opened handle reports the volume serial, so settings.json looked replaced
+// and every `pi install npm:gentle-pi` postinstall exited 1.
+test("sameOpenedFile accepts the same Windows file whose path stat has no volume id", async () => {
+	const { sameOpenedFile } = await import("../scripts/install-tui-mode-setting.mjs");
+	assert.equal(sameOpenedFile({ dev: 0, ino: 42 }, { dev: 2384917313, ino: 42 }, "win32"), true);
+	assert.equal(sameOpenedFile({ dev: 2384917313, ino: 42 }, { dev: 2384917313, ino: 42 }, "win32"), true);
+	// A different file is still refused on Windows, and a known volume id still has to match.
+	assert.equal(sameOpenedFile({ dev: 0, ino: 42 }, { dev: 2384917313, ino: 43 }, "win32"), false);
+	assert.equal(sameOpenedFile({ dev: 7, ino: 42 }, { dev: 2384917313, ino: 42 }, "win32"), false);
+	// POSIX keeps the full device and inode check.
+	assert.equal(sameOpenedFile({ dev: 0, ino: 42 }, { dev: 2384917313, ino: 42 }, "linux"), false);
+	assert.equal(sameOpenedFile({ dev: 66, ino: 42 }, { dev: 66, ino: 42 }, "darwin"), true);
+});