magus-cli 7.7.0 → 7.9.0

package/src/__tests__/plugin-requires.test.ts

@@ -1,187 +1,172 @@
+/**
+ * plugin-requires locates the plugin.json Claude Code loads and hands its
+ * `requires` to requires-probe; it parses nothing itself.
+ */
+
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { chmodSync, mkdirSync, writeFileSync } from "node:fs";
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import fs from "fs-extra";
 import {
-	parsePluginRequires,
 	readPluginRequires,
+	resolvePluginRequires,
+	selectBins,
 } from "../services/plugin-requires.js";
+import type { Requirement } from "../shared/plugin/hooks/lib/requires-probe.js";
 
-describe("parsePluginRequires", () => {
-	test("parses a valid requires.bin and fills defaults", () => {
-		const requires = parsePluginRequires({
-			name: "terminal",
-			requires: {
-				bin: [
-					{ name: "tmux", via: "brew", formula: "tmux", check: "tmux -V" },
-					{ name: "tmux-mcp", via: "bun", package: "tmux-mcp" },
-				],
-			},
-		});
-		expect(requires.bin).toHaveLength(2);
-		const tmux = requires.bin!.find((b) => b.name === "tmux")!;
-		expect(tmux.via).toBe("brew");
-		expect(tmux.check).toBe("tmux -V");
-		const mcp = requires.bin!.find((b) => b.name === "tmux-mcp")!;
-		// check defaulted from the name
-		expect(mcp.check).toBe("tmux-mcp --version");
-	});
-
-	test("drops entries with no name or an unknown installer", () => {
-		const requires = parsePluginRequires({
-			requires: {
-				bin: [
-					{ via: "bun" }, // no name
-					{ name: "x", via: "cargo" }, // unknown installer
-					{ name: "ok", via: "npm" },
-				],
-			},
-		});
-		expect(requires.bin).toHaveLength(1);
-		expect(requires.bin![0]!.name).toBe("ok");
-	});
+const BUN: Requirement = {
+	name: "bun",
+	check: ["bun", "--version"],
+	install: [{ via: "bootstrap", tool: "bun" }],
+};
+const declares = (bin: Requirement[]) => ({
+	name: "p",
+	requires: { schema: 1, bin },
+});
 
-	test("no requires / non-array bin → empty object", () => {
-		expect(parsePluginRequires({ name: "x" })).toEqual({});
-		expect(parsePluginRequires({ requires: {} })).toEqual({});
-		expect(parsePluginRequires({ requires: { bin: "nope" } })).toEqual({});
-		expect(parsePluginRequires(null)).toEqual({});
-	});
+let dir: string;
+beforeEach(async () => {
+	dir = await fs.realpath(await mkdtemp(join(tmpdir(), "plugreq-")));
+});
+afterEach(async () => {
+	await rm(dir, { recursive: true, force: true });
 });
 
-describe("parsePluginRequires — setup block (the established convention)", () => {
-	test("terminal's setup: go module + required system tool", () => {
-		// The real plugins/terminal/plugin.json shape.
-		const r = parsePluginRequires({
-			name: "terminal",
-			setup: {
-				go: ["github.com/MadAppGang/tmux-mcp@latest"],
-				required: ["tmux"],
-			},
+describe("readPluginRequires", () => {
+	test("parses .claude-plugin/plugin.json through requires-probe", async () => {
+		await fs.outputJson(
+			join(dir, ".claude-plugin", "plugin.json"),
+			declares([BUN]),
+		);
+		expect(await readPluginRequires(dir)).toEqual({
+			ok: true,
+			requirements: [BUN],
 		});
-		const mcp = r.bin!.find((b) => b.name === "tmux-mcp")!;
-		expect(mcp.via).toBe("go");
-		expect(mcp.module).toBe("github.com/MadAppGang/tmux-mcp");
-		expect(mcp.version).toBe("latest");
-		const tmux = r.bin!.find((b) => b.name === "tmux")!;
-		expect(tmux.via).toBe("brew");
-		expect(tmux.formula).toBe("tmux");
 	});
 
-	// Negative control for the /vN fix: basename(base) yields "v2" here, so
-	// without the go-module helper this test FAILS on `name`.
-	test("terminal's v2 pin: /v2 is the module's major version, not the binary", () => {
-		const r = parsePluginRequires({
-			name: "terminal",
+	test("a setup block is read by nothing: without requires the plugin declares nothing", async () => {
+		await fs.outputJson(join(dir, ".claude-plugin", "plugin.json"), {
+			name: "p",
 			setup: { go: ["github.com/MadAppGang/tmux-mcp/v2@v2.0.0"] },
 		});
-		expect(r.bin).toEqual([
-			{
-				name: "tmux-mcp",
-				via: "go",
-				module: "github.com/MadAppGang/tmux-mcp/v2",
-				version: "v2.0.0",
-				check: "tmux-mcp --version",
-			},
-		]);
-	});
-
-	// One manifest per spec: entries are keyed by binary name, so a v1 and a v2
-	// pin of the same module in ONE setup would (correctly) collapse to one.
-	test.each([
-		[
-			"github.com/MadAppGang/tmux-mcp@v1.7.1",
-			{
-				name: "tmux-mcp",
-				module: "github.com/MadAppGang/tmux-mcp",
-				version: "v1.7.1",
-			},
-		],
-		[
-			"github.com/MadAppGang/tmux-mcp/v2",
-			{
-				name: "tmux-mcp",
-				module: "github.com/MadAppGang/tmux-mcp/v2",
-				version: undefined,
-			},
-		],
-		[
-			"github.com/x/v2tool@v1.0.0",
-			{ name: "v2tool", module: "github.com/x/v2tool", version: "v1.0.0" },
-		],
-	])("go spec %s → name/module/version", (spec, expected) => {
-		const r = parsePluginRequires({ setup: { go: [spec] } });
-		expect(
-			r.bin!.map((b) => ({
-				name: b.name,
-				module: b.module,
-				version: b.version,
-			})),
-		).toEqual([expected]);
-	});
-
-	test("browser-use's setup: pip packages", () => {
-		const r = parsePluginRequires({
-			name: "browser-use",
-			setup: { pip: ["browser-use", "mcp"] },
+		expect(await readPluginRequires(dir)).toEqual({
+			ok: true,
+			requirements: [],
 		});
-		expect(r.bin!.map((b) => b.name).sort()).toEqual(["browser-use", "mcp"]);
-		expect(r.bin!.every((b) => b.via === "pip")).toBe(true);
 	});
 
-	test("bun/npm specs split name@version", () => {
-		const r = parsePluginRequires({
-			setup: { bun: ["claudish@1.2.0"], npm: ["@scope/tool@3.0.0"] },
+	test("an invalid declaration is reported, never dropped to empty", async () => {
+		await fs.outputJson(join(dir, ".claude-plugin", "plugin.json"), {
+			name: "p",
+			requires: { schema: 1, bin: [{ name: "x", via: "brew" }] },
 		});
-		const claudish = r.bin!.find((b) => b.name === "claudish")!;
-		expect(claudish.version).toBe("1.2.0");
-		const scoped = r.bin!.find((b) => b.name === "tool")!;
-		expect(scoped.package).toBe("@scope/tool");
-		expect(scoped.version).toBe("3.0.0");
+		const r = await readPluginRequires(dir);
+		expect(r?.ok).toBe(false);
 	});
 
-	test("explicit requires.bin overrides a setup entry of the same name", () => {
-		const r = parsePluginRequires({
-			setup: { required: ["tmux"] }, // → brew
-			requires: {
-				bin: [{ name: "tmux", via: "go", module: "example.com/tmux" }],
-			},
-		});
-		const tmux = r.bin!.find((b) => b.name === "tmux")!;
-		expect(tmux.via).toBe("go"); // requires.bin won
+	test("no manifest → null", async () => {
+		expect(await readPluginRequires(dir)).toBeNull();
 	});
 });
 
-describe("readPluginRequires", () => {
-	let dir: string;
-	beforeEach(async () => {
-		dir = await mkdtemp(join(tmpdir(), "plugreq-"));
-	});
-	afterEach(async () => {
-		await rm(dir, { recursive: true, force: true });
-	});
+describe("resolvePluginRequires reads the copy Claude Code loads", () => {
+	test("the installed copy wins over a newer marketplace clone", async () => {
+		const root = join(dir, "plugins-root");
+		const installed = join(root, "cache", "fixture", "app", "1.0.0");
+		const clone = join(dir, "clone", "app");
+		await fs.outputJson(
+			join(installed, ".claude-plugin", "plugin.json"),
+			declares([BUN]),
+		);
+		await fs.outputJson(join(clone, ".claude-plugin", "plugin.json"), {
+			name: "app",
+		});
+		await fs.outputJson(join(root, "installed_plugins.json"), {
+			version: 2,
+			plugins: {
+				"app@fixture": [
+					{
+						scope: "project",
+						projectPath: dir,
+						installPath: installed,
+						version: "1.0.0",
+						installedAt: "2026-01-01T00:00:00.000Z",
+						lastUpdated: "2026-01-01T00:00:00.000Z",
+					},
+				],
+			},
+		});
+		const found = await resolvePluginRequires("app@fixture", dir, {
+			root,
+			clone: async () => clone,
+		});
+		expect(found?.dir).toBe(installed);
+		expect(found?.parse).toEqual({ ok: true, requirements: [BUN] });
 
-	test("reads plugin.json at the plugin root", async () => {
-		await fs.writeJson(join(dir, "plugin.json"), {
-			name: "p",
-			requires: { bin: [{ name: "tmux", via: "brew" }] },
+		const notInstalled = await resolvePluginRequires("app@fixture", dir, {
+			root: join(dir, "no-registry"),
+			clone: async () => clone,
 		});
-		const r = await readPluginRequires(dir);
-		expect(r.bin?.[0]?.name).toBe("tmux");
+		expect(notInstalled?.dir).toBe(clone);
 	});
+});
 
-	test("falls back to .claude-plugin/plugin.json", async () => {
-		await fs.ensureDir(join(dir, ".claude-plugin"));
-		await fs.writeJson(join(dir, ".claude-plugin", "plugin.json"), {
-			name: "p",
-			requires: { bin: [{ name: "mnemex", via: "bun" }] },
-		});
-		const r = await readPluginRequires(dir);
-		expect(r.bin?.[0]?.name).toBe("mnemex");
+describe("selectBins", () => {
+	function pathWith(...tools: string[]): string {
+		const bin = join(dir, "bin");
+		mkdirSync(bin, { recursive: true });
+		for (const t of tools) {
+			writeFileSync(join(bin, t), "#!/bin/sh\nexit 0\n");
+			chmodSync(join(bin, t), 0o755);
+		}
+		return bin;
+	}
+
+	test("selects each requirement's first usable option, once, and records its root", () => {
+		const reqs: Requirement[] = [
+			BUN,
+			{
+				name: "claudish",
+				check: ["claudish", "--version"],
+				install: [{ via: "bun", package: "claudish", version: "6.0.0" }],
+			},
+			{
+				name: "jq",
+				check: ["jq", "--version"],
+				install: [{ via: "brew", formula: "jq" }],
+			},
+			{
+				name: "zsh",
+				check: ["zsh", "--version"],
+				install: [{ via: "apt", packages: ["zsh"] }],
+			},
+		];
+		const selected = selectBins(reqs, "/plugin", pathWith("brew", "apt-get"));
+		expect(selected.map((b) => [b.name, b.chosen, b.root])).toEqual([
+			// Bun's installer needs curl and unzip, and this PATH has neither.
+			["bun", null, "/plugin"],
+			[
+				"claudish",
+				{ via: "bun", package: "claudish", version: "6.0.0" },
+				"/plugin",
+			],
+			["jq", { via: "brew", formula: "jq" }, "/plugin"],
+			["zsh", { via: "apt", packages: ["zsh"] }, "/plugin"],
+		]);
+		// The declaration itself is carried unchanged.
+		expect(selected[1]?.check).toEqual(["claudish", "--version"]);
 	});
 
-	test("missing manifest → empty", async () => {
-		expect(await readPluginRequires(dir)).toEqual({});
+	test("a brew option is not selected without brew", () => {
+		const reqs: Requirement[] = [
+			{
+				name: "jq",
+				check: ["jq", "--version"],
+				install: [{ via: "brew", formula: "jq" }],
+			},
+		];
+		expect(selectBins(reqs, undefined, pathWith())[0]?.chosen).toBeNull();
 	});
 });

package/src/__tests__/plugin-resolution.test.ts

@@ -191,17 +191,11 @@ describe("isRelevantInstallation", () => {
 		).toBe(false);
 	});
 
-	test("two rootless paths DO match each other, as the original's compare does", () => {
-		// `repoRoot(entry.projectPath) === repoRoot(originalCwd)` with both sides
-		// null is true in the decompiled filter, so a row from any directory in no
-		// repository competes when Claude Code runs from another such directory —
-		// a scratch dir, a home directory, a plain non-git project.
-		//
-		// The port used to answer false here, which made magus name a
-		// `loadedVersion` the loader would not pick in any non-git directory. It is
-		// the loader's answer this module owes, not the more cautious one; what
-		// magus may WRITE is a separate question, pinned in stale-load-repair.test.ts
-		// ("a rootless row from another directory is relevant but NOT rewritten").
+	test("two rootless paths do NOT match each other (Claude Code 2.1.284)", () => {
+		// 2.1.284 guards the root comparison with `cwdRoot !== null`. Before it,
+		// two nulls compared equal and every rootless folder shared every other
+		// rootless folder's rows. Measured with `--debug-file` in a rootless folder:
+		// a row from an existing non-git folder did not load there.
 		const loose = path.join(base, "loose");
 		expect(
 			isRelevantInstallation(
@@ -212,12 +206,57 @@ describe("isRelevantInstallation", () => {
 				loose,
 				repoRootForPath(loose),
 			),
+		).toBe(false);
+	});
+
+	test("in a rootless folder its own row and USER rows still count", () => {
+		const loose = path.join(base, "loose");
+		const looseRoot = repoRootForPath(loose);
+		expect(looseRoot).toBeNull();
+		expect(
+			isRelevantInstallation(
+				entry({ version: "1.0.0", projectPath: loose }),
+				loose,
+				looseRoot,
+			),
+		).toBe(true);
+		expect(
+			isRelevantInstallation(
+				entry({ version: "1.0.0", scope: "user", projectPath: undefined }),
+				loose,
+				looseRoot,
+			),
+		).toBe(true);
+	});
+
+	test("a row's path is compared RAW, as the binary compares it: '/p/a/' is not '/p/a' in a rootless folder", () => {
+		// Normalising the row's path made this pair relevant — and in a rootless
+		// folder nothing else could, since the root comparison matches nothing —
+		// so the port named a row the loader rejects.
+		const loose = path.join(base, "loose");
+		const looseRoot = repoRootForPath(loose);
+		expect(looseRoot).toBeNull();
+		expect(
+			isRelevantInstallation(
+				entry({ version: "1.0.0", projectPath: `${loose}/` }),
+				loose,
+				looseRoot,
+			),
+		).toBe(false);
+		// The caller's directory stands in for the binary's own working
+		// directory, which is always absolute with no trailing slash.
+		expect(
+			isRelevantInstallation(
+				entry({ version: "1.0.0", projectPath: loose }),
+				`${loose}/`,
+				looseRoot,
+			),
 		).toBe(true);
 	});
 
 	test("a rootless row is still irrelevant to a directory inside a repository", () => {
-		// The null-matches-null rule must not leak the other way: `cwdRoot` is a
-		// real root here, so a rootless row's null root does not equal it.
+		// `cwdRoot` is a real root here, so a rootless row's null root does not
+		// equal it.
 		expect(
 			isRelevantInstallation(
 				entry({ version: "1.0.0", projectPath: path.join(base, "loose") }),

package/src/__tests__/plugin-row-text.test.ts

@@ -140,7 +140,7 @@ describe("pluginRowText — orphans say what the CLI says (F9)", () => {
 	// match, and it cannot tell a move from a dual publication: claudish ships
 	// to two marketplaces with both copies installed, and the row announced
 	// "moved → magus" about a plugin that had not moved anywhere.
-	test("an orphan is 'not offered', and never names a destination", () => {
+	test("an orphan is deprecated, and never names a destination", () => {
 		const seo = info({
 			id: "seo@magus",
 			version: "1.8.0",
@@ -149,16 +149,15 @@ describe("pluginRowText — orphans say what the CLI says (F9)", () => {
 			projectScope: { installed: true, version: "1.8.0" },
 		});
 		const row = rows([seo]).get(seo.id) as PluginPluginItem;
-		expect(cliNote([seo], seo.id)).toBe(
-			"not offered by any configured marketplace",
-		);
+		expect(cliNote([seo], seo.id)).toBe("no longer published");
+		// The row's own words, not the note: the verdict and the key that acts.
 		expect(pluginRowText(row).text).toBe(
-			" v1.8.0 ? not offered by any configured marketplace",
+			" v1.8.0 deprecated — press a to remove",
 		);
 		expect(pluginRowText(row).text).not.toMatch(/moved/i);
 	});
 
-	test("an orphan from a marketplace we DID read is 'not offered'", () => {
+	test("an orphan from a marketplace we DID read is deprecated", () => {
 		const gone = info({
 			id: "gone@magus",
 			version: "2.0.0",
@@ -168,14 +167,12 @@ describe("pluginRowText — orphans say what the CLI says (F9)", () => {
 		});
 		const row = rows([gone]).get(gone.id) as PluginPluginItem;
 		expect(pluginRowText(row).text).toBe(
-			` v2.0.0 ? ${cliNote([gone], gone.id)}`,
-		);
-		expect(pluginRowText(row).text).toContain(
-			"not offered by any configured marketplace",
+			" v2.0.0 deprecated — press a to remove",
 		);
+		expect(row.status?.action).toBe("remove");
 	});
 
-	test("the old words are gone: no 'deprecated', no 'moved →'", () => {
+	test("the old words are gone: no 'moved →', and no marketplace wording", () => {
 		const seo = info({
 			id: "seo@magus",
 			installedVersion: "1.8.0",
@@ -183,14 +180,14 @@ describe("pluginRowText — orphans say what the CLI says (F9)", () => {
 			projectScope: { installed: true, version: "1.8.0" },
 		});
 		const { text } = pluginRowText(rows([seo]).get(seo.id) as PluginPluginItem);
-		expect(text).not.toContain("deprecated");
+		expect(text).not.toMatch(/marketplace/i);
 		expect(text).not.toContain("moved →");
 	});
 });
 
-describe("pluginRowText — history badges combine with the state", () => {
-	const updated = (over: Partial<PluginInfo>) =>
-		info({
+describe("pluginRowText — the current version and the state, no history", () => {
+	const row = (over: Partial<PluginInfo>) => {
+		const p = info({
 			id: "terminal@magus",
 			version: "3.3.1",
 			installedVersion: "3.0.1",
@@ -198,40 +195,36 @@ describe("pluginRowText — history badges combine with the state", () => {
 			author: { name: "MadAppGang" },
 			...over,
 		});
+		return rows([p]).get(p.id) as PluginPluginItem;
+	};
 
-	test("'updated' and a pending update are both shown", () => {
-		// An external update moved 2.9.0 → 3.0.1 while 3.3.1 is already out.
-		const p = updated({ recentlyUpdatedFrom: "2.9.0" });
-		const row = rows([p]).get(p.id) as PluginPluginItem;
-		const { text, segments } = pluginRowText(row);
-		expect(text).toBe(" v2.9.0 → v3.0.1 updated → v3.3.1 available");
-		expect(segments.map((s) => s.tone)).toEqual(["success", "warning"]);
+	test("a pending update: the installed version, then what is available", () => {
+		const { text, segments } = pluginRowText(row({}));
+		expect(text).toBe(" v3.0.1 → v3.3.1 available");
+		expect(segments.map((s) => s.tone)).toEqual(["muted", "warning"]);
 	});
 
-	test("'new' and a pending update are both shown", () => {
-		const p = updated({ recentlyInstalled: true });
-		const row = rows([p]).get(p.id) as PluginPluginItem;
-		expect(pluginRowText(row).text).toBe(" v3.0.1 new → v3.3.1 available");
+	test("NEGATIVE CONTROL: no 'updated' or 'new' badge — the row has no memory of earlier versions", () => {
+		// The badge rendered "v1.8.0 → v1.7.4 updated → v1.8.0 available": a
+		// downgrade called "updated". A row now says nothing about what changed.
+		const text = pluginRowText(row({})).text;
+		expect(text).not.toContain("updated");
+		expect(text).not.toContain(" new");
 	});
 
-	test("'new' with no displayable version still says new", () => {
-		const p = updated({
-			recentlyInstalled: true,
+	test("an unknown version is not printed", () => {
+		const r = row({
 			version: "0.0.0",
 			installedVersion: "0.0.0",
 			projectScope: { installed: true, version: "0.0.0" },
 		});
-		const row = rows([p]).get(p.id) as PluginPluginItem;
-		expect(pluginRowText(row).text).toBe(" new");
+		expect(pluginRowText(r).text).not.toContain("v0.0.0");
 	});
 
 	test("a current row shows only its version", () => {
-		const p = updated({
-			version: "3.0.1",
-		});
-		const row = rows([p]).get(p.id) as PluginPluginItem;
-		expect(row.status?.action).toBe("current");
-		expect(pluginRowText(row).text).toBe(" v3.0.1");
+		const r = row({ version: "3.0.1" });
+		expect(r.status?.action).toBe("current");
+		expect(pluginRowText(r).text).toBe(" v3.0.1");
 	});
 });
 

package/src/__tests__/profile-dependencies.test.ts

@@ -141,6 +141,13 @@ describe("the render enables what the profile's plugins depend on", () => {
 			"lib@mkt",
 			"shared@other",
 		]);
+		// Which plugin asked for each — what `magus update` names when a derived
+		// dependency is no longer published.
+		expect(closure.dependencies?.requiredBy).toEqual({
+			"lib@mkt": "app@mkt",
+			"core@mkt": "lib@mkt",
+			"shared@other": "core@mkt",
+		});
 		await start(manifest, "only");
 		expect(await enabled()).toEqual({
 			"app@mkt": true,

package/src/__tests__/profile-startup-old-format.test.ts

@@ -60,7 +60,6 @@ const out = {
 	described: null,
 	options: null,
 	updateFormatValue: startup.UPDATE_FORMAT_VALUE,
-	notices: null,
 	error: null,
 };
 try {
@@ -78,7 +77,6 @@ try {
 			mode === "convert" ? { convert: true } : undefined,
 		);
 		out.need = { state: prepared.need.state };
-		out.notices = prepared.notices;
 	}
 } catch (e) {
 	out.error = e instanceof Error ? (e.stack ?? e.message) : String(e);
@@ -93,7 +91,6 @@ interface OldFormatRun {
 	described: { title: string; message: string } | null;
 	options: Array<{ label: string; value: string; meta?: string }> | null;
 	updateFormatValue: string;
-	notices: string[] | null;
 	error: string | null;
 }