magus-cli 7.10.1 → 7.10.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "magus-cli",
-  "version": "7.10.1",
+  "version": "7.10.3",
   "description": "TUI tool for managing Claude Code plugins, MCPs, and configuration",
   "type": "module",
   "main": "src/main.tsx",
@@ -65,8 +65,8 @@
     "typescript": "^5.6.3"
   },
   "optionalDependencies": {
-    "magus-cli-darwin-arm64": "7.10.1",
-    "magus-cli-darwin-x64": "7.10.1",
-    "magus-cli-linux-x64": "7.10.1"
+    "magus-cli-darwin-arm64": "7.10.3",
+    "magus-cli-darwin-x64": "7.10.3",
+    "magus-cli-linux-x64": "7.10.3"
   }
 }

package/src/__tests__/blind/c16-probe-adopts-node-global.test.ts

@@ -0,0 +1,323 @@
+/**
+ * Blind tests, contract C16: a tool whose declared installer does not own the
+ * file PATH runs is adopted by the node installer (bun or npm) when that file
+ * lies in bun's global tree or an npm global prefix. Otherwise it stays
+ * external / not-managed with a note that names no path.
+ *
+ * Written from the spec only. Every fact reaches `probeTool` through a
+ * scripted fake `ToolProbeIO`.
+ */
+import { describe, expect, test } from "bun:test";
+import {
+	type ExecResult,
+	type FetchJsonResult,
+	type ToolProbeIO,
+	classifyTool,
+	probeTool,
+} from "../../services/tool-probe.js";
+import type { BinRequirement } from "../../types/index.js";
+
+interface FakeSetup {
+	exec?: Record<string, Partial<ExecResult>>;
+	fetch?: Record<string, FetchJsonResult>;
+	files?: Record<string, string>;
+	real?: Record<string, string>;
+	onPath?: Record<string, string>;
+	env?: Record<string, string>;
+}
+
+function fakeIO(setup: FakeSetup): ToolProbeIO & { calls: string[] } {
+	const calls: string[] = [];
+	return {
+		calls,
+		exec: async (command) => {
+			const key = [command.cmd, ...command.args].join(" ");
+			calls.push(key);
+			const h = setup.exec?.[key];
+			if (h === undefined) {
+				return {
+					code: null,
+					stdout: "",
+					stderr: "",
+					timedOut: false,
+					missing: true,
+				};
+			}
+			return {
+				code: 0,
+				stdout: "",
+				stderr: "",
+				timedOut: false,
+				missing: false,
+				...h,
+			};
+		},
+		fetchJson: async (url) => {
+			const r = setup.fetch?.[url];
+			return r ?? { ok: false, reason: "returned 404" };
+		},
+		readJson: async (file) => {
+			const t = setup.files?.[file];
+			if (t === undefined) return null;
+			try {
+				return JSON.parse(t);
+			} catch {
+				return null;
+			}
+		},
+		readText: async (file) => setup.files?.[file] ?? null,
+		readlink: async () => null,
+		realpath: async (file) => setup.real?.[file] ?? null,
+		resolveExecutable: async (name) => setup.onPath?.[name] ?? null,
+		env: setup.env ?? {},
+		homedir: "/Users/j",
+	};
+}
+
+const BUN_ROOT = "/Users/j/.bun/install/global/node_modules";
+const BREW_ENV = { HOMEBREW_PREFIX: "/opt/homebrew" };
+const CELLAR = { "/opt/homebrew/Cellar": "/opt/homebrew/Cellar" };
+
+const distTags = (pkg: string, latest: string) => ({
+	[`https://registry.npmjs.org/-/package/${pkg.replace("/", "%2F")}/dist-tags`]:
+		{ ok: true, body: { latest } } as FetchJsonResult,
+});
+
+const pkgJson = (name: string, version: string) =>
+	JSON.stringify({ name, version });
+
+/** A tool whose PATH entry resolves into bun's global tree. */
+function bunWorld(
+	bin: string,
+	pkg: string,
+	installed: string,
+	latest: string,
+): FakeSetup {
+	const pkgDir = `${BUN_ROOT}/${pkg}`;
+	const file = `${pkgDir}/dist/index.js`;
+	const onPath = `/Users/j/.bun/bin/${bin}`;
+	return {
+		env: BREW_ENV,
+		onPath: { [bin]: onPath },
+		real: {
+			[onPath]: file,
+			[file]: file,
+			[pkgDir]: pkgDir,
+			[BUN_ROOT]: BUN_ROOT,
+			...CELLAR,
+		},
+		files: { [`${pkgDir}/package.json`]: pkgJson(pkg, installed) },
+		fetch: distTags(pkg, latest),
+	};
+}
+
+const MNEMEX: BinRequirement = {
+	name: "mnemex",
+	via: "brew",
+	formula: "madappgang/tap/mnemex",
+};
+
+describe("C16 case 1: brew spec, file in bun's global tree", () => {
+	test("managed, versions read, bun upgrade command, state upgrade", async () => {
+		const f = await probeTool(
+			MNEMEX,
+			fakeIO(bunWorld("mnemex", "mnemex", "0.36.1", "0.36.2")),
+		);
+		expect(f.managed).toBe(true);
+		expect(f.installed).toBe("0.36.1");
+		expect(f.latest).toBe("0.36.2");
+		expect(f.upgradeCommand).toEqual({
+			cmd: "bun",
+			args: ["install", "-g", "mnemex@latest"],
+		});
+		const s = classifyTool(MNEMEX, f);
+		expect(s.state).toBe("upgrade");
+		expect(s.target).toBe("0.36.2");
+	});
+});
+
+describe("C16 case 2: latest equals installed", () => {
+	test("state is current", async () => {
+		const f = await probeTool(
+			MNEMEX,
+			fakeIO(bunWorld("mnemex", "mnemex", "0.36.2", "0.36.2")),
+		);
+		expect(f.managed).toBe(true);
+		expect(classifyTool(MNEMEX, f).state).toBe("current");
+	});
+});
+
+describe("C16 case 3: scoped package under bun's tree", () => {
+	test("the package is @scope/tool in the upgrade command", async () => {
+		const spec: BinRequirement = {
+			name: "tool",
+			via: "brew",
+			formula: "madappgang/tap/tool",
+		};
+		const f = await probeTool(
+			spec,
+			fakeIO(bunWorld("tool", "@scope/tool", "1.0.0", "1.1.0")),
+		);
+		expect(f.managed).toBe(true);
+		expect(f.installed).toBe("1.0.0");
+		expect(f.latest).toBe("1.1.0");
+		expect(f.upgradeCommand).toEqual({
+			cmd: "bun",
+			args: ["install", "-g", "@scope/tool@latest"],
+		});
+		expect(classifyTool(spec, f).state).toBe("upgrade");
+	});
+});
+
+describe("C16 case 4: npm global prefix", () => {
+	test("brew spec adopted by npm under the root npm reports", async () => {
+		const root = "/usr/local/lib/node_modules";
+		const pkgDir = `${root}/claudish`;
+		const file = `${pkgDir}/dist/index.js`;
+		const spec: BinRequirement = {
+			name: "claudish",
+			via: "brew",
+			formula: "madappgang/tap/claudish",
+		};
+		const f = await probeTool(
+			spec,
+			fakeIO({
+				env: BREW_ENV,
+				onPath: { claudish: "/usr/local/bin/claudish" },
+				real: {
+					"/usr/local/bin/claudish": file,
+					[file]: file,
+					[pkgDir]: pkgDir,
+					[root]: root,
+					...CELLAR,
+				},
+				files: { [`${pkgDir}/package.json`]: pkgJson("claudish", "10.0.0") },
+				exec: { "npm root -g": { stdout: `${root}\n` } },
+				fetch: distTags("claudish", "10.1.0"),
+			}),
+		);
+		expect(f.managed).toBe(true);
+		expect(f.installed).toBe("10.0.0");
+		expect(f.latest).toBe("10.1.0");
+		expect(f.upgradeCommand).toEqual({
+			cmd: "npm",
+			args: ["install", "-g", "claudish@latest"],
+		});
+		const s = classifyTool(spec, f);
+		expect(s.state).toBe("upgrade");
+		expect(s.target).toBe("10.1.0");
+	});
+});
+
+describe("C16 case 5: pinned npm spec, file in bun's tree", () => {
+	const spec: BinRequirement = {
+		name: "tool",
+		via: "npm",
+		package: "tool",
+		version: "1.0.0",
+	};
+	test("managed, target is the pin, command carries tool@1.0.0", async () => {
+		const f = await probeTool(
+			spec,
+			fakeIO({
+				...bunWorld("tool", "tool", "0.9.0", "2.0.0"),
+				exec: { "npm root -g": { stdout: "/usr/local/lib/node_modules\n" } },
+			}),
+		);
+		expect(f.managed).toBe(true);
+		expect(f.installed).toBe("0.9.0");
+		const args = f.upgradeCommand?.args ?? [];
+		expect(args).toContain("tool@1.0.0");
+		expect(args.some((a) => a.includes("@latest"))).toBe(false);
+		const s = classifyTool(spec, f);
+		expect(s.state).toBe("upgrade");
+		expect(s.target).toBe("1.0.0");
+	});
+});
+
+describe("C16 case 6: file in no node tree, brew spec", () => {
+	const spec: BinRequirement = { name: "uv", via: "brew", formula: "uv" };
+	const world: FakeSetup = {
+		env: BREW_ENV,
+		onPath: { uv: "/Users/j/.local/bin/uv" },
+		real: {
+			"/Users/j/.local/bin/uv": "/Users/j/.local/bin/uv",
+			...CELLAR,
+		},
+	};
+	test("external / not-managed, note names who did not install it", async () => {
+		const f = await probeTool(spec, fakeIO(world));
+		const s = classifyTool(spec, f);
+		expect(s.state).toBe("external");
+		expect(s.reason).toBe("not-managed");
+		expect(s.note).toBe("installed by an installer magus does not update");
+		expect(s.note?.includes("/")).toBe(false);
+	});
+	test("an npm spec gets the same note: it names who installed it, never the spec installer", async () => {
+		const npmSpec: BinRequirement = { name: "uv", via: "npm", package: "uv" };
+		const f = await probeTool(
+			npmSpec,
+			fakeIO({
+				...world,
+				exec: { "npm root -g": { stdout: "/usr/local/lib/node_modules\n" } },
+			}),
+		);
+		const s = classifyTool(npmSpec, f);
+		expect(s.state).toBe("external");
+		expect(s.note).toBe("installed by an installer magus does not update");
+	});
+	test("a pinned spec in that situation stays unknown", async () => {
+		const pinned: BinRequirement = { ...spec, version: "1.0.0" };
+		const f = await probeTool(pinned, fakeIO(world));
+		expect(classifyTool(pinned, f).state).toBe("unknown");
+	});
+});
+
+describe("C16 case 7: operating-system file", () => {
+	test("zsh in /bin is external with the operating-system note", async () => {
+		const spec: BinRequirement = { name: "zsh", via: "brew", formula: "zsh" };
+		const f = await probeTool(
+			spec,
+			fakeIO({
+				env: BREW_ENV,
+				onPath: { zsh: "/bin/zsh" },
+				real: { "/bin/zsh": "/bin/zsh", ...CELLAR },
+			}),
+		);
+		const s = classifyTool(spec, f);
+		expect(s.state).toBe("external");
+		expect(s.reason).toBe("not-managed");
+		expect(s.note).toBe("comes with the operating system");
+	});
+});
+
+describe("C16 case 8: a Homebrew keg is never adopted as an npm install", () => {
+	test("npm spec, file in a keg's libexec/lib/node_modules", async () => {
+		const keg = "/opt/homebrew/Cellar/gemini-cli/0.46.0/libexec";
+		const pkgDir = `${keg}/lib/node_modules/gemini-pkg`;
+		const file = `${pkgDir}/bundle/gemini.js`;
+		const spec: BinRequirement = {
+			name: "gemini",
+			via: "npm",
+			package: "gemini-pkg",
+		};
+		const f = await probeTool(
+			spec,
+			fakeIO({
+				env: BREW_ENV,
+				onPath: { gemini: "/opt/homebrew/bin/gemini" },
+				real: {
+					"/opt/homebrew/bin/gemini": file,
+					[file]: file,
+					[pkgDir]: pkgDir,
+					...CELLAR,
+				},
+				files: { [`${pkgDir}/package.json`]: pkgJson("gemini-pkg", "0.46.0") },
+				exec: { "npm root -g": { stdout: "/opt/homebrew/lib/node_modules\n" } },
+				fetch: distTags("gemini-pkg", "0.50.0"),
+			}),
+		);
+		expect(f.upgradeCommand?.cmd).not.toBe("npm");
+		expect(classifyTool(spec, f).state).not.toBe("upgrade");
+	});
+});

package/src/__tests__/blind/c17-misdirected-update-already-landed.test.ts

@@ -0,0 +1,271 @@
+import {
+	afterAll,
+	beforeAll,
+	beforeEach,
+	describe,
+	expect,
+	test,
+} from "bun:test";
+import { execFileSync } from "node:child_process";
+import os from "node:os";
+import path from "node:path";
+import fs from "fs-extra";
+import {
+	loadedVersionHere,
+	repairStaleLoad,
+} from "../../services/claude-settings.js";
+import {
+	type PluginApplyDeps,
+	applyPlugins,
+} from "../../services/update-engine.js";
+import type {
+	InstalledPluginEntry,
+	InstalledPluginsRegistry,
+} from "../../types/index.js";
+
+/**
+ * Written blind from a spec. The row Claude Code picks for `plugin update`
+ * already holds the target, so the update writes nothing and no row moves.
+ * magus must treat it as the same misdirection as when a row moves.
+ */
+
+const GIT_CFG = [
+	"-c",
+	"user.name=test",
+	"-c",
+	"user.email=test@example.com",
+	"-c",
+	"commit.gpgsign=false",
+	"-c",
+	"init.defaultBranch=main",
+];
+const git = (cwd: string, ...args: string[]) =>
+	execFileSync("git", [...GIT_CFG, ...args], { cwd, encoding: "utf8" }).trim();
+
+const PLUGIN = "madbench@magus";
+const SAME_REPO_DETAIL =
+	"project → 0.5.0 · Claude Code updated another folder of this repository instead of this one — this folder now loads v0.5.0 too";
+
+let base: string;
+let mainTree: string;
+let here: string;
+let gone: string;
+let otherRepo: string;
+let root: string;
+let registryFile: string;
+
+const cacheFor = (version: string) =>
+	path.join(root, "cache", "magus", "madbench", version);
+
+const row = (
+	over: Partial<InstalledPluginEntry> & { version: string },
+): InstalledPluginEntry => ({
+	scope: "project",
+	installPath: cacheFor(over.version),
+	installedAt: "2026-01-01T00:00:00.000Z",
+	lastUpdated: "2026-01-01T00:00:00.000Z",
+	...over,
+});
+
+async function writeRegistry(rows: InstalledPluginEntry[]): Promise<void> {
+	const registry: InstalledPluginsRegistry = {
+		version: 2,
+		plugins: { [PLUGIN]: rows },
+	};
+	await fs.outputJson(registryFile, registry, { spaces: 2 });
+}
+
+const readRegistry = (): Promise<InstalledPluginsRegistry> =>
+	fs.readJson(registryFile);
+
+const versionsByPath = async () =>
+	(await readRegistry()).plugins[PLUGIN].map((e) => [e.projectPath, e.version]);
+
+const hereVersion = async () =>
+	(await readRegistry()).plugins[PLUGIN].find((e) => e.projectPath === here)
+		?.version;
+
+beforeAll(async () => {
+	base = await fs.realpath(
+		await fs.mkdtemp(path.join(os.tmpdir(), "magus-c17-")),
+	);
+	mainTree = path.join(base, "magus-src");
+	here = path.join(mainTree, ".claude", "worktrees", "madbench");
+	gone = path.join(mainTree, ".claude", "worktrees", "gone");
+	otherRepo = path.join(base, "unrelated");
+
+	await fs.ensureDir(mainTree);
+	git(mainTree, "init", "-q");
+	await fs.writeFile(path.join(mainTree, "README.md"), "hello\n");
+	git(mainTree, "add", "-A");
+	git(mainTree, "commit", "-qm", "initial");
+	git(mainTree, "worktree", "add", "-q", "-b", "madbench", here);
+	git(mainTree, "worktree", "add", "-q", "-b", "gone", gone);
+	await fs.remove(gone);
+
+	await fs.ensureDir(otherRepo);
+	git(otherRepo, "init", "-q");
+});
+
+afterAll(async () => {
+	if (base) await fs.remove(base);
+});
+
+beforeEach(async () => {
+	root = await fs.mkdtemp(path.join(base, "plugins-"));
+	registryFile = path.join(root, "installed_plugins.json");
+	for (const v of ["0.3.0", "0.4.0", "0.5.0", "0.6.0"]) {
+		await fs.ensureDir(cacheFor(v));
+	}
+});
+
+/** `claude plugin update` that finds its row already on the target: writes nothing. */
+function deps(): PluginApplyDeps {
+	return {
+		install: async () => {},
+		update: async () => {},
+		repair: async () => {},
+		readInstalled: async () =>
+			(await readRegistry()).plugins[PLUGIN].find((e) => e.projectPath === here)
+				?.version ?? null,
+		saveInstalled: async () => {},
+		registryRows: async () => (await readRegistry()).plugins[PLUGIN],
+		repairStaleLoad: (id, target, projectPath) =>
+			repairStaleLoad(id, target, projectPath, root),
+		loadedVersion: (id, projectPath) =>
+			loadedVersionHere(id, projectPath, root),
+	};
+}
+
+const item = (target: string) => ({
+	pluginId: PLUGIN,
+	pinned: "latest",
+	installed: "0.4.0",
+	available: target,
+	target,
+	action: "update" as const,
+	reason: "behind" as const,
+	scopes: ["project" as const],
+	beforeVersions: { project: "0.4.0" },
+});
+
+function collect() {
+	const details: string[] = [];
+	return {
+		details,
+		reporter: {
+			begin: () => {},
+			finish: (_ok: boolean, _name: string, detail: string) =>
+				details.push(detail),
+			detach: <T>(work: () => T) => work(),
+		},
+	};
+}
+
+const NO_CHANGE = `no change — the installer exited 0 but ${PLUGIN} is still 0.4.0`;
+
+describe("a misdirected update whose row already held the target", () => {
+	test("1: another row of the repository is at the target — this row follows, counted as changed", async () => {
+		await writeRegistry([
+			row({ version: "0.5.0", projectPath: mainTree }),
+			row({ version: "0.4.0", projectPath: here }),
+		]);
+		const { details, reporter } = collect();
+
+		const result = await applyPlugins([item("0.5.0")], here, deps(), reporter);
+
+		expect(result.ok).toBe(1);
+		expect(result.unchanged).toEqual([]);
+		expect(await versionsByPath()).toEqual([
+			[mainTree, "0.5.0"],
+			[here, "0.5.0"],
+		]);
+		expect(details).toEqual([SAME_REPO_DETAIL]);
+		expect(await loadedVersionHere(PLUGIN, here, root)).toBe("0.5.0");
+	});
+
+	test("2: several other rows at the target — still one folder, 'another folder'", async () => {
+		await writeRegistry([
+			row({ version: "0.5.0", projectPath: gone }),
+			row({ version: "0.5.0", projectPath: mainTree }),
+			row({ version: "0.4.0", projectPath: here }),
+		]);
+		const { details, reporter } = collect();
+
+		const result = await applyPlugins([item("0.5.0")], here, deps(), reporter);
+
+		expect(result.ok).toBe(1);
+		expect(result.unchanged).toEqual([]);
+		expect(await hereVersion()).toBe("0.5.0");
+		expect(details).toEqual([SAME_REPO_DETAIL]);
+		expect(details[0]).not.toMatch(/other folders/);
+	});
+
+	test("3 (negative a): the only row at the target is another repository's — no follow", async () => {
+		await writeRegistry([
+			row({ version: "0.5.0", projectPath: otherRepo }),
+			row({ version: "0.4.0", projectPath: mainTree }),
+			row({ version: "0.4.0", projectPath: here }),
+		]);
+		const { details, reporter } = collect();
+
+		const result = await applyPlugins([item("0.5.0")], here, deps(), reporter);
+
+		expect(result.unchanged).toEqual([PLUGIN]);
+		expect(result.ok).toBe(0);
+		expect(await hereVersion()).toBe("0.4.0");
+		expect(details).toEqual([NO_CHANGE]);
+	});
+
+	test("4 (negative b): other repository rows are NEWER than the target — no follow", async () => {
+		await writeRegistry([
+			row({ version: "0.6.0", projectPath: mainTree }),
+			row({ version: "0.4.0", projectPath: here }),
+		]);
+		const { details, reporter } = collect();
+
+		const result = await applyPlugins([item("0.5.0")], here, deps(), reporter);
+
+		expect(result.unchanged).toEqual([PLUGIN]);
+		expect(await hereVersion()).toBe("0.4.0");
+		expect(await versionsByPath()).toEqual([
+			[mainTree, "0.6.0"],
+			[here, "0.4.0"],
+		]);
+		expect(details).toEqual([NO_CHANGE]);
+	});
+
+	test("4b (negative b): other repository rows are OLDER than the target — no follow", async () => {
+		await writeRegistry([
+			row({ version: "0.3.0", projectPath: mainTree }),
+			row({ version: "0.4.0", projectPath: here }),
+		]);
+		const { details, reporter } = collect();
+
+		await applyPlugins([item("0.5.0")], here, deps(), reporter);
+
+		// The older row is not the target, so this row does not follow it. (The
+		// stale-load repair that raises that older row to this one's version is
+		// older behaviour, tested on its own.)
+		expect(await hereVersion()).toBe("0.4.0");
+		expect(details.join("\n")).not.toContain("another folder");
+	});
+
+	test("5: the target is not downloaded — could not follow, row stays", async () => {
+		await writeRegistry([
+			row({ version: "0.5.0", projectPath: mainTree }),
+			row({ version: "0.4.0", projectPath: here }),
+		]);
+		await fs.remove(cacheFor("0.5.0"));
+		const { details, reporter } = collect();
+
+		const result = await applyPlugins([item("0.5.0")], here, deps(), reporter);
+
+		expect(result.unchanged).toEqual([PLUGIN]);
+		expect(await hereVersion()).toBe("0.4.0");
+		expect(details).toHaveLength(1);
+		expect(details[0]).toContain(
+			`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.5.0 is not downloaded — run magus install)`,
+		);
+	});
+});