magus-cli 7.3.1 → 7.4.0

package/src/__tests__/blind/c13-wrong-shape.test.ts

@@ -0,0 +1,603 @@
+/**
+ * Blind tests — contract C13 (requirement R2.8: wrong-SHAPE files).
+ *
+ * Written from requirements.md and architecture.md only.
+ *
+ * A file that parses as JSON but whose top level is not a plain object, or a
+ * profiles file whose `profiles` is not a map of objects, must be refused
+ * exactly like an unparseable one: `SettingsParseError` naming the file, and
+ * every write fails leaving the file byte-for-byte unchanged.
+ *
+ * Isolation: `readSettingsFile(path)` takes an explicit path, so it runs in
+ * this process. Everything from claude-settings / manifest / profiles runs in
+ * a child `bun` with a temp HOME (architecture.md C2 correction; see
+ * ./child-run.ts) — `enablePlugin` and `readProfiles` could otherwise reach
+ * the real `~/.claude`. The child reports booleans and class names only,
+ * never a value read from a file and never an error message.
+ */
+import { afterEach, describe, expect, test } from "bun:test";
+import { randomUUID } from "node:crypto";
+import {
+	existsSync,
+	mkdirSync,
+	mkdtempSync,
+	readFileSync,
+	realpathSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { type ChildResult, runInChild } from "./child-run.js";
+
+const SERVICES = path.resolve(import.meta.dir, "../../services");
+const CLAUDE_SETTINGS = path.join(SERVICES, "claude-settings.ts");
+const SETTINGS_FILE = path.join(SERVICES, "settings-file.ts");
+const MANIFEST = path.join(SERVICES, "manifest.ts");
+const PROFILES = path.join(SERVICES, "profiles.ts");
+const T = 30_000; // per-test timeout: most tests spawn one child bun
+
+const loadSettingsFile = () => import("../../services/settings-file.js");
+
+const dirs: string[] = [];
+afterEach(() => {
+	for (const dir of dirs.splice(0))
+		rmSync(dir, { recursive: true, force: true });
+});
+
+function tempDir(tag: string): string {
+	// realpath: on macOS tmpdir is /var/… → /private/var/…; one spelling only.
+	const dir = realpathSync(
+		mkdtempSync(path.join(os.tmpdir(), `magus-blind-c13-${tag}-`)),
+	);
+	dirs.push(dir);
+	return dir;
+}
+
+function write(file: string, content: string): void {
+	mkdirSync(path.dirname(file), { recursive: true });
+	writeFileSync(file, content);
+}
+
+/** R2.8.1: top levels that parse but are not a JSON object. */
+const NOT_AN_OBJECT: Record<string, string> = {
+	null: "null\n",
+	"an empty array []": "[]\n",
+	'an array ["x"]': '["x"]\n',
+	"a number 5": "5\n",
+	'a string "text"': '"text"\n',
+	"a boolean true": "true\n",
+};
+
+/** R2.8.1 + R2.8.2: profiles files that must be refused. */
+const BAD_PROFILES: Record<string, string> = {
+	'a typo\'d key ("profile" instead of "profiles")': `${JSON.stringify({
+		version: 2,
+		profile: { lean: { name: "Lean" } },
+	})}\n`,
+	"profiles is a number": `${JSON.stringify({ version: 2, profiles: 5 })}\n`,
+	"a profile value that is a string": `${JSON.stringify({
+		version: 2,
+		profiles: { lean: "oops" },
+	})}\n`,
+	"a top-level array": "[]\n",
+	"a top-level null": "null\n",
+	"profiles is an array": `${JSON.stringify({ version: 2, profiles: [] })}\n`,
+};
+
+// ── child calls ─────────────────────────────────────────────────────────────
+
+/**
+ * Child body: call `mod[job.call](...job.args)` and report a summary.
+ * Success: shape booleans and counts only. Failure: whether the error is a
+ * SettingsParseError (by name, by prototype chain, or by instanceof the
+ * exported class) and whether its message names `job.file` — never the
+ * message itself.
+ */
+const CALL_BODY = `
+const fs = await import("node:fs");
+const real = (p) => { try { return fs.realpathSync(p); } catch { return null; } };
+const classes = [];
+for (const m of job.errorModules || []) {
+	try {
+		const x = await import(m);
+		if (typeof x.SettingsParseError === "function") classes.push(x.SettingsParseError);
+	} catch {}
+}
+if (mod && typeof mod.SettingsParseError === "function") classes.push(mod.SettingsParseError);
+try {
+	const value = await mod[job.call](...job.args);
+	const isObj = value !== null && typeof value === "object" && !Array.isArray(value);
+	const profiles = isObj ? value.profiles : undefined;
+	const profilesIsObject = profiles !== null && typeof profiles === "object" && !Array.isArray(profiles);
+	const key = job.profileKey;
+	await out({
+		stage: "done",
+		ok: true,
+		isPlainObject: isObj,
+		keyCount: isObj ? Object.keys(value).length : null,
+		profilesIsObject,
+		profileCount: profilesIsObject ? Object.keys(profiles).length : null,
+		hasProfileKey: !!key && profilesIsObject && Object.prototype.hasOwnProperty.call(profiles, key),
+		profileNameMatches: !!key && profilesIsObject && profiles[key] != null && profiles[key].name === job.profileName,
+	});
+} catch (e) {
+	const isErr = e instanceof Error;
+	const chain = [];
+	for (let p = e !== null && typeof e === "object" ? Object.getPrototypeOf(e) : null; p; p = Object.getPrototypeOf(p)) {
+		const c = Object.prototype.hasOwnProperty.call(p, "constructor") ? p.constructor : null;
+		if (c && typeof c.name === "string") chain.push(c.name);
+	}
+	const msg = isErr && typeof e.message === "string" ? e.message : "";
+	const want = job.file ? real(job.file) : null;
+	await out({
+		stage: "done",
+		ok: false,
+		isError: isErr,
+		errorName: isErr ? String(e.name) : typeof e,
+		nameIsSettingsParseError: isErr && e.name === "SettingsParseError",
+		chainHasSettingsParseError: chain.includes("SettingsParseError"),
+		instanceOfSettingsParseError: classes.some((C) => e instanceof C),
+		messageNamesFile: !!job.file && (msg.includes(job.file) || (!!want && msg.includes(want))),
+		messageSaysObject: /object/i.test(msg),
+	});
+}
+`;
+
+interface Case {
+	home: string;
+	project: string;
+}
+
+function newCase(): Case {
+	return { home: tempDir("home"), project: tempDir("proj") };
+}
+
+function call(
+	c: Case,
+	module: string,
+	fn: string,
+	args: unknown[],
+	extra: { file?: string; profileKey?: string; profileName?: string } = {},
+): ChildResult {
+	return runInChild({
+		home: c.home,
+		cwd: c.project,
+		module,
+		job: {
+			call: fn,
+			args,
+			errorModules: [SETTINGS_FILE, CLAUDE_SETTINGS],
+			...extra,
+		},
+		body: CALL_BODY,
+	});
+}
+
+/** The refusal R2.8 asks for, reduced to what a test asserts on. */
+function refusal(r: ChildResult) {
+	return {
+		stage: r.stage,
+		ok: r.ok,
+		settingsParseError:
+			r.nameIsSettingsParseError === true ||
+			r.chainHasSettingsParseError === true ||
+			r.instanceOfSettingsParseError === true,
+		messageNamesFile: r.messageNamesFile,
+		// Diagnostic only (e.g. a raw TypeError, R2.8.4). Not asserted.
+		errorName: r.errorName,
+	};
+}
+
+const REFUSED = {
+	stage: "done",
+	ok: false,
+	settingsParseError: true,
+	messageNamesFile: true,
+};
+
+// ── readSettingsFile (in-process: explicit path, no HOME) ───────────────────
+
+describe("C13 — readSettingsFile(settingsPath)", () => {
+	const isSettingsParseError = (e: unknown, cls: unknown): boolean => {
+		if (typeof cls === "function" && e instanceof cls) return true;
+		if (!(e instanceof Error)) return false;
+		if (e.name === "SettingsParseError") return true;
+		for (let p = Object.getPrototypeOf(e); p; p = Object.getPrototypeOf(p)) {
+			if (p.constructor?.name === "SettingsParseError") return true;
+		}
+		return false;
+	};
+
+	for (const [shape, content] of Object.entries(NOT_AN_OBJECT)) {
+		test(`R2.8.1 a top level that is ${shape} throws SettingsParseError naming the file`, async () => {
+			const mod = await loadSettingsFile();
+			const file = path.join(tempDir("sf"), "settings.json");
+			write(file, content);
+			let caught: unknown = null;
+			let value: unknown;
+			try {
+				value = await mod.readSettingsFile(file);
+			} catch (e) {
+				caught = e;
+			}
+			expect(value).toBeUndefined();
+			expect(isSettingsParseError(caught, mod.SettingsParseError)).toBe(true);
+			expect(String((caught as Error).message)).toContain(file);
+		});
+	}
+
+	test("R2.8.1 the refusal says the file is not a JSON object", async () => {
+		const mod = await loadSettingsFile();
+		const file = path.join(tempDir("sf"), "settings.json");
+		write(file, "[]\n");
+		const err = await mod.readSettingsFile(file).then(
+			() => null,
+			(e: unknown) => e,
+		);
+		expect(err).toBeInstanceOf(Error);
+		expect(String((err as Error).message)).toMatch(/object/i);
+	});
+
+	test("R2.8.1 the SettingsParseError carries the file's path", async () => {
+		const mod = await loadSettingsFile();
+		const file = path.join(tempDir("sf"), "settings.json");
+		write(file, "5\n");
+		const err = await mod.readSettingsFile(file).then(
+			() => null,
+			(e: unknown) => e,
+		);
+		expect((err as { path?: unknown } | null)?.path).toBe(file);
+	});
+
+	test("R2.8.1 control: {} stays valid and reads as {}", async () => {
+		const mod = await loadSettingsFile();
+		const file = path.join(tempDir("sf"), "settings.json");
+		write(file, "{}\n");
+		expect(await mod.readSettingsFile(file)).toEqual({});
+	});
+
+	test("R2.8.1 control: a missing file reads as {}", async () => {
+		const mod = await loadSettingsFile();
+		const file = path.join(tempDir("sf"), "absent", "settings.json");
+		expect(await mod.readSettingsFile(file)).toEqual({});
+	});
+
+	test("R2.8.1 control: a whitespace-only file reads as {}", async () => {
+		const mod = await loadSettingsFile();
+		const file = path.join(tempDir("sf"), "settings.json");
+		write(file, "  \n\t\n");
+		expect(await mod.readSettingsFile(file)).toEqual({});
+	});
+});
+
+// ── the four settings readers (child process, temp HOME) ────────────────────
+
+interface Reader {
+	name: string;
+	call: string;
+	args: (c: Case) => unknown[];
+	file: (c: Case) => string;
+}
+
+const READERS: Reader[] = [
+	{
+		name: "readSettings (<project>/.claude/settings.json)",
+		call: "readSettings",
+		args: (c) => [c.project],
+		file: (c) => path.join(c.project, ".claude", "settings.json"),
+	},
+	{
+		name: "readLocalSettings (<project>/.claude/settings.local.json)",
+		call: "readLocalSettings",
+		args: (c) => [c.project],
+		file: (c) => path.join(c.project, ".claude", "settings.local.json"),
+	},
+	{
+		name: "readMcpConfig (<project>/.mcp.json)",
+		call: "readMcpConfig",
+		args: (c) => [c.project],
+		file: (c) => path.join(c.project, ".mcp.json"),
+	},
+	{
+		name: "readGlobalSettings (<HOME>/.claude/settings.json, temp HOME)",
+		call: "readGlobalSettings",
+		args: () => [],
+		file: (c) => path.join(c.home, ".claude", "settings.json"),
+	},
+];
+
+for (const reader of READERS) {
+	describe(`C13 — ${reader.name}`, () => {
+		for (const [shape, content] of Object.entries(NOT_AN_OBJECT)) {
+			test(
+				`R2.8.1 a top level that is ${shape} is refused with SettingsParseError naming the file`,
+				() => {
+					const c = newCase();
+					const file = reader.file(c);
+					write(file, content);
+					const r = call(c, CLAUDE_SETTINGS, reader.call, reader.args(c), {
+						file,
+					});
+					expect(refusal(r)).toMatchObject(REFUSED);
+				},
+				T,
+			);
+		}
+
+		test(
+			"R2.8.1 the refusal says the file is not a JSON object",
+			() => {
+				const c = newCase();
+				const file = reader.file(c);
+				write(file, '["x"]\n');
+				const r = call(c, CLAUDE_SETTINGS, reader.call, reader.args(c), {
+					file,
+				});
+				expect(r).toMatchObject({
+					stage: "done",
+					ok: false,
+					messageSaysObject: true,
+				});
+			},
+			T,
+		);
+
+		test(
+			"R2.8.1 control: {} stays valid and reads as {}",
+			() => {
+				const c = newCase();
+				write(reader.file(c), "{}\n");
+				expect(
+					call(c, CLAUDE_SETTINGS, reader.call, reader.args(c)),
+				).toMatchObject({
+					stage: "done",
+					ok: true,
+					isPlainObject: true,
+					keyCount: 0,
+				});
+			},
+			T,
+		);
+	});
+}
+
+// ── enablePlugin: never "success with the change dropped" ───────────────────
+
+describe("C13 — enablePlugin on a wrong-shape <project>/.claude/settings.json", () => {
+	const PLUGIN = "demo@magus-blind";
+	const settingsFile = (c: Case) =>
+		path.join(c.project, ".claude", "settings.json");
+
+	for (const [shape, content] of Object.entries(NOT_AN_OBJECT)) {
+		test(
+			`R2.8.3 enablePlugin rejects when the top level is ${shape}, with SettingsParseError naming the file`,
+			() => {
+				const c = newCase();
+				const file = settingsFile(c);
+				write(file, content);
+				const r = call(
+					c,
+					CLAUDE_SETTINGS,
+					"enablePlugin",
+					[PLUGIN, true, c.project],
+					{ file },
+				);
+				expect(refusal(r)).toMatchObject(REFUSED);
+			},
+			T,
+		);
+
+		test(
+			`R2.8.3 enablePlugin leaves a settings.json whose top level is ${shape} byte-for-byte unchanged`,
+			() => {
+				const c = newCase();
+				const file = settingsFile(c);
+				write(file, content);
+				const before = readFileSync(file);
+				const r = call(c, CLAUDE_SETTINGS, "enablePlugin", [
+					PLUGIN,
+					true,
+					c.project,
+				]);
+				expect(r.stage).toBe("done");
+				expect(readFileSync(file).equals(before)).toBe(true);
+			},
+			T,
+		);
+	}
+
+	test(
+		"R2.8.3 control: enablePlugin on {} succeeds and records the plugin",
+		() => {
+			const c = newCase();
+			const file = settingsFile(c);
+			write(file, "{}\n");
+			expect(
+				call(c, CLAUDE_SETTINGS, "enablePlugin", [PLUGIN, true, c.project]),
+			).toMatchObject({ stage: "done", ok: true });
+			// This test's own temp testdata — safe to read here.
+			const after = JSON.parse(readFileSync(file, "utf8"));
+			expect(after.enabledPlugins?.[PLUGIN]).toBe(true);
+		},
+		T,
+	);
+});
+
+// ── profiles.json: readManifest, readProfiles("project"), writeManifest ─────
+
+describe("C13 — <project>/.claude/profiles.json", () => {
+	const profilesFile = (c: Case) =>
+		path.join(c.project, ".claude", "profiles.json");
+
+	const readersOf = (c: Case) => [
+		{
+			label: "readManifest",
+			module: MANIFEST,
+			fn: "readManifest",
+			args: [c.project],
+		},
+		{
+			label: 'readProfiles("project")',
+			module: PROFILES,
+			fn: "readProfiles",
+			args: ["project", c.project],
+		},
+	];
+
+	for (const [shape, content] of Object.entries(BAD_PROFILES)) {
+		for (const which of ["readManifest", 'readProfiles("project")']) {
+			test(
+				`R2.8.2 ${which} refuses a profiles file with ${shape}, with SettingsParseError naming the file`,
+				() => {
+					const c = newCase();
+					const file = profilesFile(c);
+					write(file, content);
+					const r = readersOf(c).find((x) => x.label === which);
+					if (!r) throw new Error(`no reader ${which}`);
+					expect(
+						refusal(call(c, r.module, r.fn, r.args, { file })),
+					).toMatchObject(REFUSED);
+				},
+				T,
+			);
+		}
+
+		test(
+			`R2.8.3 writeManifest rejects over a profiles file with ${shape}, with SettingsParseError naming the file`,
+			() => {
+				const c = newCase();
+				const file = profilesFile(c);
+				write(file, content);
+				const r = call(
+					c,
+					MANIFEST,
+					"writeManifest",
+					[{ version: 2, profiles: {} }, c.project],
+					{ file },
+				);
+				expect(refusal(r)).toMatchObject(REFUSED);
+			},
+			T,
+		);
+
+		test(
+			`R2.8.3 writeManifest leaves a profiles file with ${shape} byte-for-byte unchanged`,
+			() => {
+				const c = newCase();
+				const file = profilesFile(c);
+				write(file, content);
+				const before = readFileSync(file);
+				const r = call(c, MANIFEST, "writeManifest", [
+					{ version: 2, profiles: {} },
+					c.project,
+				]);
+				expect(r.stage).toBe("done");
+				expect(readFileSync(file).equals(before)).toBe(true);
+			},
+			T,
+		);
+	}
+
+	for (const [label, content] of [
+		["{}", "{}\n"],
+		['{"version": 2}', `${JSON.stringify({ version: 2 })}\n`],
+	] as const) {
+		for (const which of ["readManifest", 'readProfiles("project")']) {
+			test(
+				`R2.8.2 control: ${which} reads ${label} as zero profiles`,
+				() => {
+					const c = newCase();
+					write(profilesFile(c), content);
+					const r = readersOf(c).find((x) => x.label === which);
+					if (!r) throw new Error(`no reader ${which}`);
+					expect(call(c, r.module, r.fn, r.args)).toMatchObject({
+						stage: "done",
+						ok: true,
+						profilesIsObject: true,
+						profileCount: 0,
+					});
+				},
+				T,
+			);
+		}
+	}
+
+	for (const which of ["readManifest", 'readProfiles("project")']) {
+		test(
+			`R2.8.2 control: ${which} reads a valid manifest's one profile (identified by a random key)`,
+			() => {
+				const c = newCase();
+				const key = `blind-${randomUUID().slice(0, 8)}`;
+				write(
+					profilesFile(c),
+					JSON.stringify(
+						{
+							version: 2,
+							profiles: {
+								[key]: { name: "Lean", plugins: { "dev@magus": true } },
+							},
+						},
+						null,
+						2,
+					),
+				);
+				const r = readersOf(c).find((x) => x.label === which);
+				if (!r) throw new Error(`no reader ${which}`);
+				expect(
+					call(c, r.module, r.fn, r.args, {
+						profileKey: key,
+						profileName: "Lean",
+					}),
+				).toMatchObject({
+					stage: "done",
+					ok: true,
+					profileCount: 1,
+					hasProfileKey: true,
+					profileNameMatches: true,
+				});
+			},
+			T,
+		);
+	}
+
+	test(
+		"R2.8.3 control: writeManifest over {} succeeds and writes the manifest",
+		() => {
+			// Proves the refusals above are refusals, not a writeManifest that
+			// always fails.
+			const c = newCase();
+			const file = profilesFile(c);
+			write(file, "{}\n");
+			const key = `blind-${randomUUID().slice(0, 8)}`;
+			expect(
+				call(c, MANIFEST, "writeManifest", [
+					{ version: 2, profiles: { [key]: { name: "Lean" } } },
+					c.project,
+				]),
+			).toMatchObject({ stage: "done", ok: true });
+			const after = JSON.parse(readFileSync(file, "utf8"));
+			expect(after.profiles?.[key]?.name).toBe("Lean");
+		},
+		T,
+	);
+
+	test(
+		"R2.8.3 control: writeManifest with no profiles file creates it",
+		() => {
+			const c = newCase();
+			const file = profilesFile(c);
+			expect(existsSync(file)).toBe(false);
+			const key = `blind-${randomUUID().slice(0, 8)}`;
+			expect(
+				call(c, MANIFEST, "writeManifest", [
+					{ version: 2, profiles: { [key]: { name: "Lean" } } },
+					c.project,
+				]),
+			).toMatchObject({ stage: "done", ok: true });
+			const after = JSON.parse(readFileSync(file, "utf8"));
+			expect(after.profiles?.[key]?.name).toBe("Lean");
+		},
+		T,
+	);
+});