gentle-pi 3.4.0 → 3.5.0

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

@@ -0,0 +1,99 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+// isPiManagedInstall gates the POSTINSTALL entry point only (scripts/install-gentle-ai.mjs):
+// it decides whether the running gentle-pi package sits under a directory
+// pattern Pi's own package manager creates (npm-backed or git-backed), so an
+// `npm install -g gentle-pi`, a plain development git checkout, or an npx
+// cache directory never writes to the user's global Pi settings. It is
+// deliberately unrelated to installTuiModeSetting's own ownership check
+// (which compares the package location against one specific resolved agent
+// home) and to installIsolatedTuiModeSetting (gentle-shell's own bootstrap of
+// a directory it just created), covered in the other two test files.
+
+const helperUrl = new URL("../scripts/install-tui-mode-setting.mjs", import.meta.url);
+const { isPiManagedInstall } = await import(helperUrl.href);
+
+test("isPiManagedInstall recognizes the user-scope npm-managed layout", () => {
+	assert.equal(isPiManagedInstall(join("/home/alan", ".pi", "agent", "npm", "node_modules", "gentle-pi")), true);
+});
+
+test("isPiManagedInstall recognizes the project-scope npm-managed layout", () => {
+	assert.equal(isPiManagedInstall(join("/repo", ".pi", "npm", "node_modules", "gentle-pi")), true);
+});
+
+test("isPiManagedInstall recognizes Pi's git-managed layout", () => {
+	assert.equal(isPiManagedInstall(join("/home/alan", ".pi", "agent", "git", "github.com", "Gentleman-Programming", "gentle-pi")), true);
+});
+
+test("isPiManagedInstall rejects a global npm -g install", () => {
+	assert.equal(isPiManagedInstall("/usr/local/lib/node_modules/gentle-pi"), false);
+});
+
+test("isPiManagedInstall rejects a plain development git checkout", () => {
+	assert.equal(isPiManagedInstall("/Users/alan/work/gentle-pi"), false);
+});
+
+test("isPiManagedInstall rejects an npx cache directory", () => {
+	assert.equal(isPiManagedInstall(join("/home/alan", ".npm", "_npx", "abc123", "node_modules", "gentle-pi")), false);
+});
+
+test("isPiManagedInstall rejects a pnpm content-addressable store", () => {
+	assert.equal(isPiManagedInstall(join("/home/alan", ".pnpm", "gentle-pi@1.0.0", "node_modules", "gentle-pi")), false);
+});
+
+test("isPiManagedInstall resolves a relative path before checking", () => {
+	const cwd = process.cwd();
+	try {
+		process.chdir(join("/tmp"));
+		assert.equal(isPiManagedInstall(join(".", "npm", "node_modules", "gentle-pi")), true);
+	} finally {
+		process.chdir(cwd);
+	}
+});
+
+// --- postinstall entry integration --------------------------------------------
+
+function fixture(t: test.TestContext, packageSegments: readonly string[]) {
+	const root = mkdtempSync(join(tmpdir(), "gentle-pi-guard-"));
+	t.after(() => rmSync(root, { recursive: true, force: true }));
+	const home = join(root, "agent");
+	const packageRoot = join(home, ...packageSegments);
+	const scripts = join(packageRoot, "scripts");
+	mkdirSync(scripts, { recursive: true });
+	copyFileSync(helperUrl, join(scripts, "install-tui-mode-setting.mjs"));
+	copyFileSync(new URL("../scripts/install-gentle-ai.mjs", import.meta.url), join(scripts, "install-gentle-ai.mjs"));
+	writeFileSync(
+		join(scripts, "gentle-ai-installer.mjs"),
+		'export const INSTALLER_VERSION = "test"; export async function installGentleAi() { return { installed: true, binaryPath: "fixture" }; }',
+	);
+	const settings = join(home, "settings.json");
+	const env = { ...process.env, GENTLE_PI_AGENT_HOME: home, GENTLE_PI_SKIP_GENTLE_AI_INSTALL: "0" };
+	return { root, home, packageRoot, scripts, settings, env };
+}
+
+test("postinstall skips the global settings write outside a pi-managed install", (t) => {
+	const f = fixture(t, ["node_modules", "gentle-pi"]);
+	const result = spawnSync(process.execPath, [join(f.scripts, "install-gentle-ai.mjs")], { encoding: "utf8", env: f.env });
+	assert.equal(result.status, 0, result.stderr);
+	assert.match(`${result.stdout}${result.stderr}`, /skip/i);
+	assert.equal(existsSync(f.settings), false);
+});
+
+test("postinstall still writes fullscreen for a pi-managed npm install", (t) => {
+	const f = fixture(t, ["npm", "node_modules", "gentle-pi"]);
+	const result = spawnSync(process.execPath, [join(f.scripts, "install-gentle-ai.mjs")], { encoding: "utf8", env: f.env });
+	assert.equal(result.status, 0, result.stderr);
+	assert.equal(JSON.parse(readFileSync(f.settings, "utf8")).tuiMode, "fullscreen");
+});
+
+test("postinstall still writes fullscreen for a pi-managed git install", (t) => {
+	const f = fixture(t, ["git", "github.com", "Gentleman-Programming", "gentle-pi"]);
+	const result = spawnSync(process.execPath, [join(f.scripts, "install-gentle-ai.mjs")], { encoding: "utf8", env: f.env });
+	assert.equal(result.status, 0, result.stderr);
+	assert.equal(JSON.parse(readFileSync(f.settings, "utf8")).tuiMode, "fullscreen");
+});

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

@@ -7,7 +7,7 @@ import { join } from "node:path";
 import { test } from "node:test";
 
 const helperUrl = new URL("../scripts/install-tui-mode-setting.mjs", import.meta.url);
-const { installTuiModeSetting } = await import(helperUrl.href);
+const { installTuiModeSetting, installIsolatedTuiModeSetting } = await import(helperUrl.href);
 
 function fixture(t: { after(fn: () => void): void }, packagePath: readonly string[] = ["npm", "node_modules", "gentle-pi"]) {
 	const root = mkdtempSync(join(tmpdir(), "gentle-tui-test-"));
@@ -269,6 +269,44 @@ for (const fault of ["write", "rename", "concurrent-change"]) {
 	});
 }
 
+// --- installIsolatedTuiModeSetting -------------------------------------------
+// gentle-shell's own isolated-home bootstrap (T2): unlike installTuiModeSetting,
+// there is no "physically installed under this home's npm/node_modules"
+// ownership check to satisfy, because gentle-shell just created `dir` itself
+// moments ago; a plain agent-home-shaped temp directory is enough.
+
+test("installIsolatedTuiModeSetting writes fullscreen into a freshly created directory", async (t) => {
+	const root = mkdtempSync(join(tmpdir(), "gentle-shell-isolated-"));
+	t.after(() => rmSync(root, { recursive: true, force: true }));
+	const dir = join(root, "gentle-shell", "agent");
+	mkdirSync(dir, { recursive: true });
+	assert.deepEqual(await installIsolatedTuiModeSetting(dir), { changed: true, recognized: true });
+	assert.deepEqual(JSON.parse(readFileSync(join(dir, "settings.json"), "utf8")), { tuiMode: "fullscreen" });
+});
+
+test("installIsolatedTuiModeSetting preserves other settings fields already present", async (t) => {
+	const root = mkdtempSync(join(tmpdir(), "gentle-shell-isolated-"));
+	t.after(() => rmSync(root, { recursive: true, force: true }));
+	writeFileSync(join(root, "settings.json"), JSON.stringify({ tuiMode: "regular", theme: "rose" }));
+	assert.deepEqual(await installIsolatedTuiModeSetting(root), { changed: true, recognized: true });
+	assert.deepEqual(JSON.parse(readFileSync(join(root, "settings.json"), "utf8")), { tuiMode: "fullscreen", theme: "rose" });
+});
+
+test("installIsolatedTuiModeSetting is a no-op when already fullscreen", async (t) => {
+	const root = mkdtempSync(join(tmpdir(), "gentle-shell-isolated-"));
+	t.after(() => rmSync(root, { recursive: true, force: true }));
+	writeFileSync(join(root, "settings.json"), JSON.stringify({ tuiMode: "fullscreen" }));
+	const before = lstatSync(join(root, "settings.json"));
+	assert.deepEqual(await installIsolatedTuiModeSetting(root), { changed: false, recognized: true });
+	assert.equal(lstatSync(join(root, "settings.json")).ino, before.ino);
+});
+
+test("installIsolatedTuiModeSetting rejects a missing directory", async (t) => {
+	const root = mkdtempSync(join(tmpdir(), "gentle-shell-isolated-"));
+	t.after(() => rmSync(root, { recursive: true, force: true }));
+	await assert.rejects(installIsolatedTuiModeSetting(join(root, "absent")));
+});
+
 type PostinstallRoute = "skip" | "success" | "failure";
 
 function writePostinstallFixture(f: ReturnType<typeof fixture>, route: PostinstallRoute) {

package/tests/package-manifest.test.ts

@@ -1563,9 +1563,9 @@ test("pi-pretty wrapper uses cached ESM loading for compiled and pnpm symlink in
 	assert.match(wrapper, /quietToolsEnabled/);
 });
 
-test("Gentle Shell v3.4.0 package and runtime stop before publication", () => {
+test("Gentle Shell v3.5.0 package and runtime stop before publication", () => {
 	const packageJson = readPackageJson();
-	assert.equal(packageJson.version, "3.4.0", "the release manifest must remain explicitly pinned to v3.4.0");
+	assert.equal(packageJson.version, "3.5.0", "the release manifest must remain explicitly pinned to v3.5.0");
 	assert.equal(
 		packageJson.scripts?.test,
 		"node --experimental-strip-types --test tests/*.test.ts && pnpm run check:provider-contract && pnpm run test:harness",

package/tests/rpc-host.test.ts

@@ -0,0 +1,77 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+	INTERACTIVE_HOST_ENV,
+	isInteractiveMode,
+	isInteractiveRpcHost,
+	withoutInteractiveHost,
+} from "../lib/rpc-host.ts";
+
+// Interactive host signal: the desktop app sets GENTLE_SHELL_INTERACTIVE_HOST=1
+// on the pi process it spawns directly (`--mode rpc`). Subagent children
+// spawned by lib/agents-runner.ts must never see it, so rpc without the
+// variable stays byte-identical to today's headless behaviour.
+
+test("isInteractiveRpcHost is true only for rpc mode with the variable set to \"1\"", () => {
+	assert.equal(isInteractiveRpcHost("rpc", { [INTERACTIVE_HOST_ENV]: "1" }), true);
+});
+
+test("isInteractiveRpcHost is false for rpc mode without the variable", () => {
+	assert.equal(isInteractiveRpcHost("rpc", {}), false);
+});
+
+test("isInteractiveRpcHost is false for rpc mode when the variable is not exactly \"1\"", () => {
+	assert.equal(isInteractiveRpcHost("rpc", { [INTERACTIVE_HOST_ENV]: "true" }), false);
+	assert.equal(isInteractiveRpcHost("rpc", { [INTERACTIVE_HOST_ENV]: "0" }), false);
+	assert.equal(isInteractiveRpcHost("rpc", { [INTERACTIVE_HOST_ENV]: "" }), false);
+});
+
+test("isInteractiveRpcHost is false for every non-rpc mode even with the variable set", () => {
+	for (const mode of ["tui", "print", "json"]) {
+		assert.equal(isInteractiveRpcHost(mode, { [INTERACTIVE_HOST_ENV]: "1" }), false, `mode ${mode}`);
+	}
+});
+
+test("isInteractiveRpcHost defaults to process.env when no env is supplied", (t) => {
+	const previous = process.env[INTERACTIVE_HOST_ENV];
+	process.env[INTERACTIVE_HOST_ENV] = "1";
+	t.after(() => {
+		if (previous === undefined) delete process.env[INTERACTIVE_HOST_ENV];
+		else process.env[INTERACTIVE_HOST_ENV] = previous;
+	});
+
+	assert.equal(isInteractiveRpcHost("rpc"), true);
+});
+
+test("isInteractiveMode is true for tui regardless of the variable", () => {
+	assert.equal(isInteractiveMode("tui", {}), true);
+	assert.equal(isInteractiveMode("tui", { [INTERACTIVE_HOST_ENV]: "1" }), true);
+});
+
+test("isInteractiveMode is true for an interactive rpc host", () => {
+	assert.equal(isInteractiveMode("rpc", { [INTERACTIVE_HOST_ENV]: "1" }), true);
+});
+
+test("isInteractiveMode is false for rpc without the variable, and for print/json", () => {
+	assert.equal(isInteractiveMode("rpc", {}), false);
+	assert.equal(isInteractiveMode("print", { [INTERACTIVE_HOST_ENV]: "1" }), false);
+	assert.equal(isInteractiveMode("json", { [INTERACTIVE_HOST_ENV]: "1" }), false);
+});
+
+test("withoutInteractiveHost returns a copy without the variable, preserving the rest", () => {
+	const source = { PATH: "/bin", [INTERACTIVE_HOST_ENV]: "1", KEEP: "yes" };
+
+	const result = withoutInteractiveHost(source);
+
+	assert.deepEqual(result, { PATH: "/bin", KEEP: "yes" });
+	assert.deepEqual(source, { PATH: "/bin", [INTERACTIVE_HOST_ENV]: "1", KEEP: "yes" }, "the source env is not mutated");
+});
+
+test("withoutInteractiveHost is a no-op copy when the variable is absent", () => {
+	const source = { PATH: "/bin" };
+
+	const result = withoutInteractiveHost(source);
+
+	assert.deepEqual(result, { PATH: "/bin" });
+	assert.notEqual(result, source, "a fresh object is returned, not the same reference");
+});