magus-cli 7.8.0 → 7.9.0

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);
+	});
+});