magus-cli 7.7.0 → 7.9.0

package/src/__tests__/resolver.test.ts

@@ -1,24 +1,30 @@
 import { describe, expect, test } from "bun:test";
 import { PREDEFINED_PROFILES } from "../data/predefined-profiles.js";
 import {
-	dedupeBins,
+	mergeBins,
+	pinOfBin,
 	resolveAllProfiles,
 	resolveExtends,
 	resolveProfile,
 } from "../services/resolver.js";
 import type {
-	BinRequirement,
+	ManagedTool,
 	ProfileManifest,
 	ProfileManifestEntry,
 } from "../types/index.js";
+import { ownedAsDeclared, selected } from "./fixtures/bins.js";
 
-// A binResolver that returns canned requires.bin per plugin — keeps the
-// resolver tests hermetic (no marketplace cache / filesystem).
-function fakeBinResolver(
-	table: Record<string, BinRequirement[]>,
-): (pluginId: string) => Promise<BinRequirement[]> {
-	return async (pluginId) => table[pluginId] ?? [];
+// A binResolver that returns canned requirements per plugin — keeps the
+// resolver tests hermetic (no marketplace cache / filesystem). A catalogue
+// tool a plugin owns resolves as that plugin declares it today.
+function fakeBinResolver(table: Record<string, ManagedTool[]>) {
+	return async (pluginId: string) =>
+		(table[pluginId] ?? []).map((t) => selected(t));
 }
+const hermetic = (table: Record<string, ManagedTool[]> = {}) => ({
+	binResolver: fakeBinResolver(table),
+	ownedResolver: ownedAsDeclared,
+});
 
 function manifestOf(
 	profiles: Record<string, ProfileManifestEntry>,
@@ -26,44 +32,60 @@ function manifestOf(
 	return { version: 2, profiles };
 }
 
-describe("dedupeBins — precedence by order", () => {
-	test("first-seen wins installer/version; later contributes only provenance", () => {
-		const claudishPin: BinRequirement = {
-			name: "claudish",
-			via: "bun",
-			package: "claudish",
-			version: "1.2.0",
-		};
-		const claudishLoose: BinRequirement = {
-			name: "claudish",
-			via: "npm",
-			package: "claudish",
-		};
-		const result = dedupeBins([
-			{ bin: claudishPin, source: "profile:x.cliTools" },
-			{ bin: claudishLoose, source: "plugin:foo@magus" },
+describe("mergeBins — precedence by order", () => {
+	test("a profile pin absorbs a later declaration of the name; it adds only provenance", () => {
+		const result = mergeBins([
+			{
+				bin: selected({ name: "claudish", via: "bun", version: "1.2.0" }),
+				source: "profile:x.cliTools",
+			},
+			{
+				bin: selected({ name: "claudish", via: "npm" }),
+				source: "plugin:foo@magus",
+			},
 		]);
 		expect(result).toHaveLength(1);
-		expect(result[0]!.via).toBe("bun");
-		expect(result[0]!.version).toBe("1.2.0");
+		expect(result[0]!.chosen?.via).toBe("bun");
+		expect(pinOfBin(result[0]!)).toBe("1.2.0");
 		expect(result[0]!.sources).toEqual([
 			"profile:x.cliTools",
 			"plugin:foo@magus",
 		]);
 	});
 
-	test("a later entry fills a version the winner left unset", () => {
-		const loose: BinRequirement = { name: "tmux", via: "brew" };
-		const pinned: BinRequirement = {
-			name: "tmux",
-			via: "brew",
-			version: "3.4",
+	test("identical declarations merge; different plugin declarations of one name stay two", () => {
+		const jq = selected({ name: "jq", via: "brew", formula: "jq" });
+		const result = mergeBins([
+			{ bin: jq, source: "plugin:dev@magus" },
+			{ bin: { ...jq }, source: "plugin:code-search@magus" },
+			{
+				bin: selected({
+					name: "jq",
+					via: "brew",
+					formula: "jq",
+					check: "jq -V",
+				}),
+				source: "plugin:other@elsewhere",
+			},
+		]);
+		expect(result).toHaveLength(2);
+		expect(result[0]!.sources).toEqual([
+			"plugin:dev@magus",
+			"plugin:code-search@magus",
+		]);
+		expect(result[1]!.sources).toEqual(["plugin:other@elsewhere"]);
+	});
+
+	test("a check that reads the plugin root never merges across plugins", () => {
+		const env = {
+			...selected({ name: "env", via: "bun" }),
+			check: ["${CLAUDE_PLUGIN_ROOT}/x"],
 		};
-		const result = dedupeBins([
-			{ bin: loose, source: "plugin:a" },
-			{ bin: pinned, source: "plugin:b" },
+		const result = mergeBins([
+			{ bin: { ...env, root: "/a" }, source: "plugin:a@m" },
+			{ bin: { ...env, root: "/b" }, source: "plugin:b@m" },
 		]);
-		expect(result[0]!.version).toBe("3.4");
+		expect(result).toHaveLength(2);
 	});
 });
 
@@ -161,8 +183,10 @@ describe("resolveProfile", () => {
 			},
 		});
 
-		const closure = await resolveProfile(manifest, "frontend", {
-			binResolver: fakeBinResolver({
+		const closure = await resolveProfile(
+			manifest,
+			"frontend",
+			hermetic({
 				"terminal@magus": [
 					{ name: "tmux", via: "brew", formula: "tmux" },
 					// terminal ALSO wants claudish, but the profile pinned it →
@@ -170,7 +194,7 @@ describe("resolveProfile", () => {
 					{ name: "claudish", via: "npm", package: "claudish" },
 				],
 			}),
-		});
+		);
 
 		expect(closure.plugins).toEqual({
 			"terminal@magus": "4.1.0",
@@ -179,12 +203,13 @@ describe("resolveProfile", () => {
 		expect(closure.env.required).toEqual(["FIGMA_ACCESS_TOKEN"]);
 
 		const claudish = closure.bins.find((b) => b.name === "claudish")!;
-		expect(claudish.via).toBe("bun"); // from the cli-tools catalog, not npm
-		expect(claudish.version).toBe("1.2.0");
+		// claudish@magus's own declaration (bun), pinned by the profile — not npm.
+		expect(claudish.chosen?.via).toBe("bun");
+		expect(pinOfBin(claudish)).toBe("1.2.0");
 		expect(claudish.sources[0]).toContain("cliTools");
 
 		const tmux = closure.bins.find((b) => b.name === "tmux")!;
-		expect(tmux.via).toBe("brew");
+		expect(tmux.chosen?.via).toBe("brew");
 		expect(tmux.sources).toContain("plugin:terminal@magus");
 	});
 
@@ -213,9 +238,7 @@ describe("resolveAllProfiles — union", () => {
 			},
 		});
 
-		const union = await resolveAllProfiles(manifest, {
-			binResolver: fakeBinResolver({}),
-		});
+		const union = await resolveAllProfiles(manifest, hermetic());
 
 		expect(union.plugins["dev@magus"]).toBe("2.9.0"); // pin beat latest
 		expect(union.plugins["terminal@magus"]).toBe("4.1.0");
@@ -224,7 +247,9 @@ describe("resolveAllProfiles — union", () => {
 			"DATABASE_URL",
 			"FIGMA_ACCESS_TOKEN",
 		]);
-		expect(union.bins.find((b) => b.name === "mnemex")?.via).toBe("bun");
+		expect(union.bins.find((b) => b.name === "mnemex")?.chosen?.via).toBe(
+			"bun",
+		);
 		expect(union.conflicts).toBeUndefined(); // latest-vs-pin isn't a conflict
 	});
 
@@ -260,16 +285,68 @@ describe("resolveAllProfiles — union", () => {
 			a: { name: "A", cliTools: { claudish: "1.2.0" } },
 			b: { name: "B", cliTools: { claudish: "1.5.0" } },
 		});
-		const union = await resolveAllProfiles(manifest, {
-			binResolver: fakeBinResolver({}),
-		});
-		expect(union.bins.find((x) => x.name === "claudish")?.version).toBe(
-			"1.5.0",
-		);
+		const union = await resolveAllProfiles(manifest, hermetic());
+		const claudish = union.bins.find((x) => x.name === "claudish");
+		expect(claudish && pinOfBin(claudish)).toBe("1.5.0");
 		expect(union.conflicts?.some((c) => c.includes("claudish"))).toBe(true);
 	});
 });
 
+describe("a pin on a tool its plugin installs without a version", () => {
+	// claudish@magus as it declares claudish off Homebrew: its pinned release.
+	const RELEASE = {
+		via: "release" as const,
+		repo: "MadAppGang/claudish",
+		tag: "v10.3.0",
+		asset: "claudish-{os}-{arch}",
+		binary: "claudish",
+		sha256: { linux_amd64: "a".repeat(64) },
+	};
+	const ownedRelease = async (_pluginId: string, name: string) => ({
+		name,
+		check: [name, "--version"],
+		install: [RELEASE],
+		chosen: RELEASE,
+	});
+	const opts = {
+		binResolver: fakeBinResolver({}),
+		ownedResolver: ownedRelease,
+	};
+
+	test("is kept as refused: the release stays what installs, and no pin is invented", async () => {
+		const closure = await resolveProfile(
+			manifestOf({ p: { name: "P", cliTools: { claudish: "6.1.0" } } }),
+			"p",
+			opts,
+		);
+		const claudish = closure.bins.find((b) => b.name === "claudish");
+		expect(claudish?.chosen).toEqual(RELEASE);
+		expect(claudish && pinOfBin(claudish)).toBeUndefined();
+		expect(claudish?.refusedPins).toEqual(["6.1.0"]);
+	});
+
+	test("every profile's refused pin survives the union", async () => {
+		const union = await resolveAllProfiles(
+			manifestOf({
+				a: { name: "A", cliTools: { claudish: "6.1.0" } },
+				b: { name: "B", cliTools: { claudish: "7.0.0" } },
+			}),
+			opts,
+		);
+		const claudish = union.bins.find((b) => b.name === "claudish");
+		expect(claudish?.refusedPins).toEqual(["6.1.0", "7.0.0"]);
+	});
+
+	test("latest is not a pin, so nothing is refused", async () => {
+		const closure = await resolveProfile(
+			manifestOf({ p: { name: "P", cliTools: { claudish: "latest" } } }),
+			"p",
+			opts,
+		);
+		expect(closure.bins[0]?.refusedPins).toBeUndefined();
+	});
+});
+
 describe("marketplaces derived from plugin ids", () => {
 	const noBins = { binResolver: fakeBinResolver({}) };
 

package/src/__tests__/run.test.ts

@@ -0,0 +1,108 @@
+/**
+ * `runArgv` — the one runner: argv only, output captured and tailed, never
+ * written to the terminal, bounded by SIGTERM then SIGKILL.
+ */
+
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import {
+	OUTPUT_TAIL_BYTES,
+	runArgv,
+	runFailureReason,
+	succeeded,
+} from "../utils/run.js";
+
+const sh = (script: string) => ({ cmd: "/bin/sh", args: ["-c", script] });
+
+describe("runArgv", () => {
+	let out: ReturnType<typeof spyOn>;
+	let err: ReturnType<typeof spyOn>;
+	beforeEach(() => {
+		out = spyOn(process.stdout, "write");
+		err = spyOn(process.stderr, "write");
+	});
+	afterEach(() => {
+		out.mockRestore();
+		err.mockRestore();
+	});
+
+	test("captures stdout and stderr together, ANSI stripped, and never writes to the terminal", async () => {
+		const chunks: string[] = [];
+		const r = await runArgv(
+			sh("printf 'to-out\\n'; printf '\\033[31mto-err\\033[0m\\n' >&2"),
+			{ timeoutMs: 5_000, onOutput: (c) => chunks.push(c) },
+		);
+		expect(r.exitCode).toBe(0);
+		expect(succeeded(r)).toBe(true);
+		expect(r.outputTail).toContain("to-out");
+		expect(r.outputTail).toContain("to-err");
+		expect(r.outputTail).not.toContain("\u001b[");
+		expect(chunks.join("")).toContain("to-out");
+		expect(out).not.toHaveBeenCalled();
+		expect(err).not.toHaveBeenCalled();
+	});
+
+	test("keeps only the last 16 KiB of output", async () => {
+		const r = await runArgv(
+			sh(
+				"i=0; while [ $i -lt 2000 ]; do echo line-$i-xxxxxxxxxxxxxxxx; i=$((i+1)); done",
+			),
+			{ timeoutMs: 10_000 },
+		);
+		expect(Buffer.byteLength(r.outputTail)).toBeLessThanOrEqual(
+			OUTPUT_TAIL_BYTES,
+		);
+		expect(r.outputTail).toContain("line-1999-");
+		expect(r.outputTail).not.toContain("line-0-");
+	});
+
+	test("an argument is one argument: nothing reaches a shell", async () => {
+		const r = await runArgv(
+			{ cmd: "/bin/echo", args: ["a b; echo injected"] },
+			{ timeoutMs: 5_000 },
+		);
+		expect(r.outputTail.trim()).toBe("a b; echo injected");
+	});
+
+	test("stdin is not the terminal", async () => {
+		const r = await runArgv(sh("cat; echo done"), { timeoutMs: 5_000 });
+		expect(r.outputTail.trim()).toBe("done");
+	});
+
+	test("a missing executable is a spawn error, not a throw", async () => {
+		const r = await runArgv(
+			{ cmd: "/nonexistent/tool", args: [] },
+			{ timeoutMs: 5_000 },
+		);
+		expect(r.exitCode).toBeNull();
+		expect(r.spawnError).toContain("ENOENT");
+		expect(succeeded(r)).toBe(false);
+	});
+
+	test("over the limit: SIGTERM, then SIGKILL once the grace runs out", async () => {
+		const started = Date.now();
+		const r = await runArgv(sh("trap '' TERM; while :; do sleep 0.05; done"), {
+			timeoutMs: 200,
+			killGraceMs: 300,
+		});
+		expect(r.timedOut).toBe(true);
+		expect(r.signal).toBe("SIGKILL");
+		expect(Date.now() - started).toBeGreaterThanOrEqual(450);
+		expect(runFailureReason(r)).toStartWith("timed out");
+	});
+
+	test("a child that honours SIGTERM ends there", async () => {
+		const r = await runArgv(sh("exec sleep 10"), { timeoutMs: 200 });
+		expect(r.timedOut).toBe(true);
+		expect(r.signal).toBe("SIGTERM");
+	});
+
+	test("the failure reason is the installer's last line", async () => {
+		const r = await runArgv(
+			sh("echo progress; echo 'error: no such formula' >&2; exit 3"),
+			{
+				timeoutMs: 5_000,
+			},
+		);
+		expect(runFailureReason(r)).toBe("exit 3: error: no such formula");
+	});
+});

package/src/__tests__/stale-load-repair.test.ts

@@ -303,7 +303,9 @@ describe("repairStaleLoad — the backup", () => {
 			const result = await repairStaleLoad(PLUGIN, "0.5.0", here, root);
 
 			expect(result.ok).toBe(false);
-			expect(result.error).toContain("could not back up");
+			expect(result.error).toBe(
+				"could not save a backup before changing anything, so nothing was changed",
+			);
 			expect(result.rewritten).toBe(0);
 			expect(result.backup).toBeNull();
 			expect(await fs.readFile(registryFile, "utf8")).toBe(before);
@@ -328,7 +330,7 @@ describe("repairStaleLoad — refusals", () => {
 		const result = await repairStaleLoad(PLUGIN, "0.7.0", here, root);
 
 		expect(result.ok).toBe(false);
-		expect(result.error).toContain("no cache directory for v0.7.0");
+		expect(result.error).toBe("v0.7.0 is not downloaded — run magus install");
 		expect(result.backup).toBeNull();
 		expect(await fs.readFile(registryFile, "utf8")).toBe(before);
 		expect(await backups()).toEqual([]);
@@ -340,7 +342,7 @@ describe("repairStaleLoad — refusals", () => {
 		const result = await repairStaleLoad(PLUGIN, "0.5.0", here, root);
 
 		expect(result.ok).toBe(false);
-		expect(result.error).toContain("has no rows");
+		expect(result.error).toBe("it is not installed on this machine");
 	});
 
 	test("a string that is not a plugin id is refused", async () => {
@@ -360,7 +362,9 @@ describe("repairStaleLoad — refusals", () => {
 		const result = await repairStaleLoad(PLUGIN, "0.5.0", here, root);
 
 		expect(result.ok).toBe(false);
-		expect(result.error).toContain("not a readable registry");
+		expect(result.error).toBe(
+			"Claude Code's list of installed plugins cannot be read, so nothing was changed — run magus doctor",
+		);
 		expect(await fs.readFile(registryFile, "utf8")).toBe("{ not json");
 	});
 });
@@ -400,8 +404,9 @@ describe("repairStaleLoad — scope reach", () => {
 		const result = await repairStaleLoad(PLUGIN, "0.5.0", here, root);
 
 		expect(result.ok).toBe(false);
-		expect(result.error).toContain("machine-wide user-scope record at v0.3.0");
-		expect(result.error).toContain("--scope user");
+		expect(result.error).toBe(
+			"Claude Code loads the USER install of it here — update it at USER scope",
+		);
 		expect(result.rewritten).toBe(0);
 		expect(await fs.readFile(registryFile, "utf8")).toBe(before);
 		expect(await backups()).toEqual([]);
@@ -457,8 +462,9 @@ describe("repairStaleLoad — scope reach", () => {
 		const result = await repairStaleLoad(PLUGIN, "0.5.0", here, root);
 
 		expect(result.ok).toBe(false);
-		expect(result.error).toContain("machine-wide managed-scope record");
-		expect(result.error).toContain("administrator policy");
+		expect(result.error).toBe(
+			"Claude Code loads the install your administrator manages here — ask them to update it",
+		);
 	});
 
 	test("a user-scope row that is not the winner stays where it is", async () => {
@@ -485,13 +491,11 @@ describe("repairStaleLoad — scope reach", () => {
 		expect(after[1].installPath).toBe(cacheFor("0.4.0"));
 	});
 
-	test("a rootless row from another directory is relevant but never rewritten", async () => {
-		// The loader's filter compares repository roots and two nulls are equal
-		// there, so this row genuinely competes — `isRelevantInstallation` says so
-		// and plugin-resolution.test.ts pins it. Writing it is a different question:
-		// "the same repository" cannot be true of two directories that are in no
-		// repository, so the repair reports that it could not fix this rather than
-		// editing a stranger's row.
+	test("a rootless row from another directory neither competes nor is rewritten", async () => {
+		// Claude Code 2.1.284 matches nothing by root in a folder that is in no
+		// repository, so the other folder's older row does not load here and this
+		// folder's own row does. Nothing to repair, and the stranger's row is left
+		// exactly as it was.
 		const looseHere = path.join(base, "loose-here");
 		const looseOther = path.join(base, "loose-other");
 		await fs.ensureDir(looseHere);
@@ -507,13 +511,13 @@ describe("repairStaleLoad — scope reach", () => {
 				looseHere,
 				repoRootForPath(looseHere),
 			),
-		).toBe(true);
+		).toBe(false);
 
 		const result = await repairStaleLoad(PLUGIN, "0.5.0", looseHere, root);
 
 		expect(result.rewritten).toBe(0);
-		expect(result.ok).toBe(false);
-		expect(result.error).toContain("still resolves v0.3.0");
+		expect(result.ok).toBe(true);
+		expect(result.loaded).toBe("0.5.0");
 		expect((await readRegistry()).plugins[PLUGIN][0].version).toBe("0.3.0");
 	});
 });
@@ -557,7 +561,9 @@ describe("repairStaleLoad — a concurrent write is refused, not clobbered", ()
 			const result = await repairStaleLoad(PLUGIN, "0.5.0", here, root);
 
 			expect(result.ok).toBe(false);
-			expect(result.error).toContain("changed on disk after it was read");
+			expect(result.error).toBe(
+				"another Claude Code session changed its plugins at the same moment, so nothing was changed — run it again",
+			);
 			expect(result.rewritten).toBe(0);
 		} finally {
 			spy.mockRestore();
@@ -694,7 +700,9 @@ describe("repairStaleLoad — the post-write assertion", () => {
 		expect(result.rewritten).toBe(1);
 		expect(result.loaded).toBe("0.9.0");
 		expect(result.ok).toBe(false);
-		expect(result.error).toContain("still resolves v0.9.0");
+		expect(result.error).toContain(
+			"Claude Code still loads v0.9.0 in this folder",
+		);
 	});
 
 	test("the assertion reads the file from DISK, not the object it mutated", async () => {
@@ -1147,7 +1155,7 @@ describe("B4: an update brings the loader forward in the same run", () => {
 		expect(result.ok).toBe(1);
 		expect(result.failed).toEqual([]);
 		expect(details).toEqual([
-			"project → 0.5.0 · Claude Code now loads v0.5.0 here (1 older record moved forward)",
+			"project → 0.5.0 · Claude Code now loads v0.5.0 in this folder",
 		]);
 		expect(await loadedVersionHere(PLUGIN, here, root)).toBe("0.5.0");
 		// Moved forward, nothing removed.
@@ -1265,7 +1273,7 @@ describe("7.5.2: Claude Code 2.1.281 updates another project's row of the reposi
 			[here, "0.5.0"],
 		]);
 		expect(details).toEqual([
-			`project → 0.5.0 · Claude Code updated ${mainTree} instead of this project — moved this project's record to v0.5.0 too`,
+			"project → 0.5.0 · Claude Code updated another folder of this repository instead of this one — this folder now loads v0.5.0 too",
 		]);
 		expect(await loadedVersionHere(PLUGIN, here, root)).toBe("0.5.0");
 	});
@@ -1335,7 +1343,7 @@ describe("7.5.2: Claude Code 2.1.281 updates another project's row of the reposi
 				?.version,
 		).toBe("0.4.0");
 		expect(details[0]).toContain(
-			`no change — the installer exited 0 but ${PLUGIN} is still 0.4.0 (Claude Code updated ${mainTree} instead of this project, and this project's record could not follow: no cache directory for v0.6.0`,
+			`no change — the installer exited 0 but ${PLUGIN} is still 0.4.0 (Claude Code updated another folder of this repository instead of this one, and this folder could not follow: v0.6.0 is not downloaded — run magus install)`,
 		);
 	});
 });

package/src/__tests__/tool-probe.test.ts

@@ -1395,7 +1395,7 @@ describe("binPinCommand — moving an installed tool to exactly its pin", () =>
 	test("bun/npm/go carry the version in the package token", () => {
 		expect(
 			binPinCommand({ name: "m", via: "bun", version: "1.0.0" }, uv),
-		).toEqual({ cmd: "bun", args: ["install", "-g", "m@1.0.0"] });
+		).toEqual({ cmd: "bun", args: ["add", "-g", "m@1.0.0"] });
 		expect(
 			binPinCommand(
 				{ name: "t", via: "go", module: "github.com/x/t", version: "v2.0.0" },