magus-cli 7.3.1 → 7.4.1

package/src/__tests__/blind/c11-cli-parse-refusal.test.ts

@@ -0,0 +1,454 @@
+/**
+ * Blind tests — contract C11 (requirement R2.7, with R2.6 for `doctor`).
+ *
+ * Written from requirements.md and architecture.md only.
+ *
+ * Every magus run is a child `bun --no-env-file src/main.tsx …` launched with
+ * HOME set to a temp dir and cwd set to a temp project (C11, and the C2
+ * correction: HOME must be set at launch, never changed at runtime). Before
+ * any magus run, ./child-run.ts proves the same env really redirects
+ * `os.homedir()`; if it does not, magus is never launched.
+ *
+ * Only side-effect-free invocations from C11 are used: `install --check`,
+ * `profile list`, `doctor` (no `--fix`). Never `upgrade`.
+ *
+ * Nothing the child prints is surfaced verbatim. Assertions compare summary
+ * objects (booleans, exit code, redacted `.json` path tokens), so no failure
+ * can echo the contents of a user file.
+ */
+import { afterAll, describe, expect, test } from "bun:test";
+import {
+	existsSync,
+	mkdirSync,
+	mkdtempSync,
+	readFileSync,
+	realpathSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { runInChild } from "./child-run.js";
+
+const MAIN = path.resolve(import.meta.dir, "../../main.tsx");
+const SPAWN_TIMEOUT = 45_000; // a child that runs longer is killed and reported as timedOut
+const T = 120_000; // per-test timeout: the first test in a block pays for guard + magus run
+
+// ---------------------------------------------------------------------------
+// temp dirs
+// ---------------------------------------------------------------------------
+
+const dirs: string[] = [];
+afterAll(() => {
+	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-c11-${tag}-`));
+	dirs.push(dir);
+	return dir;
+}
+
+function write(file: string, content: string): void {
+	mkdirSync(path.dirname(file), { recursive: true });
+	writeFileSync(file, content);
+}
+
+interface Case {
+	home: string;
+	project: string;
+	/** Both spellings of each temp dir: as created, and resolved (macOS /var -> /private/var). */
+	homeForms: string[];
+	projectForms: string[];
+}
+
+function newCase(): Case {
+	const home = tempDir("home");
+	const project = tempDir("proj");
+	const forms = (d: string) => [...new Set([d, realpathSync(d)])];
+	return {
+		home,
+		project,
+		homeForms: forms(home),
+		projectForms: forms(project),
+	};
+}
+
+// ---------------------------------------------------------------------------
+// testdata
+// ---------------------------------------------------------------------------
+
+/** Cut off mid-object: present on disk, not valid JSON. */
+const TRUNCATED_SETTINGS = '{\n  "enabledPlugins": {\n    "a@b": true,\n';
+const TRUNCATED_PROFILES =
+	'{\n  "profiles": {\n    "blind": {\n      "plugins": [\n';
+const VALID_SETTINGS = '{\n  "enabledPlugins": {}\n}\n';
+/** Minimal valid JSON. The profiles.json schema is not in the contract, so the control only needs JSON validity. */
+const VALID_PROFILES = "{}\n";
+
+// ---------------------------------------------------------------------------
+// output classification
+// ---------------------------------------------------------------------------
+
+// biome-ignore lint/suspicious/noControlCharactersInRegex: ESC is the thing being matched.
+const ANSI = /\x1b\[[0-9;?]*[A-Za-z]/g;
+const ERROR_STARTING = /Error starting magus/i;
+/** Either wording the requirements use for the refusal (R2.4 "not valid JSON", R2.7 "fix the JSON by hand"). */
+const NOT_VALID_JSON = /not valid JSON|invalid JSON|fix the JSON by hand/i;
+/** R2.7 quotes this note. */
+const FIX_BY_HAND = /fix the JSON by hand/i;
+/** Bun's source dump: `12 | const x = …`. */
+const LINE_NUMBER_PIPE = /^\s*\d+\s*\|/m;
+/** A stack frame: `    at fn (file:1:2)`. */
+const AT_FRAME = /^[ \t]{2,}at \S/m;
+/** Bun's uncaught-error banner: `Bun v1.4.0 (…)`. */
+const BUN_CRASH_BANNER = /^Bun v\d+\.\d+\.\d+/m;
+
+interface CliRun {
+	exitCode: number | null;
+	signal: string | null;
+	timedOut: boolean;
+	stdout: string;
+	stderr: string;
+}
+
+function combined(r: CliRun): string {
+	return `${r.stdout}\n${r.stderr}`;
+}
+
+function escapeRe(s: string): string {
+	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/** `.json` path tokens in the output, with temp dirs replaced by labels. Paths only — never file contents. */
+function jsonPathsSeen(text: string, c: Case): string[] {
+	const tokens = text.match(/[~\w./-]*\.json\b/g) ?? [];
+	const redact = (t: string): string => {
+		for (const d of c.homeForms)
+			if (t.startsWith(d)) return `<HOME>${t.slice(d.length)}`;
+		for (const d of c.projectForms)
+			if (t.startsWith(d)) return `<PROJECT>${t.slice(d.length)}`;
+		if (t.startsWith("/")) return `<outside-temp>/${path.basename(t)}`;
+		return t;
+	};
+	return [...new Set(tokens.map(redact))];
+}
+
+// ---------------------------------------------------------------------------
+// the damaged file, and every spelling that counts as naming it
+// ---------------------------------------------------------------------------
+
+type Damaged = "project-settings" | "profiles" | "global-settings";
+
+interface Target {
+	file: (c: Case) => string;
+	label: string;
+	truncated: string;
+	valid: string;
+	/** True when `text` names this file by an absolute path, `~/…`, or a project-relative path. */
+	named: (text: string, c: Case) => boolean;
+}
+
+function projectFile(rel: string, truncated: string, valid: string): Target {
+	// A bare relative `.claude/x.json` counts, but not when it is the tail of
+	// `~/.claude/x.json` or of another absolute path.
+	const relRe = new RegExp(`(^|[^\\w~/.-])(\\./)?${escapeRe(rel)}`, "m");
+	return {
+		file: (c) => path.join(c.project, rel),
+		label: rel,
+		truncated,
+		valid,
+		named: (text, c) =>
+			c.projectForms.some((d) => text.includes(path.join(d, rel))) ||
+			relRe.test(text),
+	};
+}
+
+const TARGETS: Record<Damaged, Target> = {
+	"project-settings": projectFile(
+		".claude/settings.json",
+		TRUNCATED_SETTINGS,
+		VALID_SETTINGS,
+	),
+	profiles: projectFile(
+		".claude/profiles.json",
+		TRUNCATED_PROFILES,
+		VALID_PROFILES,
+	),
+	"global-settings": {
+		file: (c) => path.join(c.home, ".claude", "settings.json"),
+		label: "~/.claude/settings.json",
+		truncated: TRUNCATED_SETTINGS,
+		valid: VALID_SETTINGS,
+		named: (text, c) =>
+			text.includes("~/.claude/settings.json") ||
+			c.homeForms.some((d) =>
+				text.includes(path.join(d, ".claude", "settings.json")),
+			),
+	},
+};
+
+// ---------------------------------------------------------------------------
+// running magus
+// ---------------------------------------------------------------------------
+
+function cliEnv(home: string): Record<string, string> {
+	const env: Record<string, string> = {};
+	for (const [k, v] of Object.entries(process.env)) {
+		if (v === undefined) continue;
+		// Nothing inherited may point magus at real config or a real project.
+		if (
+			k === "CLAUDE_CONFIG_DIR" ||
+			k === "CLAUDE_PROJECT_DIR" ||
+			k === "FORCE_COLOR"
+		)
+			continue;
+		if (k.startsWith("MAGUS_")) continue;
+		env[k] = v;
+	}
+	env.HOME = home;
+	env.CLAUDE_CONFIG_DIR = path.join(home, ".claude");
+	env.XDG_CONFIG_HOME = path.join(home, ".config");
+	env.NO_COLOR = "1";
+	return env;
+}
+
+/** Proves HOME set at launch redirects `os.homedir()` in a child bun for this case. Throws if not. */
+function guardHome(c: Case): void {
+	const r = runInChild({
+		home: c.home,
+		cwd: c.project,
+		body: 'await out({ stage: "done", ok: true });',
+	});
+	if (r.stage !== "done") {
+		throw new Error(
+			`HOME guard failed (stage ${r.stage}): magus was not launched`,
+		);
+	}
+}
+
+function runMagus(c: Case, args: string[]): CliRun {
+	guardHome(c);
+	const proc = Bun.spawnSync(
+		[process.execPath, "--no-env-file", MAIN, ...args],
+		{
+			cwd: c.project,
+			env: cliEnv(c.home),
+			stdin: "ignore",
+			stdout: "pipe",
+			stderr: "pipe",
+			timeout: SPAWN_TIMEOUT,
+		},
+	);
+	const timedOut =
+		(proc as { exitedDueToTimeout?: boolean }).exitedDueToTimeout === true ||
+		proc.exitCode === null;
+	return {
+		exitCode: proc.exitCode,
+		signal: (proc as { signalCode?: string | null }).signalCode ?? null,
+		timedOut,
+		stdout: proc.stdout.toString().replace(ANSI, ""),
+		stderr: proc.stderr.toString().replace(ANSI, ""),
+	};
+}
+
+function once<V>(fn: () => V): () => V {
+	let memo: { v: V } | undefined;
+	return () => {
+		memo ??= { v: fn() };
+		return memo.v;
+	};
+}
+
+// ---------------------------------------------------------------------------
+// scenarios
+// ---------------------------------------------------------------------------
+
+interface Scenario {
+	name: string;
+	args: string[];
+	damaged: Damaged;
+	/** R2.6: doctor reports the file and exits normally; exit 1 is not asserted for it. */
+	isDoctor: boolean;
+}
+
+const SCENARIOS: Scenario[] = [
+	{
+		name: "(a) no .claude/profiles.json, truncated .claude/settings.json — `install --check`",
+		args: ["install", "--check"],
+		damaged: "project-settings",
+		isDoctor: false,
+	},
+	{
+		name: "(b) truncated .claude/profiles.json — `profile list`",
+		args: ["profile", "list"],
+		damaged: "profiles",
+		isDoctor: false,
+	},
+	{
+		name: "(b) truncated .claude/profiles.json — `install --check`",
+		args: ["install", "--check"],
+		damaged: "profiles",
+		isDoctor: false,
+	},
+	{
+		name: "(c) truncated global ~/.claude/settings.json (temp HOME) — `doctor`",
+		args: ["doctor"],
+		damaged: "global-settings",
+		isDoctor: true,
+	},
+];
+
+describe("C11 — child-process harness", () => {
+	test(
+		"R2.7 control: a child bun launched with the test env reports os.homedir() as 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,
+	);
+
+	test("R2.7 control: the CLI entry point named by C11 exists", () => {
+		expect(existsSync(MAIN)).toBe(true);
+	});
+});
+
+for (const s of SCENARIOS) {
+	const target = TARGETS[s.damaged];
+	const cmd = `magus ${s.args.join(" ")}`;
+
+	describe(`C11 — ${s.name}`, () => {
+		const damaged = once(() => {
+			const c = newCase();
+			const file = target.file(c);
+			write(file, target.truncated);
+			const before = readFileSync(file);
+			const run = runMagus(c, s.args);
+			const after = existsSync(file) ? readFileSync(file) : null;
+			return { c, run, before, after };
+		});
+
+		if (s.isDoctor) {
+			test(
+				`R2.7 ${cmd} with ${target.label} truncated does not crash with "Error starting magus"`,
+				() => {
+					const { run } = damaged();
+					expect({
+						timedOut: run.timedOut,
+						exitedOnItsOwn: run.exitCode !== null && run.signal === null,
+						printsErrorStartingMagus: ERROR_STARTING.test(combined(run)),
+					}).toEqual({
+						timedOut: false,
+						exitedOnItsOwn: true,
+						printsErrorStartingMagus: false,
+					});
+				},
+				T,
+			);
+		} else {
+			test(
+				`R2.7 ${cmd} with ${target.label} truncated exits 1`,
+				() => {
+					const { run } = damaged();
+					expect({ exitCode: run.exitCode, timedOut: run.timedOut }).toEqual({
+						exitCode: 1,
+						timedOut: false,
+					});
+				},
+				T,
+			);
+		}
+
+		test(
+			`R2.7 ${cmd} with ${target.label} truncated names the damaged file's path`,
+			() => {
+				const { c, run } = damaged();
+				const text = combined(run);
+				expect({
+					namesDamagedFile: target.named(text, c),
+					jsonPathsSeen: jsonPathsSeen(text, c),
+				}).toMatchObject({ namesDamagedFile: true });
+			},
+			T,
+		);
+
+		test(
+			`R2.7 ${cmd} with ${target.label} truncated prints no "Error starting magus" and no stack or source dump`,
+			() => {
+				const { run } = damaged();
+				const text = combined(run);
+				expect({
+					printsErrorStartingMagus: ERROR_STARTING.test(text),
+					lineNumberPipeSourceDump: LINE_NUMBER_PIPE.test(text),
+					stackFrameAtLine: AT_FRAME.test(text),
+					bunCrashBanner: BUN_CRASH_BANNER.test(text),
+				}).toEqual({
+					printsErrorStartingMagus: false,
+					lineNumberPipeSourceDump: false,
+					stackFrameAtLine: false,
+					bunCrashBanner: false,
+				});
+			},
+			T,
+		);
+
+		test(
+			`R2.7 ${cmd} leaves the truncated ${target.label} byte-identical`,
+			() => {
+				const { before, after } = damaged();
+				expect({
+					stillExists: after !== null,
+					byteIdentical: after?.equals(before) === true,
+				}).toEqual({ stillExists: true, byteIdentical: true });
+			},
+			T,
+		);
+
+		if (s.isDoctor) {
+			test(
+				`R2.7 ${cmd} with ${target.label} truncated says the file is not valid JSON`,
+				() => {
+					const { run } = damaged();
+					expect({
+						saysNotValidJson: NOT_VALID_JSON.test(combined(run)),
+					}).toEqual({ saysNotValidJson: true });
+				},
+				T,
+			);
+		} else {
+			test(
+				`R2.7 ${cmd} with ${target.label} truncated prints the "fix the JSON by hand" note on stderr`,
+				() => {
+					const { run } = damaged();
+					expect({
+						fixByHandNoteOnStderr: FIX_BY_HAND.test(run.stderr),
+					}).toEqual({
+						fixByHandNoteOnStderr: true,
+					});
+				},
+				T,
+			);
+		}
+
+		test(
+			`R2.7 control: ${cmd} with a valid ${target.label} does not print the not-valid-JSON message`,
+			() => {
+				const c = newCase();
+				write(target.file(c), target.valid);
+				const run = runMagus(c, s.args);
+				expect({
+					timedOut: run.timedOut,
+					printsNotValidJson: NOT_VALID_JSON.test(combined(run)),
+				}).toEqual({ timedOut: false, printsNotValidJson: false });
+			},
+			T,
+		);
+	});
+}