magus-cli 7.8.0 → 7.9.1

package/src/ui/renderers/cliToolRenderers.tsx

@@ -5,14 +5,18 @@ import {
 	cliToolUninstall,
 	uninstallBlocker,
 } from "../../services/cli-tool-commands.js";
+import { doctorFixCommand } from "../../shared/plugin/hooks/lib/requires-probe.js";
 import { formatCommand } from "../../utils/command-utils.js";
 import {
 	type CliToolEnterAction,
 	type CliToolRow,
+	type CliToolsRow,
+	type PluginManagedRow,
 	cliToolEnterAction,
 	cliToolStatusText,
 	displayVersion,
 	isInstalled,
+	isPluginManagedRow,
 } from "../adapters/cliToolsAdapter.js";
 import { rowLead } from "../components/primitives/index.js";
 import { type UiColor, theme } from "../theme.js";
@@ -94,13 +98,139 @@ function toneColor(tone: StatusTone): UiColor {
 	}
 }
 
+// ─── Plugin-managed rows ───────────────────────────────────────────────────────
+
+/** The mark and words for a plugin-managed row, from the dependency probe. */
+function managedStatus(presence: PluginManagedRow["presence"]): {
+	icon: string;
+	color: UiColor;
+	text: string;
+} {
+	switch (presence?.status) {
+		case undefined:
+			return { icon: "○", color: theme.colors.muted, text: "● Checking..." };
+		case "present":
+			return { icon: "●", color: theme.colors.success, text: "● Installed" };
+		case "off-path":
+			return {
+				icon: "!",
+				color: theme.colors.warning,
+				text: `! Installed in ${presence.prefix}, which is not on the PATH Claude Code starts with`,
+			};
+		case "missing":
+			return { icon: "○", color: theme.colors.muted, text: "○ Not installed" };
+		case "unknown":
+			return {
+				icon: "?",
+				color: theme.colors.warning,
+				text: `? Could not tell: ${presence.reason}`,
+			};
+	}
+}
+
+function renderPluginManagedRow(
+	row: PluginManagedRow,
+	isSelected: boolean,
+): React.ReactNode {
+	const { icon, color } = managedStatus(row.presence);
+	const suffix =
+		row.presence === null ? " ..." : ` · managed by ${row.managedBy}`;
+	if (isSelected) {
+		return (
+			<text bg={theme.selection.bg} fg={theme.selection.fg}>
+				{rowLead(true)}
+				{icon} {row.entry.displayName}
+				{suffix}{" "}
+			</text>
+		);
+	}
+	return (
+		<text fg={theme.colors.text}>
+			<span fg={color}>
+				{rowLead(false)}
+				{icon}
+			</span>
+			<span fg={theme.colors.text}> {row.entry.displayName}</span>
+			<span fg={theme.colors.dim}>{suffix}</span>
+		</text>
+	);
+}
+
+function renderPluginManagedDetail(
+	row: PluginManagedRow,
+	width: number,
+): React.ReactNode {
+	const { entry, managedBy, presence } = row;
+	const status = managedStatus(presence);
+	const here =
+		presence?.status === "present" || presence?.status === "off-path";
+	return (
+		<box flexDirection="column" width={width}>
+			<box flexDirection="row" marginBottom={1}>
+				<text fg={theme.colors.info}>
+					<strong>{entry.displayName}</strong>
+				</text>
+			</box>
+
+			<text fg={theme.colors.muted}>{entry.description}</text>
+
+			<box marginTop={1} flexDirection="column">
+				<box flexDirection="row">
+					<text fg={theme.colors.muted} flexShrink={0}>
+						{"Status   "}
+					</text>
+					<text fg={status.color} minWidth={0}>
+						{wrapValue(status.text, width)}
+					</text>
+				</box>
+				<box flexDirection="row">
+					<text fg={theme.colors.muted} flexShrink={0}>
+						{"Managed  "}
+					</text>
+					<text fg={theme.colors.text}>by {managedBy}</text>
+				</box>
+				{!here && presence !== null && row.installText ? (
+					<box flexDirection="row">
+						<text fg={theme.colors.muted} flexShrink={0}>
+							{"Install  "}
+						</text>
+						<text fg={theme.colors.info} minWidth={0}>
+							{wrapValue(row.installText, width)}
+						</text>
+					</box>
+				) : null}
+				<box flexDirection="row">
+					<text fg={theme.colors.muted} flexShrink={0}>
+						{"Website  "}
+					</text>
+					<box flexGrow={1} minWidth={0}>
+						<text fg={theme.colors.info} wrapMode="char">
+							{entry.website}
+						</text>
+					</box>
+				</box>
+			</box>
+
+			<box marginTop={2}>
+				<text fg={theme.colors.muted}>
+					{wrapText(
+						`${managedBy} installs ${entry.name} and decides its version; it cannot be installed, updated or removed from here. ${doctorFixCommand(null)} installs it when it is missing.`,
+						width,
+					).join("\n")}
+				</text>
+			</box>
+		</box>
+	);
+}
+
 // ─── Row renderer ──────────────────────────────────────────────────────────────
 
 export function renderCliToolRow(
-	row: CliToolRow,
+	row: CliToolsRow,
 	_index: number,
 	isSelected: boolean,
 ): React.ReactNode {
+	if (isPluginManagedRow(row)) return renderPluginManagedRow(row, isSelected);
 	const { tool, status, install } = row;
 	const installed = isInstalled(status);
 	const allMethods = install?.all ?? [];
@@ -167,10 +297,13 @@ export function renderCliToolRow(
 // ─── Detail renderer ───────────────────────────────────────────────────────────
 
 export function renderCliToolDetail(
-	row: CliToolRow | undefined,
+	row: CliToolsRow | undefined,
 	/** Usable detail-panel columns (`detailPanelWidth`); the scrollbox does not constrain width. */
 	width: number,
 ): React.ReactNode {
+	if (row && isPluginManagedRow(row)) {
+		return renderPluginManagedDetail(row, width);
+	}
 	if (!row) {
 		return (
 			<box

package/src/ui/screens/CliToolsScreen.tsx

@@ -1,5 +1,4 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
+import { homedir } from "node:os";
 import React, { useEffect, useCallback, useState, useRef } from "react";
 import { ScreenLayout } from "../components/layout/index.js";
 import { useScreenKeys } from "../input/KeyRouter.js";
@@ -7,13 +6,21 @@ import { moveDirection } from "../keymap.js";
 import { useApp, useFailurePopup, useModal } from "../state/AppContext.js";
 import { useDimensions } from "../state/DimensionsContext.js";
 
-import { cliTools } from "../../data/cli-tools.js";
 import { loadActiveClosure } from "../../services/active-closure.js";
 import {
 	type InstallMethod,
 	cliToolUninstall,
+	isPluginManagedItem,
+	resolveCatalogue,
 	uninstallBlocker,
+	unownedCatalogue,
 } from "../../services/cli-tool-commands.js";
+import {
+	DOCTOR_CHECK_CAP_MS,
+	installText,
+	machineEnv,
+	probeBins,
+} from "../../services/doctor-bins.js";
 import {
 	type InstallInfo,
 	PROBE_CONCURRENCY,
@@ -22,11 +29,15 @@ import {
 	probeTools,
 	specForCatalogTool,
 } from "../../services/tool-probe.js";
+import { managedBins } from "../../services/toolchain.js";
 import type { Command } from "../../utils/command-utils.js";
 import { createRequestGate } from "../../utils/request-gate.js";
+import { runArgv, succeeded } from "../../utils/run.js";
 import {
 	type CliToolCommandFailure,
 	type CliToolRow,
+	type CliToolsRow,
+	type PluginManagedRow,
 	buildToolRow,
 	cliToolConflictPartialReport,
 	cliToolConflictStuckReport,
@@ -36,7 +47,10 @@ import {
 	cliToolsNotUpdatedReport,
 	commandFailureReason,
 	countToolRows,
+	isPluginManagedRow,
+	rowName,
 } from "../adapters/cliToolsAdapter.js";
+import { installBinsInTui } from "../adapters/depsAdapter.js";
 import { ScrollableList } from "../components/ScrollableList.js";
 import {
 	renderCliToolDetail,
@@ -44,7 +58,6 @@ import {
 } from "../renderers/cliToolRenderers.js";
 import { theme } from "../theme.js";
 
-const execFileAsync = promisify(execFile);
 /** How long one installer command may run before it is stopped. */
 const COMMAND_TIMEOUT_MS = 60_000;
 
@@ -55,7 +68,7 @@ const COMMAND_TIMEOUT_MS = 60_000;
 // used to carry a private copy: a `/bin/bash` `which`, an `npm view` per tool,
 // its own version comparator, and a string-form `exec` of each check command.
 
-let cachedRows: CliToolRow[] | null = null;
+let cachedRows: CliToolsRow[] | null = null;
 let cacheInitialized = false;
 /** Every fetch takes a token, so a refresh discards the answers of the one before. */
 const fetchGate = createRequestGate();
@@ -65,9 +78,12 @@ function clearCliToolsCache(): void {
 	cacheInitialized = false;
 }
 
-/** Rows before anything is known: the catalogue mapping, checking. */
-function initialRows(): CliToolRow[] {
-	return cliTools.map((tool) =>
+/**
+ * Rows before anything is known: the catalogue mapping, checking. A tool a
+ * plugin owns joins once its plugin's declaration has been read.
+ */
+function initialRows(): CliToolsRow[] {
+	return unownedCatalogue().map(({ tool }) =>
 		buildToolRow(tool, specForCatalogTool(tool, null, undefined), undefined),
 	);
 }
@@ -102,7 +118,7 @@ export function CliToolsScreen() {
 	const showFailures = useFailurePopup();
 	const dimensions = useDimensions();
 
-	const [rows, setRows] = useState<CliToolRow[]>(
+	const [rows, setRows] = useState<CliToolsRow[]>(
 		() => cachedRows || initialRows(),
 	);
 	/** Why the last check could not run, shown under the header; null when it ran. */
@@ -112,7 +128,7 @@ export function CliToolsScreen() {
 	rowsRef.current = rows;
 
 	const setAndCache = useCallback(
-		(update: (prev: CliToolRow[]) => CliToolRow[]) => {
+		(update: (prev: CliToolsRow[]) => CliToolsRow[]) => {
 			setRows((prev) => {
 				const next = update(prev);
 				cachedRows = next;
@@ -136,45 +152,95 @@ export function CliToolsScreen() {
 		setProbeError(null);
 		try {
 			const projectPath = state.projectPath || process.cwd();
+			const catalogue = await resolveCatalogue(projectPath);
+			if (!fetchGate.isCurrent(token)) return;
+			// Each item keeps its catalogue position as its row.
+			const tracked = catalogue.flatMap((item, row) =>
+				isPluginManagedItem(item) ? [] : [{ ...item, row }],
+			);
+			const pluginManaged = catalogue.flatMap((item, row) =>
+				isPluginManagedItem(item) ? [{ ...item, row }] : [],
+			);
 			const [active, installs] = await Promise.all([
 				// Full resolution, not `resolveBins: false`: a catalogue tool may be
 				// declared by a PLUGIN's requires.bin, and parity needs the spec the
 				// CLI plans with. `resolveBins: false` would still keep the profile's
 				// own cliTools, but lose every plugin-declared bin and its pin.
 				loadActiveClosure(projectPath),
-				mapLimited(cliTools, PROBE_CONCURRENCY, (tool) =>
+				mapLimited(tracked, PROBE_CONCURRENCY, ({ tool }) =>
 					detectInstallMethods(tool, REAL_TOOL_PROBE_IO),
 				),
 			]);
 			if (!fetchGate.isCurrent(token)) return;
 
-			const closureBins = active?.closure.bins ?? null;
-			const planned = cliTools.map((tool, i) => ({
+			const closureBins = active ? managedBins(active.closure.bins) : null;
+			const planned = tracked.map(({ tool, owned, row }, i) => ({
 				tool,
+				owned,
+				row,
 				install: installs[i],
 				spec: specForCatalogTool(tool, closureBins, installs[i]),
 			}));
-			setAndCache(() =>
-				planned.map((p) => buildToolRow(p.tool, p.spec, undefined, p.install)),
+			const rowOf = (
+				p: (typeof planned)[number],
+				facts: Parameters<typeof buildToolRow>[2],
+			): CliToolRow => ({
+				...buildToolRow(p.tool, p.spec, facts, p.install),
+				...(p.owned ? { owned: p.owned } : {}),
+			});
+			const env = machineEnv(
+				process.env.HOME || homedir(),
+				process.env.PATH ?? "",
+				process.env.SHELL ?? "",
 			);
+			const managedRowOf = (
+				m: (typeof pluginManaged)[number],
+				presence: PluginManagedRow["presence"],
+			): PluginManagedRow => ({
+				managedBy: m.entry.ownedBy,
+				entry: m.entry,
+				owned: m.owned,
+				presence,
+				installText: env ? installText(m.owned, env) : "",
+			});
+			const setRow = (row: number, value: CliToolsRow) =>
+				setAndCache((prev) => {
+					const next = [...prev];
+					next[row] = value;
+					return next;
+				});
+			setAndCache(() => {
+				const next: CliToolsRow[] = new Array(catalogue.length);
+				for (const p of planned) next[p.row] = rowOf(p, undefined);
+				for (const m of pluginManaged) next[m.row] = managedRowOf(m, null);
+				return next;
+			});
 
-			await probeTools(
-				planned.map((p) => p.spec),
-				REAL_TOOL_PROBE_IO,
-				{
-					onResult: (facts, { index }) => {
-						if (!fetchGate.isCurrent(token)) return;
-						const p = planned[index];
-						if (!p) return;
-						const row = buildToolRow(p.tool, p.spec, facts, p.install);
-						setAndCache((prev) => {
-							const next = [...prev];
-							next[index] = row;
-							return next;
-						});
+			await Promise.all([
+				probeTools(
+					planned.map((p) => p.spec),
+					REAL_TOOL_PROBE_IO,
+					{
+						onResult: (facts, { index }) => {
+							if (!fetchGate.isCurrent(token)) return;
+							const p = planned[index];
+							if (p) setRow(p.row, rowOf(p, facts));
+						},
 					},
-				},
-			);
+				),
+				// The probe `magus doctor` runs, so the row and doctor agree.
+				(async () => {
+					if (!env || pluginManaged.length === 0) return;
+					const presences = await probeBins(
+						pluginManaged.map((m) => m.owned),
+						{ env, depth: "full", capMs: DOCTOR_CHECK_CAP_MS },
+					);
+					if (!fetchGate.isCurrent(token)) return;
+					pluginManaged.forEach((m, i) => {
+						setRow(m.row, managedRowOf(m, presences[i] ?? null));
+					});
+				})(),
+			]);
 		} catch (error) {
 			if (!fetchGate.isCurrent(token)) return;
 			setProbeError(error instanceof Error ? error.message : String(error));
@@ -219,31 +285,48 @@ export function CliToolsScreen() {
 	/**
 	 * Run one installer command: null when it succeeded, else why it failed.
 	 *
-	 * `execFile`, so there is no shell to re-parse a package name — the same
-	 * reason `utils/run.ts` exists. It does NOT call that shared `runCommand`:
-	 * that one inherits stdio, and a TUI must never hand the terminal to a
-	 * child. Output is captured; the modal is the progress indicator, and on a
-	 * failure the installer's own words become the popup's reason.
+	 * Through `runArgv`, which captures output and never touches the terminal;
+	 * the modal is the progress indicator, and on a failure the installer's own
+	 * words become the popup's reason.
 	 */
 	const runCommand = async (command: Command): Promise<string | null> => {
-		try {
-			await execFileAsync(command.cmd, [...command.args], {
-				timeout: COMMAND_TIMEOUT_MS,
-			});
-			return null;
-		} catch (err) {
-			return commandFailureReason(command, err, COMMAND_TIMEOUT_MS);
-		}
+		const result = await runArgv(command, { timeoutMs: COMMAND_TIMEOUT_MS });
+		return succeeded(result)
+			? null
+			: commandFailureReason(command, result, COMMAND_TIMEOUT_MS);
 	};
 
 	const handleInstall = async () => {
 		const row = rows[cliToolsState.selectedIndex];
-		const enter = row ? cliToolEnterAction(row) : null;
-		if (!row || !enter) return;
+		// A plugin-managed row is read-only: its plugin installs it.
+		if (!row || isPluginManagedRow(row)) return;
+		const enter = cliToolEnterAction(row);
+		if (!enter) return;
 
 		const { tool } = row;
 		const { command, progress: action } = enter;
 
+		// A tool a plugin owns installs from that plugin's declaration, through
+		// the same plan and executor as `magus doctor --fix`.
+		if (row.owned && enter.kind === "install") {
+			try {
+				await installBinsInTui(tool.displayName, [row.owned], modal);
+			} catch (error) {
+				modal.hideModal();
+				await showFailures(
+					cliToolFailureReport(`${tool.displayName} was not installed`, [
+						{
+							tool: tool.displayName,
+							command,
+							reason: error instanceof Error ? error.message : String(error),
+						},
+					]),
+				);
+			}
+			handleRefresh();
+			return;
+		}
+
 		modal.loading(`${action} ${tool.displayName}...`);
 		const reason = await runCommand(command);
 		modal.hideModal();
@@ -276,8 +359,9 @@ export function CliToolsScreen() {
 	 */
 	const handleResolveConflict = async () => {
 		const row = rows[cliToolsState.selectedIndex];
-		const install: InstallInfo | undefined = row?.install;
-		if (!row || !install || install.all.length < 2) return;
+		if (!row || isPluginManagedRow(row)) return;
+		const install: InstallInfo | undefined = row.install;
+		if (!install || install.all.length < 2) return;
 
 		const { tool } = row;
 		const allMethods = install.all;
@@ -370,7 +454,10 @@ export function CliToolsScreen() {
 		// Only rows the shared classifier says are behind. An `unknown` is never
 		// swept up in a bulk action — that is exactly the "cannot tell, so run
 		// it anyway" the CLI no longer does either.
-		const updatable = rows.filter((r) => r.status?.state === "upgrade");
+		const updatable = rows.filter(
+			(r): r is CliToolRow =>
+				!isPluginManagedRow(r) && r.status?.state === "upgrade",
+		);
 		if (updatable.length === 0) return;
 
 		modal.loading(`Updating ${updatable.length} tool(s)...`);
@@ -417,7 +504,10 @@ export function CliToolsScreen() {
 
 	// The footer names what Enter does on THIS row, from the same function the
 	// detail pane and the handler read; while the row is checked it does nothing.
-	const enter = selectedRow ? cliToolEnterAction(selectedRow) : null;
+	const enter =
+		selectedRow && !isPluginManagedRow(selectedRow)
+			? cliToolEnterAction(selectedRow)
+			: null;
 
 	return (
 		<ScreenLayout
@@ -440,7 +530,7 @@ export function CliToolsScreen() {
 					selectedIndex={cliToolsState.selectedIndex}
 					renderItem={renderCliToolRow}
 					maxHeight={dimensions.listPanelHeight}
-					getKey={(row) => row.tool.name}
+					getKey={rowName}
 				/>
 			}
 			detailPanel={(detailWidth) =>

package/src/ui/screens/PluginsScreen.tsx

@@ -29,11 +29,7 @@ import {
 	scopeFilesMissing,
 	versionInScope,
 } from "../../services/plugin-manager.js";
-import {
-	checkMissingDeps,
-	getPluginSetupFromSource,
-	installPluginDeps,
-} from "../../services/plugin-setup.js";
+import { resolvePluginBinRequirements } from "../../services/plugin-requires.js";
 import { saveProfile } from "../../services/profiles.js";
 import { requirersHere } from "../../services/resolver.js";
 import {
@@ -64,6 +60,7 @@ import {
 import { fuzzyFilter } from "../../utils/fuzzy-search.js";
 import { createRequestGate } from "../../utils/request-gate.js";
 import { buildCatalogNoticeText } from "../adapters/catalogNotice.js";
+import { installBinsInTui } from "../adapters/depsAdapter.js";
 import { counted, failureReport } from "../adapters/failureReport.js";
 import {
 	type FailureVerb,
@@ -865,57 +862,24 @@ export function PluginsScreen() {
 	};
 
 	/**
-	 * Install system dependencies required by a plugin's MCP servers.
+	 * Install what a just-installed plugin declares in `requires` and this
+	 * machine lacks — the same plan and executor as `magus doctor --fix`.
 	 */
 	const installPluginSystemDeps = async (
 		pluginName: string,
 		marketplace: string,
 	): Promise<void> => {
+		const pluginId = `${pluginName}@${marketplace}`;
 		try {
-			const setup = await getPluginSetupFromSource(marketplace, pluginName);
-			if (!setup) return;
-
-			const missing = await checkMissingDeps(setup);
-			const hasMissing =
-				(missing.pip?.length || 0) +
-					(missing.brew?.length || 0) +
-					(missing.npm?.length || 0) +
-					(missing.cargo?.length || 0) +
-					(missing.go?.length || 0) >
-				0;
-
-			if (!hasMissing) return;
-
-			const parts: string[] = [];
-			if (missing.pip?.length) parts.push(`pip: ${missing.pip.join(", ")}`);
-			if (missing.brew?.length) parts.push(`brew: ${missing.brew.join(", ")}`);
-			if (missing.npm?.length) parts.push(`npm: ${missing.npm.join(", ")}`);
-			if (missing.cargo?.length)
-				parts.push(`cargo: ${missing.cargo.join(", ")}`);
-			if (missing.go?.length) parts.push(`go: ${missing.go.join(", ")}`);
-
-			const wantInstall = await modal.confirm(
-				"Install Dependencies?",
-				`This plugin needs system dependencies:\n\n${parts.join("\n")}\n\nInstall now?`,
+			const bins = await resolvePluginBinRequirements(
+				pluginId,
+				state.projectPath || process.cwd(),
 			);
-
-			if (!wantInstall) return;
-
-			modal.loading("Installing dependencies...");
-			const result = await installPluginDeps(missing);
-			modal.hideModal();
-
-			// Only what did not install, each with why; what did shows nowhere.
-			const report = failureReport(
-				`${counted(result.failed.length, "dependency", "dependencies")} of ${pluginName} ${
-					result.failed.length === 1 ? "was" : "were"
-				} not installed`,
-				result.failed.map((f) => ({
-					subject: f.pkg,
-					reason: exceptionReason(f.error).reason,
-				})),
+			await installBinsInTui(
+				pluginId,
+				bins.map((bin) => ({ ...bin, sources: [`plugin:${pluginId}`] })),
+				modal,
 			);
-			if (report) await modal.failures(report);
 		} catch (error) {
 			// Hide the loading modal first: it would otherwise stay up forever,
 			// and the failure behind it would never be read.

package/src/utils/command-utils.ts

@@ -24,8 +24,8 @@ import { join } from "node:path";
  * characters it contains, and `cmd` must name a real executable rather than
  * anything PATH-plus-a-profile might have meant.
  *
- * `services/plugin-setup.ts` arrived at this same shape independently for the
- * MCP dependency installer. This is the codebase agreeing with itself.
+ * Plugin dependency installs are argv for the same reason: requires-probe
+ * renders every install step as one, and `utils/run.ts` runs it.
  */
 export interface Command {
 	readonly cmd: string;
@@ -71,9 +71,8 @@ function quoteToken(token: string): string {
  * Async only for its callers' sake — it spawns nothing. This used to run
  * `execFileAsync("which", [command])`, a real `which(1)` process with no
  * timeout, on every one of its dozen call sites. Answering "is bun on PATH?"
- * does not need a process, and under load that process is what stalls:
- * `detectToolchains` calls this per toolchain, and in a 103-file parallel test
- * run the spawn queue backed up until the test failed at **20,007 ms** — after
+ * does not need a process, and under load that process is what stalls: in a
+ * 103-file parallel test run the spawn queue backed up until the test failed at **20,007 ms** — after
  * the per-test timeout had already been raised from 5s to 20s to accommodate
  * the earlier 5s failures. Raising the limit moved the goalposts; removing the
  * spawn removes the stall.