magus-cli 7.3.1 → 7.4.1

package/src/__tests__/blind/c2-settings-parse.test.ts

@@ -0,0 +1,350 @@
+/**
+ * Blind tests — contract C2 (requirements R2.1, R2.2, R2.3).
+ *
+ * Written from requirements.md and architecture.md only.
+ *
+ * NOTHING from claude-settings runs in this process. Under Bun, a runtime
+ * HOME change does not move `os.homedir()` (architecture.md C2 correction),
+ * and this module can resolve `~/.claude` — so every call runs in a child
+ * `bun` spawned with a temp HOME (see ./child-run.ts). The child reports only
+ * booleans and names: never a value read from a file, never an error
+ * message, so no failure can print a real user file.
+ *
+ * Valid-file cases write a per-test random token into the file; the child
+ * reports whether the value it read contains that token, which proves the
+ * temp file — and not some other file — was the one read.
+ */
+import { afterEach, describe, expect, test } from "bun:test";
+import { randomUUID } from "node:crypto";
+import {
+	mkdirSync,
+	mkdtempSync,
+	readFileSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { type ChildResult, runInChild } from "./child-run.js";
+
+const MODULE = path.resolve(
+	import.meta.dir,
+	"../../services/claude-settings.ts",
+);
+const T = 30_000; // per-test timeout: each test spawns one child bun
+
+const dirs: string[] = [];
+afterEach(() => {
+	for (const dir of dirs.splice(0))
+		rmSync(dir, { recursive: true, force: true });
+});
+
+function tempDir(tag: string): string {
+	const dir = mkdtempSync(path.join(os.tmpdir(), `magus-blind-c2-${tag}-`));
+	dirs.push(dir);
+	return dir;
+}
+
+function write(file: string, content: string): void {
+	mkdirSync(path.dirname(file), { recursive: true });
+	writeFileSync(file, content);
+}
+
+/** Three distinct ways a file can exist and not be JSON. */
+const INVALID: Record<string, string> = {
+	truncated: '{\n  "enabledPlugins": {\n    "a@b": true,\n',
+	"plain text": "this is not json at all\n",
+	"trailing comma": '{ "enabledPlugins": { "a@b": true, }, }\n',
+};
+
+/**
+ * Child body: call `mod[job.call](...job.args)` and report a summary.
+ * Reports whether a value is `{}` and whether it contains `job.expect`
+ * (subset match) — never the value itself. On a throw, reports the error's
+ * class and whether it carries/names `job.file` — never its message.
+ */
+const CALL_BODY = `
+const fs = await import("node:fs");
+const real = (p) => { try { return fs.realpathSync(p); } catch { return null; } };
+const subset = (a, e) => {
+	if (e === null || typeof e !== "object") return Object.is(a, e);
+	if (a === null || typeof a !== "object") return false;
+	if (Array.isArray(e)) return Array.isArray(a) && a.length === e.length && e.every((v, i) => subset(a[i], v));
+	return Object.keys(e).every((k) => subset(a[k], e[k]));
+};
+try {
+	const value = await mod[job.call](...job.args);
+	const isObj = value !== null && typeof value === "object" && !Array.isArray(value);
+	await out({
+		stage: "done",
+		ok: true,
+		isEmptyObject: isObj && Object.keys(value).length === 0,
+		matchesExpected: job.expect === undefined ? null : subset(value, job.expect),
+	});
+} catch (e) {
+	const isErr = e instanceof Error;
+	const P = mod.SettingsParseError;
+	const want = job.file ? real(job.file) : null;
+	const msg = isErr && typeof e.message === "string" ? e.message : "";
+	const p = e && typeof e.path === "string" ? e.path : null;
+	await out({
+		stage: "done",
+		ok: false,
+		isError: isErr,
+		name: isErr ? e.name : typeof e,
+		isSettingsParseError: typeof P === "function" && e instanceof P,
+		pathIsString: p !== null,
+		pathMatchesFile: !!want && p !== null && real(p) === want,
+		messageNamesFile: !!job.file && (msg.includes(job.file) || (!!want && msg.includes(want))),
+	});
+}
+`;
+
+interface Case {
+	home: string;
+	project: string;
+}
+
+function newCase(): Case {
+	return { home: tempDir("home"), project: tempDir("proj") };
+}
+
+function call(
+	c: Case,
+	fn: string,
+	args: unknown[],
+	extra: { file?: string; expect?: unknown } = {},
+): ChildResult {
+	return runInChild({
+		home: c.home,
+		cwd: c.project,
+		module: MODULE,
+		job: { call: fn, args, ...extra },
+		body: CALL_BODY,
+	});
+}
+
+interface Reader {
+	name: string;
+	call: string;
+	args: (c: Case) => unknown[];
+	file: (c: Case) => string;
+	/** Valid content carrying `token`, and the subset the reader must return. */
+	valid: (token: string) => Record<string, unknown>;
+}
+
+const READERS: Reader[] = [
+	{
+		name: "readSettings (<project>/.claude/settings.json)",
+		call: "readSettings",
+		args: (c) => [c.project],
+		file: (c) => path.join(c.project, ".claude", "settings.json"),
+		valid: (t) => ({ enabledPlugins: { [`${t}@blind`]: true } }),
+	},
+	{
+		name: "readLocalSettings (<project>/.claude/settings.local.json)",
+		call: "readLocalSettings",
+		args: (c) => [c.project],
+		file: (c) => path.join(c.project, ".claude", "settings.local.json"),
+		valid: (t) => ({ enabledPlugins: { [`${t}@blind`]: false } }),
+	},
+	{
+		name: "readMcpConfig (<project>/.mcp.json)",
+		call: "readMcpConfig",
+		args: (c) => [c.project],
+		file: (c) => path.join(c.project, ".mcp.json"),
+		valid: (t) => ({ mcpServers: { [t]: { command: "echo", args: ["hi"] } } }),
+	},
+	{
+		name: "readGlobalSettings (<HOME>/.claude/settings.json, child process with temp HOME)",
+		call: "readGlobalSettings",
+		args: () => [],
+		file: (c) => path.join(c.home, ".claude", "settings.json"),
+		valid: (t) => ({ enabledPlugins: { [`${t}@global-blind`]: true } }),
+	},
+];
+
+describe("C2 — child-process harness", () => {
+	test(
+		"R2 control: the child's os.homedir() is the temp HOME",
+		() => {
+			const c = newCase();
+			const r = runInChild({
+				home: c.home,
+				cwd: c.project,
+				body: 'await out({ stage: "done", ok: true });',
+			});
+			expect(r).toEqual({ stage: "done", ok: true });
+		},
+		T,
+	);
+});
+
+for (const reader of READERS) {
+	describe(`C2 — ${reader.name}`, () => {
+		test(
+			"R2.1 a missing file reads as an empty object",
+			() => {
+				const c = newCase();
+				expect(call(c, reader.call, reader.args(c))).toEqual({
+					stage: "done",
+					ok: true,
+					isEmptyObject: true,
+					matchesExpected: null,
+				});
+			},
+			T,
+		);
+
+		test(
+			"R2.1 control: a valid file reads as its content (the temp file, identified by a random token)",
+			() => {
+				const c = newCase();
+				const content = reader.valid(`blind-${randomUUID()}`);
+				write(reader.file(c), JSON.stringify(content, null, 2));
+				expect(
+					call(c, reader.call, reader.args(c), { expect: content }),
+				).toMatchObject({
+					stage: "done",
+					ok: true,
+					matchesExpected: true,
+				});
+			},
+			T,
+		);
+
+		for (const [kind, content] of Object.entries(INVALID)) {
+			test(
+				`R2.2 an existing file that is not valid JSON (${kind}) throws SettingsParseError`,
+				() => {
+					const c = newCase();
+					write(reader.file(c), content);
+					expect(call(c, reader.call, reader.args(c))).toMatchObject({
+						stage: "done",
+						ok: false,
+						isError: true,
+						isSettingsParseError: true,
+					});
+				},
+				T,
+			);
+		}
+
+		test(
+			"R2.2 the SettingsParseError carries the path of the file that failed",
+			() => {
+				const c = newCase();
+				const file = reader.file(c);
+				write(file, INVALID.truncated as string);
+				// pathMatchesFile compares real paths: macOS tmpdir is /var -> /private/var.
+				expect(call(c, reader.call, reader.args(c), { file })).toMatchObject({
+					stage: "done",
+					ok: false,
+					isSettingsParseError: true,
+					pathIsString: true,
+					pathMatchesFile: true,
+				});
+			},
+			T,
+		);
+
+		test(
+			"R2.2 an existing unparseable file never reads as {}",
+			() => {
+				const c = newCase();
+				write(reader.file(c), INVALID["plain text"] as string);
+				const r = call(c, reader.call, reader.args(c));
+				expect(r.stage).toBe("done");
+				expect(r.ok).toBe(false);
+			},
+			T,
+		);
+	});
+}
+
+describe("C2 — enablePlugin read-modify-write", () => {
+	const PLUGIN = "demo@magus-blind";
+	const settingsFile = (c: Case) =>
+		path.join(c.project, ".claude", "settings.json");
+
+	test(
+		"R2.3 control: enablePlugin on a valid settings.json sets enabledPlugins[id] and keeps other keys",
+		() => {
+			const c = newCase();
+			const file = settingsFile(c);
+			write(
+				file,
+				JSON.stringify(
+					{
+						enabledPlugins: { "other@x": true },
+						permissions: { allow: ["Read"] },
+					},
+					null,
+					2,
+				),
+			);
+			expect(call(c, "enablePlugin", [PLUGIN, true, c.project])).toMatchObject({
+				stage: "done",
+				ok: true,
+			});
+			// The file is this test's temp testdata, so reading it here is safe.
+			const after = JSON.parse(readFileSync(file, "utf8"));
+			expect(after.enabledPlugins[PLUGIN]).toBe(true);
+			expect(after.enabledPlugins["other@x"]).toBe(true);
+			expect(after.permissions).toEqual({ allow: ["Read"] });
+		},
+		T,
+	);
+
+	for (const enabled of [true, false]) {
+		for (const [kind, content] of Object.entries(INVALID)) {
+			test(
+				`R2.3 enablePlugin(…, ${enabled}) fails on an unparseable settings.json (${kind})`,
+				() => {
+					const c = newCase();
+					write(settingsFile(c), content);
+					expect(
+						call(c, "enablePlugin", [PLUGIN, enabled, c.project]),
+					).toMatchObject({
+						stage: "done",
+						ok: false,
+						isError: true,
+					});
+				},
+				T,
+			);
+
+			test(
+				`R2.3 enablePlugin(…, ${enabled}) leaves an unparseable settings.json (${kind}) byte-for-byte unchanged`,
+				() => {
+					const c = newCase();
+					const file = settingsFile(c);
+					write(file, content);
+					const before = readFileSync(file);
+					const r = call(c, "enablePlugin", [PLUGIN, enabled, c.project]);
+					expect(r.stage).toBe("done");
+					expect(readFileSync(file).equals(before)).toBe(true);
+				},
+				T,
+			);
+		}
+	}
+
+	test(
+		"R2.3 the enablePlugin failure identifies the unparseable file",
+		() => {
+			// R2.4 needs the TUI to name the file, so the error that reaches it must
+			// carry the path: as a SettingsParseError, or in its message.
+			const c = newCase();
+			const file = settingsFile(c);
+			write(file, INVALID.truncated as string);
+			const r = call(c, "enablePlugin", [PLUGIN, true, c.project], { file });
+			expect(r).toMatchObject({ stage: "done", ok: false, isError: true });
+			const namesFile =
+				(r.isSettingsParseError === true && r.pathMatchesFile === true) ||
+				r.messageNamesFile === true;
+			expect(namesFile).toBe(true);
+		},
+		T,
+	);
+});