magus-cli 7.8.0 → 7.9.1

package/src/__tests__/blind-780-cli-tools.test.ts

@@ -17,10 +17,10 @@
  *   C5 stepFailureReport: settings file that does not parse, fallback fix → "C5"
  *   C6 no internal word or absolute binary path in headline/reason       → "C6"
  *
- * Errors are built in the shape Node's promisified `execFile` rejects with:
- * an Error whose message starts "Command failed: <cmd>", carrying `code`,
- * `killed`, `signal`, `stdout` and `stderr`; a missing executable is a
- * `spawn <cmd> ENOENT` with `code: "ENOENT"`. Nothing is spawned.
+ * Failures are built in the shape `runArgv` resolves with (`RunResult`):
+ * the exit code, whether the timeout killed it, the combined output tail, and
+ * for a missing executable a `spawn <cmd> ENOENT` spawn error. Nothing is
+ * spawned.
  */
 
 import { describe, expect, test } from "bun:test";
@@ -40,6 +40,7 @@ import {
 } from "../ui/adapters/startupReports.js";
 import type { FailureReport } from "../ui/state/types.js";
 import type { Command } from "../utils/command-utils.js";
+import type { RunResult } from "../utils/run.js";
 
 /** The installer timeout the spec names: 60 seconds. */
 const TIMEOUT_MS = 60_000;
@@ -73,42 +74,43 @@ interface ExecErrorShape {
 	code?: number | string | null;
 	killed?: boolean;
 	signal?: string | null;
-	/** Extra lines appended to the "Command failed:" message. */
-	messageTail?: string;
 }
 
-/** What promisified `execFile` rejects with when the command ran and failed. */
-function execError(o: ExecErrorShape): Error {
-	const cmdLine = line(o.command);
-	const err = new Error(
-		`Command failed: ${cmdLine}${o.messageTail ? `\n${o.messageTail}` : ""}`,
-	);
-	return Object.assign(err, {
-		cmd: cmdLine,
-		code: o.code === undefined ? 1 : o.code,
-		killed: o.killed ?? false,
+/** What `runArgv` resolves with when the command ran and failed. */
+function execError(o: ExecErrorShape): RunResult {
+	return {
+		exitCode:
+			typeof o.code === "number" ? o.code : o.code === undefined ? 1 : null,
 		signal: o.signal ?? null,
-		stdout: o.stdout ?? "",
-		stderr: o.stderr ?? "",
-	});
+		timedOut: o.killed ?? false,
+		outputTail: [o.stdout ?? "", o.stderr ?? ""].filter(Boolean).join("\n"),
+		durationMs: 0,
+	};
+}
+
+/** What `runArgv` resolves with when the executable does not exist. */
+function enoent(command: Command): RunResult {
+	return {
+		exitCode: null,
+		signal: null,
+		timedOut: false,
+		spawnError: `spawn ${command.cmd} ENOENT`,
+		outputTail: "",
+		durationMs: 0,
+	};
 }
 
-/** What `execFile` rejects with when the executable does not exist. */
-function enoent(command: Command): Error {
-	const err = new Error(`spawn ${command.cmd} ENOENT`);
-	return Object.assign(err, {
+/** What a spawn throws when the executable does not exist (a step's error). */
+function enoentError(command: Command): Error {
+	return Object.assign(new Error(`spawn ${command.cmd} ENOENT`), {
 		code: "ENOENT",
-		errno: -2,
 		syscall: `spawn ${command.cmd}`,
 		path: command.cmd,
-		spawnargs: [...command.args],
-		stdout: "",
-		stderr: "",
 	});
 }
 
-/** What `execFile` rejects with when its `timeout` killed the child. */
-function timedOut(command: Command, partialStderr = ""): Error {
+/** What `runArgv` resolves with when its timeout killed the child. */
+function timedOut(command: Command, partialStderr = ""): RunResult {
 	return execError({
 		command,
 		code: null,
@@ -241,13 +243,11 @@ describe("C1 commandFailureReason", () => {
 				command: BREW_UPGRADE,
 				stdout: "==> Fetching downloads for: tmux",
 				stderr: 'Error: No available formula with the name "tmux-nope".',
-				messageTail: "some other text from the message",
 			}),
 			TIMEOUT_MS,
 		);
 		expect(reason).toContain("No available formula");
 		expect(reason).not.toContain("Fetching downloads");
-		expect(reason).not.toContain("some other text from the message");
 	});
 
 	test("C1: is one line, even when stderr has many", () => {
@@ -319,25 +319,13 @@ describe("C1 commandFailureReason", () => {
 		expect(reason.trim().length).toBeGreaterThan(0);
 	});
 
-	test("C1: never returns 'Command failed:' when the cause is only in the message tail", () => {
+	test("C1: an installer that printed nothing still yields a non-empty reason", () => {
 		const reason = commandFailureReason(
 			NPM_INSTALL,
-			execError({
-				command: NPM_INSTALL,
-				messageTail:
-					"npm error 404 Not Found - GET https://npm.example.test/x - Not found",
-			}),
+			execError({ command: NPM_INSTALL }),
 			TIMEOUT_MS,
 		);
-		expect(reason).not.toContain("Command failed");
-		expect(reason.trim().length).toBeGreaterThan(0);
-	});
-
-	test("C1: something that is not an Error still yields a non-empty reason", () => {
-		const reason = commandFailureReason(NPM_INSTALL, "boom", TIMEOUT_MS);
-		expect(typeof reason).toBe("string");
-		expect(reason.trim().length).toBeGreaterThan(0);
-		expect(reason).not.toContain("Command failed");
+		expect(reason).toBe("npm exited with code 1");
 	});
 });
 
@@ -664,7 +652,7 @@ describe("C5 stepFailureReport", () => {
 		const report = stepFailureReport(
 			"Plugins were not refreshed",
 			"magus",
-			enoent({ cmd: "claude", args: ["plugin", "marketplace", "update"] }),
+			enoentError({ cmd: "claude", args: ["plugin", "marketplace", "update"] }),
 			"Run it yourself: claude plugin marketplace update magus",
 		);
 		const fixes = fixesOf(report);
@@ -791,7 +779,7 @@ describe("C6 no internal word in any headline or reason", () => {
 			stepFailureReport(
 				"Plugins were not refreshed",
 				"magus",
-				enoent(ABS_CLAUDE),
+				enoentError(ABS_CLAUDE),
 			),
 		],
 	];

package/src/__tests__/blind-780-review2.test.ts

@@ -58,7 +58,6 @@ import {
 } from "../ui/adapters/pluginsAdapter.js";
 import {
 	activationFailureReport,
-	marketplaceRefreshReport,
 	profileProblemRow,
 	profileProblemsReport,
 	staleRepairReport,
@@ -449,30 +448,6 @@ describe("U4 failed stale-load repairs", () => {
 	});
 });
 
-// ---------------------------------------------------------------------------
-// U5
-// ---------------------------------------------------------------------------
-
-describe("U5 a failed marketplace refresh", () => {
-	test("U5 the row's subject is the marketplace name", () => {
-		const r = marketplaceRefreshReport([
-			{
-				marketplace: "magus-marketing",
-				error: new Error("fatal: unable to access remote"),
-			},
-		]);
-		expect(r).not.toBeNull();
-		const report = r as FailureReport;
-		expect(report.rows).toHaveLength(1);
-		expect((report.rows[0] as FailureRow).subject).toBe("magus-marketing");
-	});
-
-	test("U5 nothing failed → no report", () => {
-		const r = marketplaceRefreshReport([]);
-		expect(r === null || r.rows.length === 0).toBe(true);
-	});
-});
-
 // ---------------------------------------------------------------------------
 // U6
 // ---------------------------------------------------------------------------

package/src/__tests__/cli-apply-seams.test.ts

@@ -1,8 +1,7 @@
 /**
- * Tests for the three progress seams the animated report depends on.
+ * Tests for the progress seams the animated report depends on.
  *
- * All three shipped untested: `ApplyReporter`, `checkBinaries`'s `onProbe`, and
- * the coupling between the apply meter's denominator and the items the apply
+ * Both shipped untested: `ApplyReporter`, and the coupling between the apply meter's denominator and the items the apply
  * loop actually touches. A review found that last one hand-duplicated
  * `applyPlugins`'s skip conditions and replicated only one of the two, so a
  * plan containing an actionable plugin with no scopes would leave the bar stuck
@@ -13,7 +12,6 @@
 import { describe, expect, mock, test } from "bun:test";
 import { parseArgs } from "../cli/update.js";
 import type { PluginScope } from "../services/claude-cli.js";
-import { checkBinaries } from "../services/doctor-bins.js";
 import {
 	type ApplyReporter,
 	type PluginApplyDeps,
@@ -22,7 +20,6 @@ import {
 	pluginNeedsWork,
 } from "../services/update-engine.js";
 import type { PluginUpdateItem } from "../services/update-plan.js";
-import type { ResolvedBin } from "../types/index.js";
 
 const PROJECT = "/tmp/project";
 
@@ -224,65 +221,3 @@ describe("installPluginInScope — the scope-targeted path", () => {
 		expect(saved).toEqual([]);
 	});
 });
-
-describe("checkBinaries onProbe", () => {
-	const bins: ResolvedBin[] = [
-		{ name: "tmux", via: "brew", sources: [] } as unknown as ResolvedBin,
-		{ name: "tmux-mcp", via: "bun", sources: [] } as unknown as ResolvedBin,
-		{ name: "jq", via: "brew", sources: [] } as unknown as ResolvedBin,
-	];
-
-	test("fires once per binary, before its probe, with a stable total", async () => {
-		// Before the probe matters: the point is to name the binary the command
-		// is currently blocked on, not the one it just finished.
-		const seen: Array<[string, number, number]> = [];
-		const order: string[] = [];
-		await checkBinaries(
-			bins,
-			async (name) => {
-				order.push(`probe:${name}`);
-				return true;
-			},
-			(name, index, total) => {
-				order.push(`announce:${name}`);
-				seen.push([name, index, total]);
-			},
-		);
-
-		expect(seen).toEqual([
-			["tmux", 0, 3],
-			["tmux-mcp", 1, 3],
-			["jq", 2, 3],
-		]);
-		expect(order.slice(0, 2)).toEqual(["announce:tmux", "probe:tmux"]);
-	});
-
-	test("the index is 0-based, so done/total needs index+1", async () => {
-		// A meter fed the raw index reads 0/3 while the first probe runs, which
-		// is correct — it has finished none of them.
-		const first: number[] = [];
-		await checkBinaries(
-			bins,
-			async () => true,
-			(_n, index) => first.push(index),
-		);
-		expect(first[0]).toBe(0);
-		expect(first.at(-1)).toBe(bins.length - 1);
-	});
-
-	test("no callback means no behaviour change", async () => {
-		const results = await checkBinaries(bins, async () => false);
-		expect(results.map((r) => r.present)).toEqual([false, false, false]);
-	});
-
-	test("an empty bin list announces nothing", async () => {
-		const seen: string[] = [];
-		const results = await checkBinaries(
-			[],
-			async () => true,
-			(n) => seen.push(n),
-		);
-		expect(results).toEqual([]);
-		expect(seen).toEqual([]);
-	});
-});

package/src/__tests__/cli-tool-commands.test.ts

@@ -25,12 +25,18 @@
  */
 
 import { describe, expect, test } from "bun:test";
-import { cliTools } from "../data/cli-tools.js";
+import { readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { cliTools as catalogue, isOwnedEntry } from "../data/cli-tools.js";
 import {
 	type InstallMethod,
 	cliToolInstall,
 	cliToolUninstall,
 	cliToolUpdate,
+	isPluginManagedItem,
+	ownedCliTool,
+	resolveCatalogue,
+	unownedCatalogue,
 } from "../services/cli-tool-commands.js";
 import { versionFromPypiJson } from "../services/tool-probe.js";
 import {
@@ -38,6 +44,7 @@ import {
 	type PythonCliInstaller,
 	resolvePythonCliInstaller,
 } from "../services/toolchain.js";
+import { parseRequires } from "../shared/plugin/hooks/lib/requires-probe.js";
 import { type Command, formatCommand } from "../utils/command-utils.js";
 
 const byProbe = (probe: string): PythonCliInstaller => {
@@ -47,10 +54,129 @@ const byProbe = (probe: string): PythonCliInstaller => {
 };
 const PYTHON_PROBES = PYTHON_CLI_INSTALLERS.map((i) => i.probe);
 
+/** The catalogue entries that carry their own installer (no plugin owns them). */
+const cliTools = unownedCatalogue().map((c) => c.tool);
+
+/** Every requirement the repo's plugins declare, by name → the plugins declaring it. */
+function declaredRequirements(): Map<string, string[]> {
+	const pluginsDir = join(import.meta.dir, "..", "..", "..", "..", "plugins");
+	const out = new Map<string, string[]>();
+	for (const plugin of readdirSync(pluginsDir)) {
+		let manifest: unknown;
+		try {
+			manifest = JSON.parse(
+				readFileSync(
+					join(pluginsDir, plugin, ".claude-plugin", "plugin.json"),
+					"utf8",
+				),
+			);
+		} catch {
+			continue;
+		}
+		const parsed = parseRequires(manifest);
+		if (!parsed.ok) continue;
+		for (const r of parsed.requirements) {
+			out.set(r.name, [...(out.get(r.name) ?? []), plugin]);
+		}
+	}
+	return out;
+}
+
 /** The methods the resolver models, i.e. the ones that reach toolchain.ts. */
 const RESOLVED_METHODS: InstallMethod[] = ["npm", "bun", "brew", "pip"];
 
 describe("the catalogue is well-formed", () => {
+	test("no catalogue entry restates a requirement a plugin declares", () => {
+		// A tool a plugin declares is owned by that plugin: the catalogue keeps its
+		// display fields and `ownedBy`, and its check and installer come from the
+		// declaration. A second copy here is what drifted before.
+		const declared = declaredRequirements();
+		expect(declared.size).toBeGreaterThan(0);
+		for (const entry of catalogue) {
+			if (isOwnedEntry(entry)) {
+				const [plugin] = entry.ownedBy.split("@");
+				expect(declared.get(entry.name) ?? []).toContain(plugin);
+				expect("packageName" in entry).toBe(false);
+				expect("checkCommand" in entry).toBe(false);
+			} else {
+				expect(declared.has(entry.name)).toBe(false);
+			}
+		}
+		expect(catalogue.some(isOwnedEntry)).toBe(true);
+	});
+
+	test("an owned row takes its check and installer from the plugin's declaration", async () => {
+		const owned = await resolveCatalogue(
+			"/nonexistent",
+			async (pluginId, name) =>
+				pluginId === "claudish@magus"
+					? {
+							name,
+							check: [name, "--version"],
+							install: [{ via: "bun", package: name }],
+							chosen: { via: "bun", package: name },
+						}
+					: null,
+		);
+		const claudish = owned.find(
+			(c) => !isPluginManagedItem(c) && c.tool.name === "claudish",
+		);
+		expect(
+			claudish && !isPluginManagedItem(claudish) && claudish.tool,
+		).toMatchObject({
+			checkCommand: "claudish --version",
+			packageManager: "bun",
+			packageName: "claudish",
+		});
+		expect(claudish?.owned?.sources).toEqual(["plugin:claudish@magus"]);
+		// An owned entry whose declaration cannot be read here is left out.
+		const names = owned.map((c) =>
+			isPluginManagedItem(c) ? c.entry.name : c.tool.name,
+		);
+		expect(names).not.toContain("mnemex");
+		// One whose chosen install is not version-managed cannot be a row.
+		const entry = catalogue.find((e) => e.name === "claudish");
+		expect(
+			entry &&
+				ownedCliTool(entry, {
+					name: "claudish",
+					check: ["claudish"],
+					install: [],
+					chosen: { via: "apt", packages: ["claudish"] },
+				}),
+		).toBeNull();
+	});
+
+	test("an owned tool its plugin installs from a release is a plugin-managed row, in catalogue order", async () => {
+		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 items = await resolveCatalogue("/nonexistent", async (_id, name) => ({
+			name,
+			check: [name, "--version"],
+			install: [release],
+			chosen: release,
+		}));
+		const names = items.map((c) =>
+			isPluginManagedItem(c) ? c.entry.name : c.tool.name,
+		);
+		// Nothing dropped: the catalogue, in its own order.
+		expect(names).toEqual(catalogue.map((e) => e.name));
+		const managed = items.filter(isPluginManagedItem);
+		expect(managed.map((m) => [m.entry.name, m.entry.ownedBy])).toEqual(
+			catalogue.filter(isOwnedEntry).map((e) => [e.name, e.ownedBy]),
+		);
+		for (const m of managed) {
+			expect(m.owned.chosen).toEqual(release);
+			expect(m.owned.sources).toEqual([`plugin:${m.entry.ownedBy}`]);
+		}
+	});
+
 	test("it has entries, and each names a package manager and a package", () => {
 		// Guard: every assertion below iterates the catalogue, so an empty or
 		// malformed one would make them all pass vacuously.
@@ -71,11 +197,10 @@ describe("no builder ever emits a bare `pip`", () => {
 			const cmd = cliToolInstall(tool);
 			expect(cmd.cmd).not.toBe("pip");
 			if (tool.packageManager === "pip") {
-				// Whatever the machine running this resolved to, it must be one of
-				// the three modelled installers — and `cmd` must BE that probe,
-				// since that is the executable the syscall looks up.
-				expect(PYTHON_PROBES).toContain(cmd.cmd);
-				expect(cmd.cmd).toBe(resolvePythonCliInstaller().probe);
+				// requires-probe renders the profile-only pip kind as a uv tool
+				// install: the package gets its own env, immune to PEP 668.
+				expect(cmd.cmd).toBe("uv");
+				expect(cmd.args.slice(0, 2)).toEqual(["tool", "install"]);
 			}
 		}
 	});

package/src/__tests__/cli-tools-adapter.test.ts

@@ -7,7 +7,6 @@
  */
 
 import { describe, expect, test } from "bun:test";
-import { cliTools } from "../data/cli-tools.js";
 import { cliToolInstall } from "../services/cli-tool-commands.js";
 import {
 	type ToolFacts,
@@ -18,13 +17,17 @@ import { binCommandFor } from "../services/update-engine.js";
 import { planBinUpdates } from "../services/update-plan.js";
 import type { ResolvedBin } from "../types/index.js";
 import {
+	type PluginManagedRow,
 	buildToolRow,
 	cliToolStatusText,
 	countToolRows,
+	isPluginManagedRow,
+	rowName,
 } from "../ui/adapters/cliToolsAdapter.js";
+import { testCatalogue } from "./fixtures/bins.js";
 
 const catalogue = (name: string) => {
-	const tool = cliTools.find((t) => t.name === name);
+	const tool = testCatalogue().find((t) => t.name === name);
 	if (!tool) throw new Error(`no catalogue tool ${name}`);
 	return tool;
 };
@@ -294,4 +297,51 @@ describe("countToolRows — header counts from states", () => {
 			unverified: 1,
 		});
 	});
+
+	test("a plugin-managed row counts from its probe answer, and never as an update", () => {
+		const managed = (
+			presence: PluginManagedRow["presence"],
+		): PluginManagedRow => ({
+			managedBy: "claudish@magus",
+			entry: {
+				name: "claudish",
+				displayName: "Claudish",
+				description: "",
+				website: "",
+				category: "ai-coding",
+				ownedBy: "claudish@magus",
+			},
+			owned: {
+				name: "claudish",
+				check: ["claudish", "--version"],
+				install: [],
+				chosen: null,
+				sources: ["plugin:claudish@magus"],
+			},
+			presence,
+			installText: "",
+		});
+		const rows = [
+			managed({ name: "claudish", status: "present" }),
+			managed({ name: "claudish", status: "off-path", prefix: "~/.local/bin" }),
+			managed({ name: "claudish", status: "missing" }),
+			managed({ name: "claudish", status: "unknown", reason: "slow" }),
+			managed(null),
+		];
+		expect(countToolRows(rows)).toEqual({
+			installed: 2,
+			updates: 0,
+			unverified: 1,
+		});
+		expect(rows.every(isPluginManagedRow)).toBe(true);
+		expect(rowName(rows[0] as PluginManagedRow)).toBe("claudish");
+		const tool = catalogue("mnemex");
+		const tracked = buildToolRow(
+			tool,
+			specForCatalogTool(tool, null, undefined),
+			undefined,
+		);
+		expect(isPluginManagedRow(tracked)).toBe(false);
+		expect(rowName(tracked)).toBe("mnemex");
+	});
 });

package/src/__tests__/cli-tools-plugin-managed.test.tsx

@@ -0,0 +1,83 @@
+/**
+ * A catalogue tool its plugin installs without a version magus can track
+ * (claudish and mnemex from their releases off Homebrew) is drawn read-only:
+ * the row says which plugin manages it, the detail pane says it cannot be
+ * acted on here, and no Enter action is drawn. Rendered through OpenTUI's
+ * test renderer; no IO.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { testRender } from "@opentui/react/test-utils";
+import { act } from "react";
+import type { PluginManagedRow } from "../ui/adapters/cliToolsAdapter.js";
+import {
+	renderCliToolDetail,
+	renderCliToolRow,
+} from "../ui/renderers/cliToolRenderers.js";
+
+function row(presence: PluginManagedRow["presence"]): PluginManagedRow {
+	return {
+		managedBy: "claudish@magus",
+		entry: {
+			name: "claudish",
+			displayName: "Claudish",
+			description: "Run Claude Code with any model",
+			website: "https://github.com/MadAppGang/claudish",
+			category: "ai-coding",
+			ownedBy: "claudish@magus",
+		},
+		owned: {
+			name: "claudish",
+			check: ["claudish", "--version"],
+			install: [],
+			chosen: null,
+			sources: ["plugin:claudish@magus"],
+		},
+		presence,
+		installText: "cd $(mktemp -d) && curl -fsSLO https://example/claudish",
+	};
+}
+
+async function frame(node: React.ReactNode, width = 80): Promise<string> {
+	const { captureCharFrame, renderOnce, renderer } = await testRender(
+		<box flexDirection="column">{node}</box>,
+		{ width, height: 20 },
+	);
+	await act(async () => {
+		await renderOnce();
+		await renderOnce();
+	});
+	const out = captureCharFrame();
+	await act(async () => renderer.destroy());
+	return out;
+}
+
+describe("a plugin-managed CLI tool row", () => {
+	test("the row names the plugin that manages it", async () => {
+		const out = await frame(
+			renderCliToolRow(row({ name: "claudish", status: "present" }), 0, false),
+		);
+		expect(out).toContain("● Claudish · managed by claudish@magus");
+	});
+
+	test("missing: the detail says so, shows the plugin's install, and offers no Enter", async () => {
+		const out = await frame(
+			renderCliToolDetail(row({ name: "claudish", status: "missing" }), 70),
+			70,
+		);
+		expect(out).toContain("Status   ○ Not installed");
+		expect(out).toContain("Managed  by claudish@magus");
+		expect(out).toContain("Install  cd $(mktemp -d)");
+		// The note wraps at the pane's width; read it as prose.
+		const prose = out.replace(/\s+/g, " ");
+		expect(prose).toContain(
+			"claudish@magus installs claudish and decides its version; it cannot be installed, updated or removed from here. magus doctor --fix installs it when it is missing.",
+		);
+		expect(out).not.toContain("Enter");
+	});
+
+	test("while it is being checked, the row says so", async () => {
+		const out = await frame(renderCliToolRow(row(null), 0, false));
+		expect(out).toContain("○ Claudish ...");
+	});
+});