magus-cli 7.7.0 → 7.9.0

package/src/__tests__/deps-adapter.test.ts

@@ -0,0 +1,191 @@
+/**
+ * The TUI's dependency flow — the one the Plugins screen runs after a plugin
+ * installs and the CLI Tools screen runs for a tool a plugin owns: probe →
+ * planDeps → one confirm listing every step → applyDepsPlan → a failure popup
+ * built from the same ApplyOutcome[] the CLI renders. PATH, HOME and the cache
+ * dir are temp dirs for the duration.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import {
+	chmodSync,
+	existsSync,
+	mkdirSync,
+	mkdtempSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { ResolvedBin } from "../types/index.js";
+import {
+	type DepsModal,
+	depsFailureReport,
+	installBinsInTui,
+} from "../ui/adapters/depsAdapter.js";
+import type { FailureReport } from "../ui/state/types.js";
+
+let root: string;
+let tools: string;
+const saved = {
+	PATH: process.env.PATH,
+	HOME: process.env.HOME,
+	XDG: process.env.XDG_CACHE_HOME,
+};
+beforeEach(() => {
+	root = mkdtempSync(join(tmpdir(), "deps-adapter-"));
+	tools = join(root, "tools");
+	mkdirSync(tools);
+	mkdirSync(join(root, "home"));
+	process.env.PATH = `${tools}:/usr/bin:/bin`;
+	process.env.HOME = join(root, "home");
+	process.env.XDG_CACHE_HOME = join(root, "cache");
+});
+afterEach(() => {
+	process.env.PATH = saved.PATH;
+	process.env.HOME = saved.HOME;
+	if (saved.XDG === undefined)
+		Reflect.deleteProperty(process.env, "XDG_CACHE_HOME");
+	else process.env.XDG_CACHE_HOME = saved.XDG;
+	rmSync(root, { recursive: true, force: true });
+});
+
+function fakeBrew(fails = false): void {
+	const brew = join(tools, "brew");
+	writeFileSync(
+		brew,
+		fails
+			? "#!/bin/sh\necho 'Error: No available formula' >&2\nexit 1\n"
+			: `#!/bin/sh\nprintf '#!/bin/sh\\nexit 0\\n' > "${tools}/$2"\nchmod 755 "${tools}/$2"\n`,
+	);
+	chmodSync(brew, 0o755);
+}
+
+const owned: ResolvedBin = {
+	name: "faketool",
+	check: ["faketool", "--version"],
+	install: [{ via: "brew", formula: "faketool" }],
+	chosen: { via: "brew", formula: "faketool" },
+	sources: ["plugin:fake@magus"],
+};
+
+function modal(answer: boolean) {
+	const seen = {
+		confirms: [] as string[],
+		loading: [] as string[],
+		reports: [] as FailureReport[],
+	};
+	const m: DepsModal = {
+		confirm: async (_title, message) => {
+			seen.confirms.push(message);
+			return answer;
+		},
+		loading: (msg) => seen.loading.push(msg),
+		hideModal: () => {},
+		failures: async (r) => {
+			seen.reports.push(r);
+		},
+	};
+	return { m, seen };
+}
+
+describe("installBinsInTui", () => {
+	test("asks once with every step, installs through the executor, and stays quiet on success", async () => {
+		fakeBrew();
+		const { m, seen } = modal(true);
+		await installBinsInTui("fake@magus", [owned], m);
+		expect(seen.confirms).toHaveLength(1);
+		expect(seen.confirms[0]).toContain(
+			"faketool: brew install faketool   (fake@magus)",
+		);
+		expect(seen.loading).toContain("Installing faketool...");
+		expect(existsSync(join(tools, "faketool"))).toBe(true);
+		expect(seen.reports).toEqual([]);
+	});
+
+	test("no means nothing runs", async () => {
+		fakeBrew();
+		const { m } = modal(false);
+		await installBinsInTui("fake@magus", [owned], m);
+		expect(existsSync(join(tools, "faketool"))).toBe(false);
+	});
+
+	test("a failed install is a popup with the installer's words and the command", async () => {
+		fakeBrew(true);
+		const { m, seen } = modal(true);
+		await installBinsInTui("fake@magus", [owned], m);
+		expect(seen.reports).toHaveLength(1);
+		const [row] = seen.reports[0]?.rows ?? [];
+		expect(row?.subject).toBe("faketool");
+		expect(row?.reason).toContain("No available formula");
+		const fix = row?.fix ?? seen.reports[0]?.fix;
+		expect(fix).toBe("brew install faketool");
+	});
+
+	test("present already: no question at all", async () => {
+		fakeBrew();
+		writeFileSync(join(tools, "faketool"), "#!/bin/sh\nexit 0\n");
+		chmodSync(join(tools, "faketool"), 0o755);
+		const { m, seen } = modal(true);
+		await installBinsInTui("fake@magus", [owned], m);
+		expect(seen.confirms).toEqual([]);
+		expect(seen.reports).toEqual([]);
+	});
+});
+
+describe("depsFailureReport", () => {
+	test("needs-password, unfixable and a PATH line each say what to do", () => {
+		const report = depsFailureReport(
+			"terminal@magus",
+			[
+				{
+					name: "tmux, zsh",
+					status: "needs-password",
+					requiredBy: [],
+					exitCode: null,
+					outputTail: "",
+					durationMs: 0,
+					remedy: "run: sudo -v   then: magus doctor --fix",
+				},
+			],
+			{
+				unfixable: [{ name: "x", why: "needs Go" }],
+				pathAdvice: [
+					{
+						prefix: "~/.bun/bin",
+						rcFile: "~/.zshrc",
+						rcLine: 'export PATH="$HOME/.bun/bin:$PATH"',
+					},
+				],
+			},
+		);
+		expect(report?.headline).toBe("3 dependencies of terminal@magus need you");
+		expect(report?.rows.map((r) => r.subject)).toEqual([
+			"tmux, zsh",
+			"x",
+			"~/.bun/bin",
+		]);
+		expect(report?.rows[0]?.fix).toBe(
+			"run: sudo -v   then: magus doctor --fix",
+		);
+	});
+
+	test("all installed and nothing else to say: no popup", () => {
+		expect(
+			depsFailureReport(
+				"p",
+				[
+					{
+						name: "a",
+						status: "installed",
+						requiredBy: [],
+						exitCode: 0,
+						outputTail: "",
+						durationMs: 1,
+					},
+				],
+				{ unfixable: [], pathAdvice: [] },
+			),
+		).toBeNull();
+	});
+});

package/src/__tests__/deps-check-hook.test.ts

@@ -0,0 +1,220 @@
+/**
+ * The SessionStart deps-check hook, run as Claude Code runs it: a child process
+ * with the hook input on stdin, `CLAUDE_PLUGIN_ROOT` set, and the label as argv.
+ * PATH, HOME and TMPDIR are temp dirs, so the result does not depend on what
+ * this machine has installed.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import {
+	chmodSync,
+	existsSync,
+	mkdirSync,
+	mkdtempSync,
+	readFileSync,
+	readdirSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+	type Requirement,
+	dedupeKey,
+} from "../shared/plugin/hooks/lib/requires-probe.js";
+
+const HOOK = join(
+	import.meta.dir,
+	"..",
+	"shared",
+	"plugin",
+	"hooks",
+	"deps-check.ts",
+);
+
+const JQ: Requirement = {
+	name: "jq",
+	check: ["jq", "--version"],
+	install: [{ via: "apt", packages: ["jq"] }],
+};
+
+let root: string;
+let bin: string;
+let tmp: string;
+beforeEach(() => {
+	root = mkdtempSync(join(tmpdir(), "deps-check-"));
+	bin = join(root, "bin");
+	tmp = join(root, "tmp");
+	mkdirSync(bin);
+	mkdirSync(tmp);
+	mkdirSync(join(root, "home"));
+	tool("apt-get");
+});
+afterEach(() => rmSync(root, { recursive: true, force: true }));
+
+function tool(name: string): void {
+	writeFileSync(join(bin, name), "#!/bin/sh\nexit 0\n");
+	chmodSync(join(bin, name), 0o755);
+}
+
+function plugin(label: string, requires: unknown): string {
+	const dir = join(root, "plugins", label);
+	mkdirSync(join(dir, ".claude-plugin"), { recursive: true });
+	writeFileSync(
+		join(dir, ".claude-plugin", "plugin.json"),
+		JSON.stringify({ name: label, requires }),
+	);
+	return dir;
+}
+
+function runHook(
+	label: string,
+	pluginRoot: string,
+	sessionId: string | null = "s-1",
+	extraInput: Record<string, unknown> = {},
+): { stdout: string; exitCode: number } {
+	const r = Bun.spawnSync(
+		[
+			process.execPath,
+			"--env-file=/dev/null",
+			"--config=/dev/null",
+			HOOK,
+			label,
+		],
+		{
+			stdin: Buffer.from(
+				JSON.stringify({
+					...(sessionId ? { session_id: sessionId } : {}),
+					...extraInput,
+				}),
+			),
+			env: {
+				PATH: bin,
+				HOME: join(root, "home"),
+				TMPDIR: tmp,
+				SHELL: "/bin/zsh",
+				CLAUDE_PLUGIN_ROOT: pluginRoot,
+			},
+		},
+	);
+	return { stdout: r.stdout.toString(), exitCode: r.exitCode };
+}
+
+const ledger = (sessionId = "s-1") => join(tmp, `magus-deps-${sessionId}`);
+
+describe("deps-check hook", () => {
+	test("healthy: prints nothing, and the ledger proves it ran", () => {
+		tool("jq");
+		const dir = plugin("dev", { schema: 1, bin: [JQ] });
+		const r = runHook("dev", dir);
+		expect(r).toEqual({ stdout: "", exitCode: 0 });
+		expect(readFileSync(join(ledger(), "seen", "dev"), "utf8")).toBe("ts");
+	});
+
+	test("missing: one systemMessage with the marker, the dep and its fix", () => {
+		const dir = plugin("dev", { schema: 1, bin: [JQ] });
+		const r = runHook("dev", dir);
+		expect(r.exitCode).toBe(0);
+		const out = JSON.parse(r.stdout) as {
+			systemMessage: string;
+			hookSpecificOutput: { hookEventName: string; additionalContext: string };
+		};
+		expect(out.systemMessage.split("\n")[0]).toBe(
+			"magus-deps · dev: missing jq.",
+		);
+		expect(out.systemMessage).toContain(
+			"Fix all: bun add -g magus-cli, then magus doctor --fix",
+		);
+		expect(out.systemMessage).toContain(
+			"jq: sudo apt-get install -y --no-install-recommends jq",
+		);
+		expect(out.hookSpecificOutput.hookEventName).toBe("SessionStart");
+		expect(readdirSync(join(ledger(), "claimed"))).toEqual([dedupeKey(JQ)]);
+	});
+
+	test("magus on PATH: the fix names magus alone", () => {
+		tool("magus");
+		const dir = plugin("dev", { schema: 1, bin: [JQ] });
+		const out = JSON.parse(runHook("dev", dir).stdout) as {
+			systemMessage: string;
+		};
+		expect(out.systemMessage).toContain("Fix all: magus doctor --fix");
+		expect(out.systemMessage).not.toContain("magus-cli");
+	});
+
+	test("the fix runs doctor against the directory the session runs in", () => {
+		tool("magus");
+		const message = (input: Record<string, unknown>, session: string) =>
+			(
+				JSON.parse(
+					runHook(
+						"dev",
+						plugin("dev", { schema: 1, bin: [JQ] }),
+						session,
+						input,
+					).stdout,
+				) as { systemMessage: string }
+			).systemMessage;
+		expect(message({ cwd: "/work/repo" }, "s-a")).toContain(
+			"Fix all: magus doctor --fix --project /work/repo\n",
+		);
+		// Quoted for the shell it is pasted into.
+		expect(message({ cwd: "/work/my repo" }, "s-b")).toContain(
+			"Fix all: magus doctor --fix --project '/work/my repo'\n",
+		);
+		// Not a directory a terminal can name: the fix is the bare command.
+		for (const [cwd, session] of [
+			["relative/dir", "s-c"],
+			["/work/a\nb", "s-d"],
+		] as const) {
+			expect(message({ cwd }, session)).toContain(
+				"Fix all: magus doctor --fix\n",
+			);
+		}
+	});
+
+	test("one identical declaration in two plugins is reported once per session", () => {
+		const first = runHook("dev", plugin("dev", { schema: 1, bin: [JQ] }));
+		const second = runHook(
+			"code-search",
+			plugin("code-search", { schema: 1, bin: [JQ] }),
+		);
+		expect(first.stdout).toContain("magus-deps · dev: missing jq");
+		expect(second.stdout).toBe("");
+		expect(readdirSync(join(ledger(), "seen")).sort()).toEqual([
+			"code-search",
+			"dev",
+		]);
+	});
+
+	test("no readable session id: no ledger, and the banner still prints", () => {
+		const dir = plugin("dev", { schema: 1, bin: [JQ] });
+		const r = runHook("dev", dir, null);
+		expect(r.stdout).toContain("magus-deps · dev: missing jq");
+		expect(existsSync(tmp) && readdirSync(tmp)).toEqual([]);
+	});
+
+	test("an invalid declaration is reported, not swallowed", () => {
+		const dir = plugin("dev", { schema: 1, bin: [{ name: "jq" }] });
+		const out = JSON.parse(runHook("dev", dir).stdout) as {
+			systemMessage: string;
+		};
+		expect(out.systemMessage).toStartWith(
+			"magus-deps · dev: requires is invalid (",
+		);
+		expect(out.systemMessage).toEndWith("— please report");
+	});
+
+	test("a ledger older than a day is pruned; a fresh one is kept", () => {
+		const old = join(tmp, "magus-deps-old");
+		const fresh = join(tmp, "magus-deps-fresh");
+		mkdirSync(old);
+		mkdirSync(fresh);
+		const twoDaysAgo = new Date(Date.now() - 2 * 24 * 60 * 60 * 1000);
+		require("node:fs").utimesSync(old, twoDaysAgo, twoDaysAgo);
+		tool("jq");
+		runHook("dev", plugin("dev", { schema: 1, bin: [JQ] }));
+		expect(existsSync(old)).toBe(false);
+		expect(existsSync(fresh)).toBe(true);
+	});
+});