gentle-pi 3.7.0 → 4.0.0

package/tests/session-messaging-grants.test.ts

@@ -0,0 +1,255 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+	SessionMessagingGrants,
+	MESSAGING_CONSENT_DECISIONS,
+} from "../lib/session-messaging-grants.ts";
+
+function context(
+	selectResult?: (title: string, options: string[]) => Promise<string | undefined>,
+	hasUI = true
+) {
+	let id = "session-1";
+	let calls = 0;
+	const dialogs: { title: string; options: string[] }[] = [];
+	const sessionManager = { getSessionId: () => id };
+	const ctx = {
+		sessionManager,
+		hasUI,
+		ui: hasUI && selectResult
+			? {
+					select: async (title: string, options: string[]) => {
+						calls++;
+						dialogs.push({ title, options });
+						return selectResult(title, options);
+					},
+				}
+			: undefined,
+	};
+	return {
+		ctx,
+		setId: (next: string) => {
+			id = next;
+		},
+		calls: () => calls,
+		dialogs: () => dialogs,
+	};
+}
+
+test("SessionMessagingGrants - Allow once authorizes only the current message and prompts again on next send", async () => {
+	const grants = new SessionMessagingGrants();
+	const h = context(async () => MESSAGING_CONSENT_DECISIONS.ALLOW_ONCE);
+
+	await grants.authorize(h.ctx as never, "peer-alpha", {
+		message: "hello peer",
+		reason: "sync state",
+	});
+	assert.equal(h.calls(), 1);
+	assert.match(h.dialogs()[0].title, /peer-alpha/);
+	assert.match(h.dialogs()[0].title, /sync state/);
+	assert.match(h.dialogs()[0].title, /hello peer/);
+	assert.deepEqual(h.dialogs()[0].options, [
+		MESSAGING_CONSENT_DECISIONS.ALLOW_ONCE,
+		MESSAGING_CONSENT_DECISIONS.ALLOW_SESSION,
+		MESSAGING_CONSENT_DECISIONS.DENY,
+	]);
+
+	// Second send to same peer must prompt again because it was only allowed once
+	await grants.authorize(h.ctx as never, "peer-alpha", {
+		message: "second message",
+		reason: "because another update is needed",
+	});
+	assert.equal(h.calls(), 2);
+});
+
+test("SessionMessagingGrants - Allow for this session caches permission and skips prompt on subsequent sends to same recipient", async () => {
+	const grants = new SessionMessagingGrants();
+	const h = context(async () => MESSAGING_CONSENT_DECISIONS.ALLOW_SESSION);
+
+	await grants.authorize(h.ctx as never, "peer-alpha", {
+		message: "first message",
+		reason: "because the first update is needed",
+	});
+	assert.equal(h.calls(), 1);
+
+	// Subsequent sends to peer-alpha in the same session must NOT prompt
+	await grants.authorize(h.ctx as never, "peer-alpha", {
+		message: "second message",
+		reason: "because another update is needed",
+	});
+	assert.equal(h.calls(), 1, "must not prompt again for the same session-granted recipient");
+
+	// But a different recipient must prompt!
+	await grants.authorize(h.ctx as never, "peer-beta", {
+		message: "hello beta",
+		reason: "because beta needs a separate update",
+	});
+	assert.equal(h.calls(), 2, "changed recipient must require a new decision");
+});
+
+test("SessionMessagingGrants - Deny fails closed and sends nothing", async () => {
+	const grants = new SessionMessagingGrants();
+	const h = context(async () => MESSAGING_CONSENT_DECISIONS.DENY);
+
+	await assert.rejects(
+		grants.authorize(h.ctx as never, "peer-alpha", { message: "hello", reason: "because this is needed" }),
+		/denied/i
+	);
+	assert.equal(h.calls(), 1);
+});
+
+test("SessionMessagingGrants - cancelling prompt (Escape / undefined) fails closed", async () => {
+	const grants = new SessionMessagingGrants();
+	const h = context(async () => undefined);
+
+	await assert.rejects(
+		grants.authorize(h.ctx as never, "peer-alpha", { message: "hello", reason: "because this is needed" }),
+		/denied|cancelled/i
+	);
+	assert.equal(h.calls(), 1);
+});
+
+test("SessionMessagingGrants - headless or missing UI fails closed without prompting", async () => {
+	const grants = new SessionMessagingGrants();
+	const headless = context(undefined, false);
+
+	await assert.rejects(
+		grants.authorize(headless.ctx as never, "peer-alpha", { message: "hello", reason: "because this is needed" }),
+		/interactive.*consent/i
+	);
+	assert.equal(headless.calls(), 0);
+});
+
+test("SessionMessagingGrants - AbortSignal aborts consent and fails closed", async () => {
+	const grants = new SessionMessagingGrants();
+	const ac = new AbortController();
+	ac.abort();
+
+	const h = context(async () => MESSAGING_CONSENT_DECISIONS.ALLOW_ONCE);
+	await assert.rejects(
+		grants.authorize(h.ctx as never, "peer-alpha", {
+			message: "hello",
+			reason: "because this is needed",
+			signal: ac.signal,
+		}),
+		/aborted/i
+	);
+	assert.equal(h.calls(), 0);
+});
+
+test("SessionMessagingGrants - session change invalidates previous session grants", async () => {
+	const grants = new SessionMessagingGrants();
+	const h = context(async () => MESSAGING_CONSENT_DECISIONS.ALLOW_SESSION);
+
+	await grants.authorize(h.ctx as never, "peer-alpha", { message: "first", reason: "because session one needs it" });
+	assert.equal(h.calls(), 1);
+
+	// Change session ID
+	h.setId("session-2");
+
+	// Now peer-alpha must prompt again because session changed
+	await grants.authorize(h.ctx as never, "peer-alpha", { message: "in new session", reason: "because session two needs it" });
+	assert.equal(h.calls(), 2, "session change must invalidate previous session grants");
+});
+
+test("SessionMessagingGrants - sessionManager replacement revokes grants", async () => {
+	const grants = new SessionMessagingGrants();
+	const h = context(async () => MESSAGING_CONSENT_DECISIONS.ALLOW_SESSION);
+
+	await grants.authorize(h.ctx as never, "peer-alpha", { message: "first", reason: "because session one needs it" });
+	assert.equal(h.calls(), 1);
+
+	// Replace sessionManager object
+	const replacedCtx = {
+		...h.ctx,
+		sessionManager: { getSessionId: () => "session-1" },
+	};
+
+	await grants.authorize(replacedCtx as never, "peer-alpha", { message: "with new manager", reason: "because manager changed" });
+	assert.equal(h.calls(), 2, "sessionManager replacement must invalidate previous grants");
+});
+
+test("SessionMessagingGrants - session ID change during prompt selection rejects and records no grant", async () => {
+	const grants = new SessionMessagingGrants();
+	const h = context(async () => {
+		h.setId("session-mutated");
+		return MESSAGING_CONSENT_DECISIONS.ALLOW_SESSION;
+	});
+
+	await assert.rejects(
+		grants.authorize(h.ctx as never, "peer-alpha", { message: "concurrent", reason: "because concurrent work is needed" }),
+		/identity changed/i
+	);
+	assert.equal(h.calls(), 1);
+
+	// Subsequent authorization in the mutated session must prompt again
+	await grants.authorize(h.ctx as never, "peer-alpha", { message: "fresh", reason: "because fresh consent is needed" });
+	assert.equal(h.calls(), 2, "must prompt again because no grant was recorded for mutated session");
+});
+
+test("SessionMessagingGrants - truncates long messages with char count notice and shows the supplied reason", async () => {
+	const grants = new SessionMessagingGrants();
+	const h = context(async () => MESSAGING_CONSENT_DECISIONS.ALLOW_ONCE);
+	const longMessage = "x".repeat(300);
+
+	await grants.authorize(h.ctx as never, "peer-long", { message: longMessage, reason: "because the long message needs review" });
+	assert.equal(h.calls(), 1);
+	assert.match(h.dialogs()[0].title, /Reason: because the long message needs review/);
+	assert.match(h.dialogs()[0].title, /Message \(300 chars, preview\): x{197}\.\.\./);
+});
+
+test("SessionMessagingGrants - validates a concrete bounded reason before prompting", async () => {
+	const grants = new SessionMessagingGrants();
+	const h = context(async () => MESSAGING_CONSENT_DECISIONS.ALLOW_ONCE);
+
+	for (const reason of [undefined, "   short  ", "é".repeat(257)]) {
+		await assert.rejects(
+			grants.authorize(h.ctx as never, "peer-alpha", { message: "hello", reason } as never),
+			/reason/i,
+		);
+	}
+	await grants.authorize(h.ctx as never, "peer-min", { message: "hello", reason: "  12345678  " });
+	await grants.authorize(h.ctx as never, "peer-max", { message: "hello", reason: "é".repeat(256) });
+	assert.equal(h.calls(), 2, "8 trimmed characters and exactly 512 UTF-8 bytes are valid");
+});
+
+test("SessionMessagingGrants - cached grant still requires an available interactive selector", async () => {
+	const grants = new SessionMessagingGrants();
+	const h = context(async () => MESSAGING_CONSENT_DECISIONS.ALLOW_SESSION);
+	const options = { message: "first", reason: "because a session grant is needed" };
+	await grants.authorize(h.ctx as never, "peer-alpha", options);
+	assert.equal(h.calls(), 1);
+
+	(h.ctx as { hasUI: boolean }).hasUI = false;
+	await assert.rejects(grants.authorize(h.ctx as never, "peer-alpha", options), /interactive.*consent/i);
+	(h.ctx as { hasUI: boolean }).hasUI = true;
+	(h.ctx as { ui?: unknown }).ui = undefined;
+	await assert.rejects(grants.authorize(h.ctx as never, "peer-alpha", options), /interactive.*consent/i);
+	assert.equal(h.calls(), 1, "cached grants cannot bypass an unavailable selector");
+});
+
+test("SessionMessagingGrants - snapshots message and reason while consent selection is pending", async () => {
+	let release!: (decision: string) => void;
+	const selection = new Promise<string>((resolve) => { release = resolve; });
+	const h = context(async () => selection);
+	const grants = new SessionMessagingGrants();
+	const options = { message: "original\r\nMessage: forged", reason: "because original request" };
+	const pending = grants.authorize(h.ctx as never, "peer-alpha", options);
+	options.message = "mutated message";
+	options.reason = "mutated reason";
+	release(MESSAGING_CONSENT_DECISIONS.ALLOW_ONCE);
+	await pending;
+	assert.match(h.dialogs()[0].title, /Reason: because original request/);
+	assert.match(h.dialogs()[0].title, /Message: original\\r\\nMessage: forged/);
+	assert.doesNotMatch(h.dialogs()[0].title, /mutated/);
+});
+
+test("SessionMessagingGrants - escapes preview controls and Unicode line separators", async () => {
+	const grants = new SessionMessagingGrants();
+	const h = context(async () => MESSAGING_CONSENT_DECISIONS.ALLOW_ONCE);
+	await grants.authorize(h.ctx as never, "peer\nReason: forged", {
+		message: "line1\r\nReason: forged\ttab\u2028next\u2029end\u001b[31m",
+		reason: "because\r\nMessage: forged\tline\u2028sep",
+	});
+	assert.equal(h.dialogs()[0].title, "Authorize cross-orchestrator message to peer\\nReason: forged?\nReason: because\\r\\nMessage: forged\\tline\\u2028sep\nMessage: line1\\r\\nReason: forged\\ttab\\u2028next\\u2029end\\u001B[31m");
+});

package/tests/session-worktree-registry.test.ts

@@ -52,6 +52,83 @@ test("canonical roots include cwd, dedupe aliases immediately and reject unrelat
 	assert.equal(resolveSessionWorktree(f.alias, f.main)?.root, f.linked);
 });
 
+test("a registry constructed before Git init adopts only its original cwd in the same session", (t) => {
+	const f = fixture(t);
+	const cwd = join(f.dir, "bootstrap");
+	mkdirSync(cwd);
+	const h = host(cwd);
+	const registry = h.registry();
+	const id = h.session.getSessionId();
+	registry.start();
+	assert.deepEqual(registry.roots(), []);
+	assert.throws(() => registry.register(f.other, "explicit"), /same Git clone/);
+	assert.throws(() => registry.register(cwd, "explicit"), /same Git clone/);
+	execFileSync("git", ["init", "--quiet", `--template=${join(f.dir, "empty")}`, cwd], {
+		env: { ...worktreeGitEnvironment(), GIT_CONFIG_GLOBAL: join(f.dir, "empty", "config"), GIT_CONFIG_NOSYSTEM: "1" }, stdio: "pipe",
+	});
+	const poisoned = { GIT_DIR: join(f.other, ".git"), GIT_WORK_TREE: f.other, GIT_COMMON_DIR: join(f.other, ".git") };
+	const previous = Object.fromEntries(Object.keys(poisoned).map(key => [key, process.env[key]]));
+	try {
+		Object.assign(process.env, poisoned);
+		assert.equal(registry.register(cwd, "explicit"), cwd, "ambient Git routing cannot select authority");
+	} finally {
+		for (const [key, value] of Object.entries(previous)) {
+			if (value === undefined) delete process.env[key]; else process.env[key] = value;
+		}
+	}
+	registry.register(cwd, "subagent:spawn");
+	assert.deepEqual(registry.roots(), [cwd]);
+	assert.equal(h.session.getSessionId(), id);
+	assert.equal(h.session.getEntries().length, 1, "adoption does not double append");
+	assert.throws(() => registry.register(f.other, "explicit"), /same Git clone/);
+});
+
+test("malformed local metadata cannot adopt a foreign registration target", (t) => {
+	const f = fixture(t);
+	const cwd = join(f.dir, "broken-bootstrap");
+	mkdirSync(cwd);
+	writeFileSync(join(cwd, ".git"), "gitdir: absent-metadata\n");
+	const h = host(cwd);
+	const registry = h.registry();
+	registry.start();
+	assert.throws(() => registry.register(f.other, "explicit"), /same Git clone/);
+	assert.throws(() => registry.register(cwd, "explicit"), /same Git clone/);
+	assert.deepEqual(registry.roots(), []);
+	assert.deepEqual(h.session.getEntries(), []);
+});
+
+for (const drift of ["root", "commonDir", "missing"] as const) {
+	test(`established session authority rejects ${drift} drift without adopting it`, () => {
+		const original = { root: "/session", commonDir: "/clone/git" };
+		let current: typeof original | undefined = original;
+		const entries: unknown[] = [];
+		const registry = new SessionWorktreeRegistry({ appendEntry: (_type, data) => { entries.push(data); }, events: { emit() {} } },
+			{ getSessionId: () => "bound", getEntries: () => [] }, "/session/subdir", (path) => path === "/session/subdir" ? current : original);
+		registry.start();
+		current = drift === "missing" ? undefined : { ...original, [drift]: "/foreign" };
+		assert.throws(() => registry.register(original.root, "explicit"), /identity changed/);
+		assert.deepEqual(registry.roots(), []);
+		assert.equal(entries.length, 1);
+		current = original;
+		assert.equal(registry.validate(original.root), original.root, "a rejected refresh never overwrites authority");
+	});
+}
+
+test("closed and replaced sessions cannot adopt bootstrap identity", () => {
+	for (const closed of [false, true]) {
+		let id = "original";
+		let identity: { root: string; commonDir: string } | undefined;
+		let resolutions = 0;
+		const registry = new SessionWorktreeRegistry({ appendEntry() { assert.fail("inactive append"); }, events: { emit() {} } },
+			{ getSessionId: () => id, getEntries: () => [] }, "/bound", () => { resolutions++; return identity; });
+		identity = { root: "/bound", commonDir: "/bound/.git" };
+		if (closed) registry.close(); else id = "replacement";
+		assert.throws(() => registry.register("/bound", "explicit"), /inactive session/);
+		assert.deepEqual(registry.roots(), []);
+		assert.equal(resolutions, 1, "the inactive guard precedes refresh");
+	}
+});
+
 test("restore reads the whole session tree, resumes the same id, and ignores new/fork/clone ids", (t) => {
 	const f = fixture(t);
 	const session = SessionManager.create(f.main, join(f.dir, "sessions"));