magus-cli 7.3.1 → 7.4.0

package/src/__tests__/blind/c16-nested-wrong-shape.test.ts

@@ -0,0 +1,297 @@
+/**
+ * Blind tests — requirement R2.8.5 (wrong shape ONE LEVEL DOWN), through
+ * contracts C2 and C13.
+ *
+ * Written from requirements.md and architecture.md only.
+ *
+ * R2.8.5: when `enabledPlugins` (a map magus writes an entry into) is present
+ * but is not a JSON object — `[]`, `["dev@magus"]`, `null`, a string, a
+ * number — `enablePlugin` must refuse the write with a `SettingsParseError`-
+ * class error naming the file AND the key, and leave the file byte-identical.
+ * It must never report success while `JSON.stringify` silently drops the
+ * entry (an array with a string property serialises as the bare array).
+ *
+ * Controls prove the refusals are refusals and not an `enablePlugin` that
+ * always fails: `{"enabledPlugins": {}}` and a file with no `enabledPlugins`
+ * key both resolve, record the entry, and keep every other top-level key.
+ *
+ * Isolation: `enablePlugin` lives in claude-settings, which can resolve
+ * `~/.claude`, so every call runs in a child `bun` with a temp HOME
+ * (architecture.md C2 correction; see ./child-run.ts). The child reports
+ * booleans and class names only — never an error message or a value read from
+ * a file. The settings files read back here are this test's own temp testdata.
+ */
+import { afterEach, describe, expect, test } from "bun:test";
+import {
+	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 T = 30_000; // per-test timeout: each test spawns one child bun
+
+const PLUGIN = "dev@magus";
+const KEY = "enabledPlugins";
+
+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-c16-${tag}-`)),
+	);
+	dirs.push(dir);
+	return dir;
+}
+
+interface Case {
+	home: string;
+	project: string;
+	/** <project>/.claude/settings.json — the file enablePlugin writes. */
+	file: string;
+}
+
+function newCase(content: string): Case {
+	const home = tempDir("home");
+	const project = tempDir("proj");
+	const file = path.join(project, ".claude", "settings.json");
+	mkdirSync(path.dirname(file), { recursive: true });
+	writeFileSync(file, content);
+	return { home, project, file };
+}
+
+// ── the child call ──────────────────────────────────────────────────────────
+
+/**
+ * Child body: `await mod.enablePlugin(...job.args)`.
+ * Success → `{ ok: true }`. Failure → whether the error is a
+ * SettingsParseError (by name, by a constructor named SettingsParseError on
+ * its prototype chain — i.e. a subclass — or by instanceof an exported
+ * class), and whether its message names the file and the key. The message
+ * itself is never reported.
+ */
+const ENABLE_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 {}
+}
+try {
+	await mod.enablePlugin(...job.args);
+	await out({ stage: "done", ok: true });
+} 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 = real(job.file);
+	const errPath = isErr && typeof e.path === "string" ? e.path : 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: msg.includes(job.file) || (!!want && msg.includes(want)),
+		messageNamesKey: msg.includes(job.key),
+		pathIsFile: errPath !== null && (errPath === job.file || (!!want && real(errPath) === want)),
+	});
+}
+`;
+
+function enable(c: Case, enabled: boolean): ChildResult {
+	return runInChild({
+		home: c.home,
+		cwd: c.project,
+		module: CLAUDE_SETTINGS,
+		job: {
+			args: [PLUGIN, enabled, c.project],
+			file: c.file,
+			key: KEY,
+			errorModules: [SETTINGS_FILE, CLAUDE_SETTINGS],
+		},
+		body: ENABLE_BODY,
+	});
+}
+
+/** The refusal R2.8.5 asks for, reduced to what the tests assert 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,
+		messageNamesKey: r.messageNamesKey,
+		// Diagnostic only (e.g. a raw TypeError, R2.8.4). Not asserted.
+		errorName: r.errorName,
+	};
+}
+
+// ── wrong shapes: refused, for enabled = true AND enabled = false ───────────
+
+/** R2.8.5: `enabledPlugins` present but not a JSON object. */
+const WRONG_SHAPES: Record<string, string> = {
+	"an empty array []": '{"enabledPlugins": []}\n',
+	'an array ["dev@magus"]': '{"enabledPlugins": ["dev@magus"]}\n',
+	null: '{"enabledPlugins": null}\n',
+	'a string "dev@magus"': '{"enabledPlugins": "dev@magus"}\n',
+	"a number 5": '{"enabledPlugins": 5}\n',
+};
+
+describe("C16 — enablePlugin when <project>/.claude/settings.json has a wrong-shape enabledPlugins", () => {
+	for (const [shape, content] of Object.entries(WRONG_SHAPES)) {
+		for (const enabled of [true, false]) {
+			const call = `enablePlugin("${PLUGIN}", ${enabled})`;
+
+			test(
+				`R2.8.5 ${call} rejects when enabledPlugins is ${shape}, with a SettingsParseError-class error, and never resolves`,
+				() => {
+					const c = newCase(content);
+					expect(refusal(enable(c, enabled))).toMatchObject({
+						stage: "done",
+						ok: false,
+						settingsParseError: true,
+					});
+				},
+				T,
+			);
+
+			test(
+				`R2.8.5 ${call} on enabledPlugins = ${shape}: the error message names the file and the key "enabledPlugins"`,
+				() => {
+					const c = newCase(content);
+					expect(refusal(enable(c, enabled))).toMatchObject({
+						stage: "done",
+						ok: false,
+						messageNamesFile: true,
+						messageNamesKey: true,
+					});
+				},
+				T,
+			);
+
+			test(
+				`R2.8.5 ${call} leaves a settings.json whose enabledPlugins is ${shape} byte-identical`,
+				() => {
+					const c = newCase(content);
+					const before = readFileSync(c.file);
+					const r = enable(c, enabled);
+					expect(r.stage).toBe("done");
+					expect(readFileSync(c.file).equals(before)).toBe(true);
+				},
+				T,
+			);
+		}
+	}
+
+	test(
+		"R2.8.5 the refusal's path property is the settings file (C2: SettingsParseError carries path)",
+		() => {
+			const c = newCase(WRONG_SHAPES["an empty array []"] as string);
+			expect(enable(c, true)).toMatchObject({
+				stage: "done",
+				ok: false,
+				pathIsFile: true,
+			});
+		},
+		T,
+	);
+});
+
+// ── controls: a well-shaped map, or no key at all, is written normally ──────
+
+/** Top-level keys that must survive the read-modify-write untouched. */
+const OTHER_KEYS = {
+	blindMarker: [1, "two", null, { three: 3 }],
+	permissions: { allow: ["Bash(ls:*)"] },
+	includeCoAuthoredBy: false,
+};
+
+const CONTROLS: Record<string, Record<string, unknown>> = {
+	'{"enabledPlugins": {}}': { enabledPlugins: {}, ...OTHER_KEYS },
+	"a file without the enabledPlugins key": { ...OTHER_KEYS },
+};
+
+function readBack(c: Case): Record<string, unknown> {
+	// This test's own temp testdata — safe to read.
+	return JSON.parse(readFileSync(c.file, "utf8")) as Record<string, unknown>;
+}
+
+describe("C16 — enablePlugin controls (well-shaped or absent enabledPlugins)", () => {
+	for (const [label, settings] of Object.entries(CONTROLS)) {
+		const content = `${JSON.stringify(settings, null, 2)}\n`;
+
+		test(
+			`R2.8.5 control: enablePlugin("${PLUGIN}", true) on ${label} resolves and records enabledPlugins["${PLUGIN}"] === true`,
+			() => {
+				const c = newCase(content);
+				expect(enable(c, true)).toMatchObject({ stage: "done", ok: true });
+				const after = readBack(c);
+				const map = after[KEY] as Record<string, unknown> | undefined;
+				expect(map?.[PLUGIN]).toBe(true);
+			},
+			T,
+		);
+
+		test(
+			`R2.8.5 control: enablePlugin("${PLUGIN}", true) on ${label} preserves the other top-level keys`,
+			() => {
+				const c = newCase(content);
+				expect(enable(c, true)).toMatchObject({ stage: "done", ok: true });
+				const after = readBack(c);
+				for (const [k, v] of Object.entries(OTHER_KEYS)) {
+					expect(after[k]).toEqual(v);
+				}
+			},
+			T,
+		);
+
+		test(
+			`R2.8.5 control: enablePlugin("${PLUGIN}", false) on ${label} resolves and records enabledPlugins["${PLUGIN}"] === false`,
+			() => {
+				const c = newCase(content);
+				expect(enable(c, false)).toMatchObject({ stage: "done", ok: true });
+				const map = readBack(c)[KEY] as Record<string, unknown> | undefined;
+				expect(map?.[PLUGIN]).toBe(false);
+			},
+			T,
+		);
+	}
+
+	test(
+		"R2.8.5 control: another plugin's existing enabledPlugins entry is kept",
+		() => {
+			const c = newCase(
+				`${JSON.stringify({ enabledPlugins: { "other@blind": true } }, null, 2)}\n`,
+			);
+			expect(enable(c, true)).toMatchObject({ stage: "done", ok: true });
+			expect(readBack(c)[KEY]).toEqual({ "other@blind": true, [PLUGIN]: true });
+		},
+		T,
+	);
+});