gentle-pi 3.2.0 → 3.3.0

package/tests/double-esc-cancel-policy.test.ts

@@ -0,0 +1,194 @@
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test, { after } from "node:test";
+import {
+	DOUBLE_ESC_CANCEL_FILE,
+	DOUBLE_ESC_CANCEL_SCHEMA,
+	DOUBLE_ESC_CANCEL_WINDOW_MS,
+	loadDoubleEscCancelPolicy,
+	parseDoubleEscCancelPolicyFile,
+	resolveDoubleEscCancelPolicy,
+	writeDoubleEscCancelPolicy,
+} from "../lib/double-esc-cancel-policy.ts";
+
+// ---------------------------------------------------------------------------
+// Double-esc-cancel policy (issue #1163).
+//
+// Global-only resolver: global file > env var > default off. Mirrors the
+// resolution shape of lib/background-subagents-policy.ts minus the
+// project-file layer, since this preference is deliberately global-only
+// (see the feature scope in odd/tasks/double-esc-cancel.md). Strict schema
+// decode, fail-closed to "off" on any malformed input.
+// ---------------------------------------------------------------------------
+
+const scratchRoots: string[] = [];
+
+function makeScratch(prefix: string): string {
+	const dir = mkdtempSync(join(tmpdir(), prefix));
+	scratchRoots.push(dir);
+	return dir;
+}
+
+after(() => {
+	for (const dir of scratchRoots) rmSync(dir, { recursive: true, force: true });
+});
+
+function writePolicyFile(dir: string, policy: string): void {
+	mkdirSync(dir, { recursive: true });
+	writeFileSync(join(dir, DOUBLE_ESC_CANCEL_FILE), JSON.stringify({ schema: DOUBLE_ESC_CANCEL_SCHEMA, policy }));
+}
+
+const EMPTY_ENV = {} as Record<string, string | undefined>;
+
+test("the confirmation window is 1000ms, deliberately double Pi's own 500ms idle double-Esc window", () => {
+	assert.equal(DOUBLE_ESC_CANCEL_WINDOW_MS, 1000);
+});
+
+// --- strict decode ---------------------------------------------------------
+
+test("strict decode accepts exactly the v1 schema with policy on|off", () => {
+	assert.equal(parseDoubleEscCancelPolicyFile(`{"schema":"${DOUBLE_ESC_CANCEL_SCHEMA}","policy":"on"}`), "on");
+	assert.equal(parseDoubleEscCancelPolicyFile(`{"schema":"${DOUBLE_ESC_CANCEL_SCHEMA}","policy":"off"}`), "off");
+});
+
+test("strict decode rejects malformed shapes", () => {
+	for (const raw of [
+		"not json",
+		"[]",
+		"null",
+		'{"policy":"on"}',
+		'{"schema":"gentle-pi.double-esc-cancel/v2","policy":"on"}',
+		`{"schema":"${DOUBLE_ESC_CANCEL_SCHEMA}","policy":"ON"}`,
+		`{"schema":"${DOUBLE_ESC_CANCEL_SCHEMA}","policy":true}`,
+		`{"schema":"${DOUBLE_ESC_CANCEL_SCHEMA}","policy":"on","extra":1}`,
+	]) {
+		assert.equal(parseDoubleEscCancelPolicyFile(raw), undefined, `must reject: ${raw}`);
+	}
+});
+
+// --- cascade: global file > env > default off -------------------------------
+
+test("default is off with no file and no env", () => {
+	const configHome = join(makeScratch("gp-esc-home-"), "gentle-ai");
+	assert.equal(loadDoubleEscCancelPolicy({ gentlePiConfigHome: configHome, env: EMPTY_ENV }), "off");
+});
+
+test("the resolver reads GENTLE_PI_CONFIG_HOME from the given env, never from process.env", () => {
+	const root = makeScratch("gp-esc-envhome-");
+	writePolicyFile(root, "on");
+	const result = resolveDoubleEscCancelPolicy({ env: { GENTLE_PI_CONFIG_HOME: root } });
+	assert.equal(result.policy, "on");
+	assert.equal(result.globalFile, join(root, "double-esc-cancel.json"));
+});
+
+test("global file overrides env", () => {
+	const configHome = join(makeScratch("gp-esc-home-"), "gentle-ai");
+	writePolicyFile(configHome, "on");
+	assert.equal(
+		loadDoubleEscCancelPolicy({ gentlePiConfigHome: configHome, env: { GENTLE_PI_DOUBLE_ESC_CANCEL: "off" } }),
+		"on",
+	);
+});
+
+test("env var applies only when no policy file exists, and only exact on|off", () => {
+	const configHome = join(makeScratch("gp-esc-home-"), "gentle-ai");
+	assert.equal(
+		loadDoubleEscCancelPolicy({ gentlePiConfigHome: configHome, env: { GENTLE_PI_DOUBLE_ESC_CANCEL: "on" } }),
+		"on",
+	);
+	for (const invalid of ["1", "true", "ON", "yes", ""]) {
+		assert.equal(
+			loadDoubleEscCancelPolicy({ gentlePiConfigHome: configHome, env: { GENTLE_PI_DOUBLE_ESC_CANCEL: invalid } }),
+			"off",
+			`env value "${invalid}" must fail closed to off`,
+		);
+	}
+});
+
+test("a malformed global file fails closed to off instead of falling through to env", () => {
+	const configHome = join(makeScratch("gp-esc-home-"), "gentle-ai");
+	mkdirSync(configHome, { recursive: true });
+	writeFileSync(join(configHome, DOUBLE_ESC_CANCEL_FILE), "{malformed");
+	assert.equal(
+		loadDoubleEscCancelPolicy({ gentlePiConfigHome: configHome, env: { GENTLE_PI_DOUBLE_ESC_CANCEL: "on" } }),
+		"off",
+	);
+});
+
+// --- resolver attribution ---------------------------------------------------
+
+test("the resolver attributes the global file when it decides", () => {
+	const configHome = join(makeScratch("gp-esc-home-"), "gentle-ai");
+	writePolicyFile(configHome, "on");
+	const resolution = resolveDoubleEscCancelPolicy({ gentlePiConfigHome: configHome, env: EMPTY_ENV });
+	assert.deepEqual(resolution, {
+		policy: "on",
+		source: "global_file",
+		malformed: false,
+		globalFile: join(configHome, DOUBLE_ESC_CANCEL_FILE),
+		globalFileExists: true,
+		envValue: undefined,
+	});
+});
+
+test("the resolver attributes the environment variable when no file exists", () => {
+	const configHome = join(makeScratch("gp-esc-home-"), "gentle-ai");
+	const resolution = resolveDoubleEscCancelPolicy({
+		gentlePiConfigHome: configHome,
+		env: { GENTLE_PI_DOUBLE_ESC_CANCEL: "on" },
+	});
+	assert.equal(resolution.source, "environment");
+	assert.equal(resolution.policy, "on");
+	assert.equal(resolution.globalFileExists, false);
+});
+
+test("the resolver attributes the built-in default when nothing else decides", () => {
+	const configHome = join(makeScratch("gp-esc-home-"), "gentle-ai");
+	const resolution = resolveDoubleEscCancelPolicy({ gentlePiConfigHome: configHome, env: EMPTY_ENV });
+	assert.equal(resolution.source, "default");
+	assert.equal(resolution.policy, "off");
+	assert.equal(resolution.malformed, false);
+});
+
+test("the resolver attributes a malformed global file to that file and does not fall through", () => {
+	const configHome = join(makeScratch("gp-esc-home-"), "gentle-ai");
+	mkdirSync(configHome, { recursive: true });
+	writeFileSync(join(configHome, DOUBLE_ESC_CANCEL_FILE), "{malformed");
+	const resolution = resolveDoubleEscCancelPolicy({
+		gentlePiConfigHome: configHome,
+		env: { GENTLE_PI_DOUBLE_ESC_CANCEL: "on" },
+	});
+	assert.equal(resolution.source, "global_file");
+	assert.equal(resolution.policy, "off");
+	assert.equal(resolution.malformed, true);
+});
+
+test("loadDoubleEscCancelPolicy delegates to the resolver so the two can never disagree", () => {
+	const configHome = join(makeScratch("gp-esc-home-"), "gentle-ai");
+	writePolicyFile(configHome, "on");
+	assert.equal(
+		loadDoubleEscCancelPolicy({ gentlePiConfigHome: configHome, env: EMPTY_ENV }),
+		resolveDoubleEscCancelPolicy({ gentlePiConfigHome: configHome, env: EMPTY_ENV }).policy,
+	);
+});
+
+// --- writer -------------------------------------------------------------------
+
+test("writeDoubleEscCancelPolicy writes the strict v1 shape to the global file, creating the config home", () => {
+	const configHome = join(makeScratch("gp-esc-home-"), "gentle-ai", "nested");
+	const path = writeDoubleEscCancelPolicy("on", { gentlePiConfigHome: configHome });
+	assert.equal(path, join(configHome, DOUBLE_ESC_CANCEL_FILE));
+	assert.equal(loadDoubleEscCancelPolicy({ gentlePiConfigHome: configHome, env: EMPTY_ENV }), "on");
+});
+
+test("writeDoubleEscCancelPolicy(off) round-trips through the resolver", () => {
+	const configHome = join(makeScratch("gp-esc-home-"), "gentle-ai");
+	writeDoubleEscCancelPolicy("on", { gentlePiConfigHome: configHome });
+	writeDoubleEscCancelPolicy("off", { gentlePiConfigHome: configHome });
+	const resolution = resolveDoubleEscCancelPolicy({ gentlePiConfigHome: configHome, env: EMPTY_ENV });
+	assert.equal(resolution.policy, "off");
+	assert.equal(resolution.source, "global_file");
+	assert.equal(resolution.malformed, false);
+});