magus-cli 7.7.0 → 7.9.0

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

@@ -0,0 +1,197 @@
+/**
+ * doctor's dependency report: which plugins count (what Claude Code loads
+ * here, with or without profiles.json), how declarations merge across
+ * plugins, and the `--json` document's shape. PATH and HOME are temp dirs.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import {
+	chmodSync,
+	mkdirSync,
+	mkdtempSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { PlanEnv } from "../services/deps-plan.js";
+import {
+	type CollectSources,
+	DEPS_REPORT_SCHEMA,
+	assessDeps,
+	collectDeps,
+	depsReportJson,
+} from "../services/deps-report.js";
+import type { ParseResult } from "../shared/plugin/hooks/lib/requires-probe.js";
+import { parseRequires } from "../shared/plugin/hooks/lib/requires-probe.js";
+
+let root: string;
+let env: PlanEnv;
+beforeEach(() => {
+	root = mkdtempSync(join(tmpdir(), "deps-report-"));
+	mkdirSync(join(root, "bin"));
+	mkdirSync(join(root, "home"));
+	env = {
+		os: "linux",
+		arch: "amd64",
+		home: join(root, "home"),
+		path: join(root, "bin"),
+		userShell: "/bin/bash",
+	};
+});
+afterEach(() => rmSync(root, { recursive: true, force: true }));
+
+const JQ = {
+	name: "jq",
+	check: ["jq", "--version"],
+	install: [{ via: "apt", packages: ["jq"] }],
+};
+const BUN = {
+	name: "bun",
+	check: ["bun", "--version"],
+	install: [{ via: "bootstrap", tool: "bun" }],
+};
+const TMUX_MCP = {
+	name: "tmux-mcp",
+	check: ["tmux-mcp", "--version"],
+	install: [
+		{
+			via: "release",
+			repo: "MadAppGang/tmux-mcp",
+			tag: "v2.0.0",
+			asset: "tmux-mcp_{os}_{arch}.tar.gz",
+			binary: "tmux-mcp",
+			sha256: { linux_amd64: "a".repeat(64) },
+		},
+	],
+};
+
+const manifest = (bin: unknown[], schema = 1) => ({
+	requires: { schema, bin },
+});
+
+/** Plugins as Claude Code would load them, with no profiles.json anywhere. */
+function sources(declared: Record<string, unknown>): CollectSources {
+	return {
+		enabledPlugins: async () => Object.keys(declared),
+		pluginRequires: async (id) => {
+			const m = declared[id];
+			if (m === undefined) return null;
+			return { dir: join(root, id), parse: parseRequires(m) as ParseResult };
+		},
+		profileCliTools: async () => [],
+	};
+}
+
+describe("collectDeps", () => {
+	test("reads every enabled plugin's declaration, with no profiles.json", async () => {
+		const collected = await collectDeps(
+			root,
+			sources({
+				"dev@magus": manifest([BUN, JQ]),
+				"code-search@magus": manifest([BUN, JQ]),
+				"terminal@magus": manifest([BUN, TMUX_MCP]),
+			}),
+		);
+		expect(collected.plugins).toEqual([
+			"dev@magus",
+			"code-search@magus",
+			"terminal@magus",
+		]);
+		// Identical declarations merge: one bun, one jq, every plugin named.
+		expect(collected.bins.map((b) => [b.name, b.sources])).toEqual([
+			[
+				"bun",
+				[
+					"plugin:dev@magus",
+					"plugin:code-search@magus",
+					"plugin:terminal@magus",
+				],
+			],
+			["jq", ["plugin:dev@magus", "plugin:code-search@magus"]],
+			["tmux-mcp", ["plugin:terminal@magus"]],
+		]);
+	});
+
+	test("a declaration this magus cannot read is reported per plugin, by kind", async () => {
+		const collected = await collectDeps(
+			root,
+			sources({
+				"new@x": manifest([BUN], 2),
+				"old@x": manifest([BUN], 0),
+				"bad@x": { requires: { schema: 1, bin: [{ name: "x" }] } },
+			}),
+		);
+		expect(collected.problems.map((p) => [p.plugin, p.kind])).toEqual([
+			["new@x", "newer-schema"],
+			["old@x", "older-schema"],
+			["bad@x", "invalid"],
+		]);
+		expect(collected.bins).toEqual([]);
+	});
+});
+
+describe("depsReportJson", () => {
+	test("names tmux-mcp missing with its release install, in the schema-1 shape", async () => {
+		const state = await assessDeps(
+			root,
+			env,
+			sources({ "terminal@magus": manifest([TMUX_MCP]) }),
+		);
+		const json = depsReportJson(state, env);
+		expect(json).toEqual({
+			schema: DEPS_REPORT_SCHEMA,
+			platform: { os: "linux", arch: "amd64" },
+			magusOnPath: false,
+			plugins: ["terminal@magus"],
+			deps: [
+				{
+					name: "tmux-mcp",
+					key: expect.stringMatching(/^tmux-mcp-[0-9a-f]{12}$/),
+					status: "missing",
+					requiredBy: ["terminal@magus"],
+					fix: {
+						via: "release",
+						escalation: "none",
+						text: expect.stringContaining(
+							"curl -fsSLO https://github.com/MadAppGang/tmux-mcp/releases/download/v2.0.0/tmux-mcp_linux_amd64.tar.gz",
+						),
+						prefix: "~/.local/bin",
+						prefixOnPath: false,
+					},
+				},
+			],
+			plugins_needing_update: [],
+			invalid: [],
+			unfixable: [],
+			pathAdvice: [
+				{
+					prefix: "~/.local/bin",
+					rcFile: "~/.bashrc",
+					rcLine: 'export PATH="$HOME/.local/bin:$PATH"',
+				},
+			],
+		});
+		// One document, round-trippable.
+		expect(JSON.parse(JSON.stringify(json))).toEqual(json);
+	});
+
+	test("present is reported present, with no fix", async () => {
+		const tm = join(root, "bin", "tmux-mcp");
+		writeFileSync(tm, "#!/bin/sh\nexit 0\n");
+		chmodSync(tm, 0o755);
+		const state = await assessDeps(
+			root,
+			env,
+			sources({ "terminal@magus": manifest([TMUX_MCP]) }),
+		);
+		const [dep] = depsReportJson(state, env).deps;
+		expect(dep).toEqual({
+			name: "tmux-mcp",
+			key: expect.any(String),
+			status: "present",
+			requiredBy: ["terminal@magus"],
+		});
+		expect(state.plan.steps).toEqual([]);
+	});
+});

package/src/__tests__/doctor-bins.test.ts

@@ -1,43 +1,141 @@
-import { describe, expect, test } from "bun:test";
-import { checkBinaries, missingBinaries } from "../services/doctor-bins.js";
+/**
+ * Presence for doctor, install and profile switch goes through requires-probe's
+ * `probe` — the same function the SessionStart hook runs. PATH and HOME are
+ * pinned to temp dirs, so nothing on this machine decides an answer.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import {
+	chmodSync,
+	mkdirSync,
+	mkdtempSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { PlanEnv } from "../services/deps-plan.js";
+import {
+	checkBinaries,
+	missingBinaries,
+	probeBins,
+} from "../services/doctor-bins.js";
 import type { ResolvedBin } from "../types/index.js";
 
-const bins: ResolvedBin[] = [
-	{
-		name: "tmux",
-		via: "brew",
-		formula: "tmux",
-		sources: ["plugin:terminal@magus"],
-	},
-	{
-		name: "claudish",
-		via: "bun",
-		package: "claudish",
-		version: "1.2.0",
-		sources: ["profile:x.cliTools"],
-	},
-];
-
-describe("checkBinaries", () => {
-	test("reports presence and an install command per bin", async () => {
-		const present = new Set(["claudish"]);
-		const results = await checkBinaries(bins, async (n) => present.has(n));
-
-		const tmux = results.find((r) => r.name === "tmux")!;
-		expect(tmux.present).toBe(false);
-		expect(tmux.installCommand).toBe("brew install tmux");
-		expect(tmux.sources).toEqual(["plugin:terminal@magus"]);
-
-		const claudish = results.find((r) => r.name === "claudish")!;
-		expect(claudish.present).toBe(true);
-		expect(claudish.installCommand).toBe("bun install -g claudish@1.2.0");
+let root: string;
+let bin: string;
+let env: PlanEnv;
+beforeEach(() => {
+	root = mkdtempSync(join(tmpdir(), "doctor-bins-"));
+	bin = join(root, "bin");
+	mkdirSync(bin);
+	mkdirSync(join(root, "home"));
+	env = {
+		os: "linux",
+		arch: "amd64",
+		home: join(root, "home"),
+		path: bin,
+		userShell: "/bin/zsh",
+	};
+});
+afterEach(() => rmSync(root, { recursive: true, force: true }));
+
+function tool(dir: string, name: string, body = "exit 0"): void {
+	mkdirSync(dir, { recursive: true });
+	writeFileSync(join(dir, name), `#!/bin/sh\n${body}\n`);
+	chmodSync(join(dir, name), 0o755);
+}
+
+const tmux: ResolvedBin = {
+	name: "tmux",
+	check: ["tmux", "-V"],
+	install: [{ via: "brew", formula: "tmux" }],
+	chosen: { via: "brew", formula: "tmux" },
+	sources: ["plugin:terminal@magus"],
+};
+const claudish: ResolvedBin = {
+	name: "claudish",
+	check: ["claudish", "--version"],
+	install: [{ via: "bun", package: "claudish", version: "1.2.0" }],
+	chosen: { via: "bun", package: "claudish", version: "1.2.0" },
+	sources: ["profile:x.cliTools"],
+};
+
+describe("probeBins", () => {
+	test("answers each bin in order, with the hook's own probe", async () => {
+		tool(bin, "claudish");
+		const presences = await probeBins([tmux, claudish], {
+			env,
+			depth: "full",
+			capMs: 2_000,
+		});
+		expect(presences).toEqual([
+			{ name: "tmux", status: "missing" },
+			{ name: "claudish", status: "present" },
+		]);
+	});
+
+	test("a check reading the plugin root runs with ITS plugin's directory", async () => {
+		const pluginA = join(root, "a");
+		const pluginB = join(root, "b");
+		tool(pluginA, "ok.sh");
+		mkdirSync(pluginB);
+		const rooted = (dir: string): ResolvedBin => ({
+			name: "env",
+			check: ["${CLAUDE_PLUGIN_ROOT}/ok.sh"],
+			install: [{ via: "bun", package: "x" }],
+			chosen: { via: "bun", package: "x" },
+			root: dir,
+			sources: [],
+		});
+		// Same name twice: probed in separate passes, each answered for itself.
+		const presences = await probeBins([rooted(pluginA), rooted(pluginB)], {
+			env,
+			depth: "full",
+			capMs: 2_000,
+		});
+		expect(presences.map((p) => p.status)).toEqual(["present", "missing"]);
+	});
+
+	test("a dangling symlink reads as missing", async () => {
+		const { symlinkSync } = await import("node:fs");
+		symlinkSync(join(root, "gone"), join(bin, "tmux"));
+		const [p] = await probeBins([tmux], {
+			env,
+			depth: "presence",
+			capMs: 2_000,
+		});
+		expect(p?.status).toBe("missing");
 	});
 });
 
-describe("missingBinaries", () => {
-	test("returns only the absent ones", async () => {
-		const results = await checkBinaries(bins, async (n) => n === "claudish");
-		const missing = missingBinaries(results);
-		expect(missing.map((m) => m.name)).toEqual(["tmux"]);
+describe("checkBinaries / missingBinaries", () => {
+	test("pairs each answer with the paste-able install line", async () => {
+		tool(join(env.home, ".bun", "bin"), "claudish");
+		const results = await checkBinaries([tmux, claudish], {
+			env,
+			depth: "full",
+			capMs: 2_000,
+		});
+		expect(
+			results.map((r) => [r.name, r.presence.status, r.installCommand]),
+		).toEqual([
+			["tmux", "missing", "brew install tmux"],
+			["claudish", "off-path", "bun add -g claudish@1.2.0"],
+		]);
+		expect(missingBinaries(results).map((r) => r.name)).toEqual([
+			"tmux",
+			"claudish",
+		]);
+	});
+
+	test("present is not actionable", async () => {
+		tool(bin, "tmux");
+		const results = await checkBinaries([tmux], {
+			env,
+			depth: "full",
+			capMs: 2_000,
+		});
+		expect(missingBinaries(results)).toEqual([]);
 	});
 });

package/src/__tests__/doctor-json.test.ts

@@ -0,0 +1,261 @@
+/**
+ * `magus doctor --json`, end to end, as a process: a temp HOME where Claude
+ * Code has one plugin enabled and installed (no profiles.json anywhere), a
+ * PATH pinned to a temp dir, and a fake `brew` that talks on both stdout and
+ * stderr while it installs. stdout must stay exactly one JSON document.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import {
+	chmodSync,
+	existsSync,
+	mkdirSync,
+	mkdtempSync,
+	readFileSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const MAIN = join(import.meta.dir, "..", "main.tsx");
+
+let home: string;
+let tools: string;
+let project: string;
+beforeEach(() => {
+	home = mkdtempSync(join(tmpdir(), "doctor-json-"));
+	tools = join(home, "tools");
+	project = join(home, "project");
+	mkdirSync(tools);
+	mkdirSync(project);
+	const plugin = join(home, "plugin");
+	mkdirSync(join(plugin, ".claude-plugin"), { recursive: true });
+	writeFileSync(
+		join(plugin, ".claude-plugin", "plugin.json"),
+		JSON.stringify({
+			name: "fake",
+			requires: {
+				schema: 1,
+				bin: [
+					{
+						name: "faketool",
+						check: ["faketool", "--version"],
+						install: [{ via: "brew", formula: "faketool" }],
+					},
+				],
+			},
+		}),
+	);
+	mkdirSync(join(home, ".claude", "plugins"), { recursive: true });
+	writeFileSync(
+		join(home, ".claude", "settings.json"),
+		JSON.stringify({ enabledPlugins: { "fake@magus": true } }),
+	);
+	const now = new Date().toISOString();
+	writeFileSync(
+		join(home, ".claude", "plugins", "installed_plugins.json"),
+		JSON.stringify({
+			version: 2,
+			plugins: {
+				"fake@magus": [
+					{
+						scope: "user",
+						installPath: plugin,
+						version: "1.0.0",
+						installedAt: now,
+						lastUpdated: now,
+					},
+				],
+			},
+		}),
+	);
+	// A brew that is noisy on both streams, then puts the tool on PATH.
+	const brew = join(tools, "brew");
+	writeFileSync(
+		brew,
+		[
+			"#!/bin/sh",
+			'echo "==> Downloading $2"',
+			'echo "Warning: noisy installer" >&2',
+			`printf '#!/bin/sh\\necho 1.0.0\\n' > "${tools}/faketool"`,
+			`chmod 755 "${tools}/faketool"`,
+		].join("\n"),
+	);
+	chmodSync(brew, 0o755);
+});
+afterEach(() => rmSync(home, { recursive: true, force: true }));
+
+function doctor(...args: string[]) {
+	return doctorIn(project, ...args);
+}
+
+function doctorIn(cwd: string, ...args: string[]) {
+	const r = Bun.spawnSync(
+		[process.execPath, "--no-env-file", MAIN, "doctor", ...args],
+		{
+			cwd,
+			env: {
+				HOME: home,
+				PATH: `${tools}:/usr/bin:/bin`,
+				SHELL: "/bin/zsh",
+				XDG_CACHE_HOME: join(home, ".cache"),
+				NO_COLOR: "1",
+			},
+			stdin: "ignore",
+		},
+	);
+	return {
+		code: r.exitCode,
+		out: r.stdout.toString(),
+		err: r.stderr.toString(),
+	};
+}
+
+describe("magus doctor --json", () => {
+	test("with no profiles.json, names the enabled plugin's missing dep and its fix", () => {
+		const r = doctor("--json");
+		expect(r.code).toBe(1);
+		const doc = JSON.parse(r.out);
+		expect(doc.schema).toBe(1);
+		expect(doc.plugins).toEqual(["fake@magus"]);
+		expect(doc.deps).toEqual([
+			{
+				name: "faketool",
+				key: expect.any(String),
+				status: "missing",
+				requiredBy: ["fake@magus"],
+				fix: { via: "brew", escalation: "none", text: "brew install faketool" },
+			},
+		]);
+		expect(doc.applied).toBeUndefined();
+	});
+
+	test("--fix --yes --json: the installer talks on both streams; stdout is still one document", () => {
+		const r = doctor("--fix", "--yes", "--json");
+		const doc = JSON.parse(r.out); // throws if anything else reached stdout
+		expect(doc.applied).toEqual([
+			expect.objectContaining({
+				name: "faketool",
+				status: "installed",
+				argv: [join(tools, "brew"), "install", "faketool"],
+				exitCode: 0,
+				outputTail: expect.stringContaining("noisy installer"),
+			}),
+		]);
+		expect(doc.deps[0].status).toBe("present");
+		expect(r.code).toBe(0);
+		expect(existsSync(join(tools, "faketool"))).toBe(true);
+	});
+
+	test("reading never writes Claude Code's files: a clone missing a plugin's directory stays byte-identical", () => {
+		// A clone of the magus marketplace whose manifest lists a plugin whose
+		// source directory is not on disk, and that plugin enabled but not
+		// installed, so doctor reads the clone to find its declaration.
+		const clone = join(home, ".claude", "plugins", "marketplaces", "magus");
+		mkdirSync(join(clone, ".claude-plugin"), { recursive: true });
+		mkdirSync(join(clone, "plugins", "fake", ".claude-plugin"), {
+			recursive: true,
+		});
+		writeFileSync(
+			join(clone, "plugins", "fake", ".claude-plugin", "plugin.json"),
+			JSON.stringify({ name: "fake" }),
+		);
+		writeFileSync(
+			join(clone, ".claude-plugin", "marketplace.json"),
+			`${JSON.stringify(
+				{
+					name: "magus",
+					plugins: [
+						{ name: "fake", source: "./plugins/fake", version: "1.0.0" },
+						{ name: "gone", source: "./plugins/gone", version: "1.0.0" },
+					],
+				},
+				null,
+				4,
+			)}\n`,
+		);
+		writeFileSync(
+			join(home, ".claude", "plugins", "known_marketplaces.json"),
+			JSON.stringify({
+				magus: {
+					source: { source: "github", repo: "MadAppGang/magus" },
+					installLocation: clone,
+					lastUpdated: new Date().toISOString(),
+				},
+			}),
+		);
+		writeFileSync(
+			join(home, ".claude", "settings.json"),
+			JSON.stringify({
+				enabledPlugins: { "fake@magus": true, "gone@magus": true },
+			}),
+		);
+		const owned = [
+			join(clone, ".claude-plugin", "marketplace.json"),
+			join(clone, "plugins", "fake", ".claude-plugin", "plugin.json"),
+			join(home, ".claude", "plugins", "known_marketplaces.json"),
+			join(home, ".claude", "plugins", "installed_plugins.json"),
+			join(home, ".claude", "settings.json"),
+		];
+		const snapshot = () => owned.map((f) => readFileSync(f, "utf8"));
+		const before = snapshot();
+
+		doctor();
+		expect(snapshot()).toEqual(before);
+		doctor("--json");
+		expect(snapshot()).toEqual(before);
+		const fixed = doctor("--fix", "--yes");
+		expect(fixed.out).toContain("faketool");
+		expect(snapshot()).toEqual(before);
+	});
+
+	test("--project checks that project's plugins from any directory, and names it in the fix", () => {
+		// Installed at project scope: enabled only in the project's own settings.
+		writeFileSync(
+			join(home, ".claude", "settings.json"),
+			JSON.stringify({ enabledPlugins: {} }),
+		);
+		mkdirSync(join(project, ".claude"), { recursive: true });
+		writeFileSync(
+			join(project, ".claude", "settings.json"),
+			JSON.stringify({ enabledPlugins: { "fake@magus": true } }),
+		);
+		const registry = join(home, ".claude", "plugins", "installed_plugins.json");
+		const installed = JSON.parse(readFileSync(registry, "utf8"));
+		installed.plugins["fake@magus"][0].scope = "project";
+		installed.plugins["fake@magus"][0].projectPath = project;
+		writeFileSync(registry, JSON.stringify(installed));
+		const elsewhere = join(home, "elsewhere");
+		mkdirSync(elsewhere);
+
+		// Run where the banner's reader may well be: not in the project.
+		expect(JSON.parse(doctorIn(elsewhere, "--json").out).plugins).toEqual([]);
+		const r = doctorIn(elsewhere, "--json", "--project", project);
+		expect(JSON.parse(r.out).plugins).toEqual(["fake@magus"]);
+		expect(JSON.parse(r.out).deps[0]).toMatchObject({
+			name: "faketool",
+			status: "missing",
+		});
+
+		const text = doctorIn(elsewhere, "--project", project);
+		expect(text.out).toContain(`Fix: magus doctor --fix --project ${project}`);
+	});
+
+	test("--project naming no directory is a usage error", () => {
+		const missing = doctor("--json", "--project", join(home, "nope"));
+		expect(missing.code).toBe(2);
+		expect(missing.out).toBe("");
+		expect(missing.err).toContain("is not a directory");
+		const bare = doctor("--json", "--project");
+		expect(bare.code).toBe(2);
+		expect(bare.err).toContain("--project needs a directory");
+	});
+
+	test("--fix --json without --yes refuses: there is nowhere to ask", () => {
+		const r = doctor("--fix", "--json");
+		expect(r.code).toBe(2);
+		expect(r.out).toBe("");
+		expect(r.err).toContain("needs --yes");
+	});
+});