magus-cli 7.9.0 → 7.10.0

package/src/__tests__/blind/review-followups/ledger-pruning.test.ts

@@ -0,0 +1,79 @@
+import { expect, test } from "bun:test";
+import {
+	access,
+	chmod,
+	mkdir,
+	readdir,
+	utimes,
+	writeFile,
+} from "node:fs/promises";
+import { join } from "node:path";
+
+import {
+	hookCommand,
+	linkExecutable,
+	makeHookPlugin,
+	makeShellPath,
+	makeWorld,
+	pinnedEnv,
+	removeWorld,
+	runChild,
+	sessionInput,
+} from "../plugin-deps/helpers";
+
+test("each stale ledger is pruned even when another stale ledger cannot be removed", async () => {
+	const world = await makeWorld();
+	let blocked = "";
+	try {
+		const plugin = await makeHookPlugin(world, "ledger-pruning", {
+			schema: 1,
+			bin: [],
+		});
+		const shellPath = await makeShellPath(world);
+		await linkExecutable(world.bin, "bun", process.execPath);
+
+		for (const name of ["magus-deps-candidate-a", "magus-deps-candidate-b"]) {
+			await mkdir(join(world.tmp, name));
+		}
+		const candidates = (await readdir(world.tmp)).filter((name) =>
+			name.startsWith("magus-deps-candidate-"),
+		);
+		blocked = join(world.tmp, candidates[0] ?? "magus-deps-candidate-a");
+		const removable = join(
+			world.tmp,
+			candidates[1] ?? "magus-deps-candidate-b",
+		);
+		await mkdir(join(blocked, "contents"));
+		await writeFile(join(blocked, "contents", "ledger"), "stale\n");
+		const stale = new Date(0);
+		await utimes(blocked, stale, stale);
+		await utimes(removable, stale, stale);
+		await chmod(blocked, 0o000);
+
+		await runChild(
+			join(shellPath, "sh"),
+			["-c", `umask 022; ${hookCommand("pruner")}`],
+			{
+				cwd: world.project,
+				env: pinnedEnv(world, [world.bin, shellPath], {
+					BUN_INSTALL: join(world.home, ".bun"),
+					CLAUDE_PLUGIN_ROOT: plugin,
+					SHELL: join(shellPath, "sh"),
+				}),
+				input: sessionInput("current-ledger"),
+				timeoutMs: 9_500,
+			},
+		);
+
+		let removableExists = true;
+		try {
+			await access(removable);
+		} catch {
+			removableExists = false;
+		}
+		expect(removableExists).toBe(false);
+	} finally {
+		if (blocked) await chmod(blocked, 0o700).catch(() => undefined);
+		await removeWorld(world);
+	}
+});

package/src/__tests__/blind/review-followups/path-advice.test.ts

@@ -0,0 +1,46 @@
+import { expect, test } from "bun:test";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+import {
+	configureClaude,
+	makePlugin,
+	makeWorld,
+	removeWorld,
+	runDoctor,
+	writeExecutable,
+} from "../plugin-deps/helpers";
+
+test("doctor does not advise adding a PATH line already present in the shell rc file", async () => {
+	const world = await makeWorld();
+	try {
+		const rcLine = 'export PATH="$HOME/.bun/bin:$PATH"';
+		await writeFile(join(world.home, ".zshrc"), `${rcLine}\n`);
+		const plugin = await makePlugin(world, "path-advice", {
+			schema: 1,
+			bin: [
+				{
+					name: "bun",
+					check: ["bun", "--version"],
+					install: [{ tool: "bun", via: "bootstrap" }],
+				},
+				{
+					name: "widget",
+					check: ["widget", "--version"],
+					install: [{ package: "widget", via: "bun" }],
+				},
+			],
+		});
+		await configureClaude(world, [{ key: "path-advice@test", root: plugin }]);
+		await writeExecutable(join(world.bin, "bun"), "exit 0");
+		await writeExecutable(join(world.home, ".bun", "bin", "widget"), "exit 0");
+
+		const result = await runDoctor(world, ["--fix", "--yes"], {
+			extraEnv: { BUN_INSTALL: join(world.home, ".bun") },
+		});
+		const output = `${result.stdout}\n${result.stderr}`;
+		expect(output).not.toContain(`${rcLine}  to ~/.zshrc`);
+	} finally {
+		await removeWorld(world);
+	}
+});

package/src/__tests__/blind/review-followups/stats-requires.test.ts

@@ -0,0 +1,16 @@
+import { expect, test } from "bun:test";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+
+import { REPO_ROOT } from "../plugin-deps/helpers";
+
+test("the stats plugin declares only tools its runtime uses", async () => {
+	const manifest = JSON.parse(
+		await readFile(
+			join(REPO_ROOT, "plugins", "stats", ".claude-plugin", "plugin.json"),
+			"utf8",
+		),
+	) as { requires: { bin: { name: string }[] } };
+
+	expect(manifest.requires.bin.map(({ name }) => name).sort()).toEqual(["bun"]);
+});

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

@@ -468,7 +468,7 @@ describe("applyDepsPlan — uv-module", () => {
 			env,
 		);
 		const { calls, run } = fakeRun([
-			[(a) => a[1] === "python" && a[2] === "find", { outputTail: `${PY}\n` }],
+			[(a) => a[1] === "python" && a[2] === "find", { stdout: `${PY}\n` }],
 		]);
 		const outcomes = await applyDepsPlan(plan, options({ run }));
 		expect(outcomes.map((o) => [o.name, o.status])).toEqual([
@@ -518,7 +518,7 @@ describe("applyDepsPlan — uv-module", () => {
 		for (const t of ["sudo", "uv"]) tool(bin, t);
 		const plan = planDeps([LIBS], [missing("chromium-libs")], env);
 		const { calls, run } = fakeRun([
-			[(a) => a[1] === "python", { outputTail: "/usr/bin/python3.12\n" }],
+			[(a) => a[1] === "python", { stdout: "/usr/bin/python3.12\n" }],
 			[(a) => a[1] === "-c", { exitCode: 1 }],
 		]);
 		const [outcome] = await applyDepsPlan(plan, options({ run }));
@@ -835,6 +835,7 @@ describe("applyDepsPlan — installed means the re-probe found it", () => {
 				signal: null,
 				timedOut: false,
 				outputTail: argv[1] === "pm" ? `${xdgBin}\n` : "installed claudish",
+				...(argv[1] === "pm" ? { stdout: `${xdgBin}\n` } : {}),
 				durationMs: 1,
 			};
 		};

package/src/__tests__/plugin-mcp-source-shapes.test.ts

@@ -0,0 +1,250 @@
+/**
+ * Marketplace plugin `source` comes in two shapes: a string path
+ * ("./plugins/foo") or an object (git-subdir / github / url). Only a string
+ * source has an on-disk MCP config under the marketplace clone.
+ *
+ * Regression guarded: the Plugins screen does
+ *   src = await getPluginSourcePath(mp, name); if (!src) skip;
+ *   await getPluginEnvRequirements(mp, src)
+ * and an object source used to throw `pluginSource.replace is not a function`.
+ *
+ * The module resolves the home directory at import time, and Bun's
+ * os.homedir() ignores a HOME changed at runtime, so every scenario runs in a
+ * child bun process with HOME pointed at a temp directory.
+ */
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { spawnSync } from "node:child_process";
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const MODULE_PATH = path.resolve(
+	import.meta.dir,
+	"../services/plugin-mcp-config.ts",
+);
+const MP = "testmp";
+
+const CHILD_SCRIPT = `
+import { getPluginSourcePath, getPluginEnvRequirements } from ${JSON.stringify(MODULE_PATH)};
+
+const input = JSON.parse(process.env.MCP_SHAPES_INPUT ?? "{}");
+const out = {};
+
+try {
+	const sp = await getPluginSourcePath(input.mp, input.plugin);
+	out.sourcePathType = typeof sp;
+	out.sourcePath = sp === undefined ? null : sp;
+	out.sourcePathOk = true;
+} catch (e) {
+	out.sourcePathOk = false;
+	out.sourcePathError = String(e && e.message ? e.message : e);
+}
+
+// The exact Plugins-screen sequence.
+try {
+	const src = await getPluginSourcePath(input.mp, input.plugin);
+	if (!src) {
+		out.sequence = { ok: true, skipped: true };
+	} else {
+		const reqs = await getPluginEnvRequirements(input.mp, src);
+		out.sequence = { ok: true, skipped: false, names: reqs.map((r) => r.name) };
+	}
+} catch (e) {
+	out.sequence = { ok: false, error: String(e && e.message ? e.message : e) };
+}
+
+if (typeof input.direct === "string") {
+	try {
+		const reqs = await getPluginEnvRequirements(input.mp, input.direct);
+		out.direct = {
+			ok: true,
+			reqs: reqs.map((r) => ({ name: r.name, serverName: r.serverName })),
+		};
+	} catch (e) {
+		out.direct = { ok: false, error: String(e && e.message ? e.message : e) };
+	}
+}
+
+process.stdout.write("__RESULT__" + JSON.stringify(out) + "\\n");
+`;
+
+interface ChildResult {
+	sourcePathOk: boolean;
+	sourcePathError?: string;
+	sourcePathType?: string;
+	sourcePath?: unknown;
+	sequence: {
+		ok: boolean;
+		skipped?: boolean;
+		names?: string[];
+		error?: string;
+	};
+	direct?: {
+		ok: boolean;
+		reqs?: Array<{ name: string; serverName: string }>;
+		error?: string;
+	};
+}
+
+let tmpHome: string;
+let scriptPath: string;
+
+async function writeMarketplace(
+	plugins: Array<{ name: string; source: unknown }>,
+): Promise<void> {
+	const dir = path.join(
+		tmpHome,
+		".claude",
+		"plugins",
+		"marketplaces",
+		MP,
+		".claude-plugin",
+	);
+	await fs.mkdir(dir, { recursive: true });
+	await fs.writeFile(
+		path.join(dir, "marketplace.json"),
+		JSON.stringify({ name: MP, plugins }, null, 2),
+	);
+}
+
+async function writeMcpConfig(
+	relSource: string,
+	config: Record<string, unknown>,
+): Promise<void> {
+	const dir = path.join(
+		tmpHome,
+		".claude",
+		"plugins",
+		"marketplaces",
+		MP,
+		relSource.replace(/^\.\//, ""),
+		"mcp-servers",
+	);
+	await fs.mkdir(dir, { recursive: true });
+	await fs.writeFile(
+		path.join(dir, "mcp-config.json"),
+		JSON.stringify(config, null, 2),
+	);
+}
+
+function runChild(input: {
+	mp: string;
+	plugin: string;
+	direct?: string;
+}): ChildResult {
+	const res = spawnSync("bun", ["--no-env-file", scriptPath], {
+		cwd: tmpHome,
+		env: {
+			...process.env,
+			HOME: tmpHome,
+			MCP_SHAPES_INPUT: JSON.stringify(input),
+		},
+		encoding: "utf-8",
+		timeout: 30_000,
+	});
+	const stdout = res.stdout ?? "";
+	const line = stdout.split("\n").find((l) => l.startsWith("__RESULT__"));
+	if (!line) {
+		throw new Error(
+			`child produced no result (status ${res.status})\nstdout:\n${stdout}\nstderr:\n${res.stderr ?? ""}`,
+		);
+	}
+	return JSON.parse(line.slice("__RESULT__".length)) as ChildResult;
+}
+
+beforeEach(async () => {
+	tmpHome = await fs.mkdtemp(path.join(os.tmpdir(), "mcp-source-shapes-"));
+	scriptPath = path.join(tmpHome, "child.ts");
+	await fs.writeFile(scriptPath, CHILD_SCRIPT);
+});
+
+afterEach(async () => {
+	await fs.rm(tmpHome, { recursive: true, force: true });
+});
+
+describe("string source", () => {
+	test("getPluginSourcePath returns the string and env requirements resolve from its mcp-config", async () => {
+		await writeMarketplace([{ name: "foo", source: "./plugins/foo" }]);
+		await writeMcpConfig("./plugins/foo", {
+			"foo-server": {
+				command: "node",
+				args: ["server.js"],
+				env: { FOO_TOKEN: "${FOO_TOKEN}" },
+			},
+		});
+
+		const r = runChild({ mp: MP, plugin: "foo", direct: "./plugins/foo" });
+
+		expect(r.sourcePathOk).toBe(true);
+		expect(r.sourcePathType).toBe("string");
+		expect(r.sourcePath).toBe("./plugins/foo");
+
+		expect(r.direct?.ok).toBe(true);
+		const names = (r.direct?.reqs ?? []).map((q) => q.name);
+		expect(names).toContain("FOO_TOKEN");
+		const foo = r.direct?.reqs?.find((q) => q.name === "FOO_TOKEN");
+		expect(foo?.serverName).toBe("foo-server");
+
+		// The Plugins-screen sequence reaches the same requirement.
+		expect(r.sequence.ok).toBe(true);
+		expect(r.sequence.skipped).toBe(false);
+		expect(r.sequence.names).toContain("FOO_TOKEN");
+	});
+});
+
+describe("object source", () => {
+	const shapes: Array<[string, Record<string, unknown>]> = [
+		[
+			"git-subdir",
+			{
+				source: "git-subdir",
+				url: "https://github.com/expo/skills.git",
+				path: "plugins/expo",
+				ref: "main",
+			},
+		],
+		["github", { source: "github", repo: "owner/name" }],
+		["url", { source: "url", url: "https://example.com/x.git" }],
+	];
+
+	for (const [label, source] of shapes) {
+		test(`${label}: getPluginSourcePath returns undefined, not the object`, async () => {
+			await writeMarketplace([
+				{ name: "foo", source: "./plugins/foo" },
+				{ name: "remote", source },
+			]);
+			await writeMcpConfig("./plugins/foo", {
+				"foo-server": { env: { FOO_TOKEN: "${FOO_TOKEN}" } },
+			});
+
+			const r = runChild({ mp: MP, plugin: "remote" });
+
+			expect(r.sourcePathError).toBeUndefined();
+			expect(r.sourcePathOk).toBe(true);
+			expect(r.sourcePathType).toBe("undefined");
+			expect(r.sourcePathType).not.toBe("object");
+		});
+
+		test(`${label}: the Plugins-screen sequence resolves without throwing`, async () => {
+			await writeMarketplace([{ name: "remote", source }]);
+
+			const r = runChild({ mp: MP, plugin: "remote" });
+
+			expect(r.sequence.error).toBeUndefined();
+			expect(r.sequence.ok).toBe(true);
+		});
+	}
+});
+
+describe("unknown plugin", () => {
+	test("getPluginSourcePath returns undefined for a name not in the marketplace", async () => {
+		await writeMarketplace([{ name: "foo", source: "./plugins/foo" }]);
+
+		const r = runChild({ mp: MP, plugin: "does-not-exist" });
+
+		expect(r.sourcePathOk).toBe(true);
+		expect(r.sourcePathType).toBe("undefined");
+		expect(r.sequence.ok).toBe(true);
+		expect(r.sequence.skipped).toBe(true);
+	});
+});