magus-cli 7.8.0 → 7.9.0

package/src/types/index.ts

@@ -1,4 +1,9 @@
 import type { ModelsConfig } from "../services/models-core.js";
+import type {
+	InstallOption,
+	Requirement,
+	Via,
+} from "../shared/plugin/hooks/lib/requires-probe.js";
 
 export interface McpServer {
 	name: string;
@@ -409,14 +414,52 @@ export interface ProfileManifest {
 	profiles: Record<string, ProfileManifestEntry>;
 }
 
-// ─── Plugin binary requirements (plugin.json `requires.bin`) ────────────────────
+// ─── Binary requirements (profile cliTools, and plugin requires) ────────────────
 
-/** How a binary dependency is installed. */
-export type BinInstaller = "bun" | "brew" | "npm" | "pip" | "go";
+/**
+ * What a plugin or a profile needs on the machine. One shape for both: a
+ * plugin's `requires` entry as requires-probe parses it, and a profile
+ * cliTools entry mapped onto the profile-only `npm`/`pip`/`go` kinds (or
+ * `bun`/`brew`) by `cliToolToBin`.
+ */
+export type BinRequirement = Requirement;
+export type BinInstallOption = InstallOption;
+
+/**
+ * A requirement with the install option chosen for this machine — selected
+ * once, where the requirement is resolved — and the plugin directory a
+ * `${CLAUDE_PLUGIN_ROOT}` check or a plugin-relative script resolves against
+ * (absent for a profile cliTool).
+ */
+export interface SelectedBin extends Requirement {
+	/** Null when no option can be used here (`whyUnselectable` says why). */
+	chosen: InstallOption | null;
+	root?: string;
+	/**
+	 * Profile pins the chosen option cannot install at: a tool a plugin owns
+	 * and installs from a release, Homebrew or apt, whose version is the
+	 * declaration's. Never applied, never dropped: `planDeps` reports each as
+	 * unfixable and `magus update` names it.
+	 */
+	refusedPins?: string[];
+}
+
+/** A selected requirement with its provenance: `plugin:<id>` / `profile:<name>.cliTools`. */
+export interface ResolvedBin extends SelectedBin {
+	sources: string[];
+}
+
+/** The install kinds whose installed version magus tracks and updates. */
+export type BinInstaller = Extract<Via, "bun" | "brew" | "npm" | "pip" | "go">;
 
-/** A single binary dependency a plugin (or profile) declares. */
-export interface BinRequirement {
-	/** The executable name expected on PATH (also the dedup key). */
+/**
+ * A requirement whose chosen option is one of the {@link BinInstaller} kinds,
+ * in the shape `magus update` and the CLI Tools screen track versions in.
+ * Derived from a {@link SelectedBin} by `managedTool` (services/toolchain.ts)
+ * or built from a catalogue entry; never declared by hand.
+ */
+export interface ManagedTool {
+	/** The executable name expected on PATH. */
 	name: string;
 	via: BinInstaller;
 	/** Package id for bun/npm/pip (defaults to `name`). */
@@ -425,25 +468,19 @@ export interface BinRequirement {
 	formula?: string;
 	/** Module path for `go install` (defaults to `name`). */
 	module?: string;
-	/** Command that verifies presence, e.g. "tmux -V" (defaults to `<name> --version`). */
+	/** The check, as one display line, e.g. "tmux -V" (defaults to `<name> --version`). */
 	check?: string;
 	/** Optional version pin (real for bun/npm/pip; advisory for brew/go). */
 	version?: string;
 }
 
-/** The `requires` block a plugin may declare in its plugin.json. */
-export interface PluginRequires {
-	bin?: BinRequirement[];
+/** A {@link ManagedTool} with its provenance. */
+export interface ManagedBin extends ManagedTool {
+	sources: string[];
 }
 
 // ─── Resolved install closure (resolver output) ─────────────────────────────────
 
-/** A binary requirement after dedup + pin precedence, with provenance. */
-export interface ResolvedBin extends BinRequirement {
-	/** Where this requirement came from, for diagnostics. */
-	sources: string[];
-}
-
 /**
  * The fully-resolved set of things to install for a profile (or the union of
  * all profiles). Produced by the resolver; consumed by `magus install`.

package/src/ui/App.tsx

@@ -3,8 +3,6 @@ import { activePluginPins } from "../services/active-closure.js";
 import { isClaudeAvailable } from "../services/claude-cli.js";
 import {
 	findStaleLoads,
-	migrateMarketplaceRename,
-	recoverMarketplaceSettings,
 	repairAllStaleLoads,
 } from "../services/claude-settings.js";
 import {
@@ -12,7 +10,6 @@ import {
 	startupGitignoreNeed,
 } from "../services/gitignore-check.js";
 import { applyStartupFixes } from "../services/gitignore-service.js";
-import { repairAllMarketplaces } from "../services/local-marketplace.js";
 import { autoAddMissingMarketplaces } from "../services/marketplace-sync.js";
 import {
 	type ProfileStartupNeed,
@@ -26,7 +23,6 @@ import {
 } from "../services/version-check.js";
 import {
 	gitignoreStartupReport,
-	marketplaceRefreshReport,
 	profileStartupReport,
 	staleRepairReport,
 } from "./adapters/startupReports.js";
@@ -565,14 +561,11 @@ function AppContent({ onExit }: AppContentProps) {
 		const noRefresh = process.argv.includes("--no-refresh");
 		if (noRefresh) return;
 
-		dispatch({
-			type: "SHOW_PROGRESS",
-			state: { message: "Scanning marketplaces..." },
-		});
-
-		// Migrate old marketplace names -> magus (idempotent), then repair plugin.json files
-		migrateMarketplaceRename().catch(() => {}); // non-blocking, best-effort
-
+		// Opening magus reads Claude Code's files and never writes them: the
+		// marketplace registry, its clones, installed_plugins.json and every
+		// settings.json are Claude Code's. The one change made here goes through
+		// Claude Code's own CLI.
+		//
 		// Auto-add marketplaces referenced by enabledPlugins but missing from
 		// the local registry. Fixes the "fresh clone of a project whose
 		// .claude/settings.json enables @magus plugins but this machine has
@@ -585,34 +578,7 @@ function AppContent({ onExit }: AppContentProps) {
 				// non-fatal: user can still install marketplaces manually
 			}
 		})();
-
-		// Recover stale marketplace registry entries (e.g. "directory" -> "github"),
-		// then refresh the clones whose source that fixed. A refresh that fails
-		// leaves that marketplace's plugins read from an old copy, so it is named
-		// in the failure popup with why.
-		recoverMarketplaceSettings()
-			.then(async (recovery) => {
-				if (recovery.reregistered.length === 0) return;
-				const { updateMarketplace } = await import("../services/claude-cli.js");
-				const failed: Array<{ marketplace: string; error: unknown }> = [];
-				for (const mp of recovery.reregistered) {
-					await updateMarketplace(mp).catch((error: unknown) => {
-						failed.push({ marketplace: mp, error });
-					});
-				}
-				queueReports(marketplaceRefreshReport(failed));
-			})
-			.catch(() => {}); // the recovery itself: non-fatal
-
-		repairAllMarketplaces()
-			.then(async () => {
-				dispatch({ type: "HIDE_PROGRESS" });
-				dispatch({ type: "DATA_REFRESH_COMPLETE" });
-			})
-			.catch(() => {
-				dispatch({ type: "HIDE_PROGRESS" });
-			});
-	}, [dispatch, queueReports]);
+	}, []);
 
 	return (
 		<DimensionsProvider

package/src/ui/adapters/cliToolsAdapter.ts

@@ -18,7 +18,7 @@
  */
 
 import path from "node:path";
-import type { CliTool } from "../../data/cli-tools.js";
+import type { CliTool, OwnedCatalogueEntry } from "../../data/cli-tools.js";
 import {
 	cliToolInstall,
 	cliToolUpdate,
@@ -31,8 +31,14 @@ import {
 	classifyTool,
 } from "../../services/tool-probe.js";
 import { binCommandForState } from "../../services/toolchain.js";
-import type { BinRequirement, ResolvedBin } from "../../types/index.js";
+import type { Presence } from "../../shared/plugin/hooks/lib/requires-probe.js";
+import type {
+	ManagedBin,
+	ManagedTool,
+	ResolvedBin,
+} from "../../types/index.js";
 import { type Command, formatCommand } from "../../utils/command-utils.js";
+import type { RunResult } from "../../utils/run.js";
 import type { StatusTone } from "../renderers/pluginStatusText.js";
 import type { FailureReport } from "../state/types.js";
 import { counted, failureReport, withoutBinaryPaths } from "./failureReport.js";
@@ -41,7 +47,7 @@ import { CLAUDE_MISSING_REASON, exceptionReason } from "./pluginsAdapter.js";
 export interface CliToolRow {
 	tool: CliTool;
 	/** The requirement the tool was probed through (closure → detected → catalogue). */
-	spec: BinRequirement;
+	spec: ManagedTool;
 	/** True until facts arrive. */
 	checking: boolean;
 	/** Null while checking. */
@@ -56,25 +62,65 @@ export interface CliToolRow {
 	updateCommand?: Command;
 	/** What Enter runs for a tool that is not installed. */
 	installCommand: Command;
+	/**
+	 * For a tool a plugin owns: that plugin's requirement. Enter on a missing
+	 * one installs it through the deps executor, like `magus doctor --fix`.
+	 */
+	owned?: ResolvedBin;
+}
+
+/**
+ * A catalogue tool its plugin installs with an option magus does not version
+ * (a release, a Homebrew cask, apt): read-only. No Enter action, no update,
+ * no conflict fix — the row says which plugin manages it and whether it is
+ * here, from the same probe `magus doctor` runs.
+ */
+export interface PluginManagedRow {
+	/** The plugin that installs it: `<plugin>@<marketplace>`. */
+	managedBy: string;
+	entry: OwnedCatalogueEntry;
+	owned: ResolvedBin;
+	/** Null while checking. */
+	presence: Presence | null;
+	/** The plugin's install line, for display; `magus doctor --fix` runs it. */
+	installText: string;
+}
+
+/** A CLI Tools list row. */
+export type CliToolsRow = CliToolRow | PluginManagedRow;
+
+export const isPluginManagedRow = (row: CliToolsRow): row is PluginManagedRow =>
+	"managedBy" in row;
+
+/** The tool's catalogue name, whichever kind of row. */
+export function rowName(row: CliToolsRow): string {
+	return isPluginManagedRow(row) ? row.entry.name : row.tool.name;
+}
+
+/** On PATH or in a user prefix, as far as the row knows. */
+function rowInstalled(row: CliToolsRow): boolean {
+	if (!isPluginManagedRow(row)) return isInstalled(row.status);
+	const status = row.presence?.status;
+	return status === "present" || status === "off-path";
 }
 
 /**
  * Did this spec come from the resolver's closure — i.e. does the active profile
  * declare this tool?
  *
- * `ResolvedBin` is `BinRequirement` plus `sources`, and only the resolver adds
+ * `ManagedBin` is `ManagedTool` plus `sources`, and only the resolver adds
  * them, so the provenance travels with the spec itself rather than being
  * re-derived here (which would be a second copy of `specForCatalogTool`'s
  * branch 1, free to disagree with it).
  */
-function declaredSpec(spec: BinRequirement): ResolvedBin | null {
-	const candidate = spec as ResolvedBin;
+function declaredSpec(spec: ManagedTool): ManagedBin | null {
+	const candidate = spec as ManagedBin;
 	return Array.isArray(candidate.sources) ? candidate : null;
 }
 
 export function buildToolRow(
 	tool: CliTool,
-	spec: BinRequirement,
+	spec: ManagedTool,
 	facts: ToolFacts | undefined,
 	install?: InstallInfo,
 ): CliToolRow {
@@ -122,7 +168,7 @@ export function buildToolRow(
  */
 function updateCommandFor(
 	tool: CliTool,
-	declared: ResolvedBin | null,
+	declared: ManagedBin | null,
 	status: ToolStatus,
 	facts: ToolFacts,
 	install: InstallInfo | undefined,
@@ -237,7 +283,7 @@ export interface CliToolStatusText {
  * within 24. Keyed by reason alone — plus the spec's installer, which is a
  * word, never a path.
  */
-function unknownLabel(reason: ToolReason, via: BinRequirement["via"]): string {
+function unknownLabel(reason: ToolReason, via: ManagedTool["via"]): string {
 	switch (reason) {
 		case "not-managed":
 			return `not managed by ${via}`;
@@ -292,7 +338,7 @@ export function cliToolStatusText(row: CliToolRow): CliToolStatusText {
 }
 
 /** Header counts, from the rows' states. */
-export function countToolRows(rows: readonly CliToolRow[]): {
+export function countToolRows(rows: readonly CliToolsRow[]): {
 	installed: number;
 	updates: number;
 	unverified: number;
@@ -301,7 +347,11 @@ export function countToolRows(rows: readonly CliToolRow[]): {
 	let updates = 0;
 	let unverified = 0;
 	for (const row of rows) {
-		if (isInstalled(row.status)) installed++;
+		if (rowInstalled(row)) installed++;
+		if (isPluginManagedRow(row)) {
+			if (row.presence?.status === "unknown") unverified++;
+			continue;
+		}
 		if (row.status?.state === "upgrade") updates++;
 		if (row.status?.state === "unknown") unverified++;
 	}
@@ -364,39 +414,29 @@ export const RETRY_TIMEOUT_FIX =
 	"Try again; if it keeps timing out, check your network connection";
 
 /**
- * Why an installer command failed, as ONE line, from what `execFile` threw.
+ * Why an installer command failed, as ONE line, from its {@link RunResult}.
  *
- * The thrown message's first line is "Command failed: <the command>", which
- * says nothing the fix line does not. The installer's own words are in its
- * stderr: the text after an `error:` (npm, brew and cargo all say it that
- * way), else its first line that is not bookkeeping. A missing installer and
- * a timeout are said plainly — a missing `claude` in the words every other
- * screen uses for it. No absolute binary path survives into the reason.
+ * The installer's own words are in its output: the text after an `error:`
+ * (npm, brew and cargo all say it that way), else its first line that is not
+ * bookkeeping. A missing installer and a timeout are said plainly — a missing
+ * `claude` in the words every other screen uses for it. No absolute binary
+ * path survives into the reason.
  */
 export function commandFailureReason(
 	command: Command,
-	error: unknown,
+	result: RunResult,
 	timeoutMs: number,
 ): string {
-	if (!(error instanceof Error)) {
-		return withoutBinaryPaths(String(error).split("\n")[0]?.trim() || "failed");
-	}
-	const e = error as Error & {
-		code?: unknown;
-		killed?: boolean;
-		signal?: unknown;
-		stderr?: unknown;
-	};
 	const name = commandName(command);
-	if (e.code === "ENOENT") {
+	if (result.spawnError?.includes("ENOENT")) {
 		return name === "claude"
 			? CLAUDE_MISSING_REASON
 			: `${name} is not installed on this machine`;
 	}
-	if (e.killed || e.signal === "SIGTERM") {
+	if (result.timedOut) {
 		return `did not finish within ${Math.round(timeoutMs / 1000)} seconds`;
 	}
-	const lines = String(e.stderr ?? "")
+	const lines = result.outputTail
 		.split("\n")
 		.map((line) => line.replace(/^npm (?:ERR!|error)\b/i, "").trim())
 		.filter((line) => line !== "" && !INSTALLER_NOISE.test(line));
@@ -406,12 +446,10 @@ export function commandFailureReason(
 		: (lines[0] ?? "");
 	if (!reason) {
 		reason =
-			typeof e.code === "number"
-				? `${name} exited with code ${e.code}`
-				: e.message
-						.split("\n")[0]
-						?.replace(/^Command failed: .*$/, "")
-						.trim() || `${name} failed`;
+			result.spawnError ??
+			(result.exitCode !== null
+				? `${name} exited with code ${result.exitCode}`
+				: `${name} failed`);
 	}
 	reason = withoutBinaryPaths(reason);
 	return reason.length > MAX_REASON

package/src/ui/adapters/depsAdapter.ts

@@ -0,0 +1,129 @@
+/**
+ * Plugin dependencies in the TUI: the same plan and the same `ApplyOutcome[]`
+ * `magus doctor --fix` renders as text, rendered as a confirm modal and a
+ * failure popup.
+ *
+ * `installBinsInTui` is the one flow the Plugins screen (a plugin just
+ * installed) and the CLI Tools screen (a tool a plugin owns) both run:
+ * probe → `planDeps` → confirm listing every step → `applyDepsPlan` → popup.
+ */
+
+import { homedir } from "node:os";
+import {
+	type ApplyOutcome,
+	type DepsPlan,
+	applyDepsPlan,
+	defaultLockPath,
+	planLines,
+} from "../../services/deps-plan.js";
+import { assessBins } from "../../services/deps-report.js";
+import { machineEnv } from "../../services/doctor-bins.js";
+import type { ResolvedBin } from "../../types/index.js";
+import type { FailureReport, FailureRow } from "../state/types.js";
+import { counted, failureReport } from "./failureReport.js";
+
+const STATUS_REASON: Record<ApplyOutcome["status"], string> = {
+	installed: "installed",
+	"off-path": "installed, but not on the PATH Claude Code starts with",
+	failed: "the installer failed",
+	"needs-password": "needs your sudo password",
+	"needs-root": "needs root, and sudo is not available",
+	blocked: "what it needs was not installed",
+};
+
+/**
+ * What did not install, each with why and the exact command; then what can
+ * never be installed here; then the PATH lines. Null when there is nothing to
+ * say. The headline counts what needs the user.
+ */
+export function depsFailureReport(
+	subject: string,
+	outcomes: readonly ApplyOutcome[],
+	plan: Pick<DepsPlan, "unfixable" | "pathAdvice">,
+): FailureReport | null {
+	const rows: FailureRow[] = [];
+	for (const o of outcomes) {
+		if (o.status === "installed") continue;
+		const last = o.outputTail.trim().split("\n").pop()?.trim();
+		rows.push({
+			subject: o.name,
+			reason:
+				o.status === "failed" && last
+					? `${STATUS_REASON[o.status]}: ${last}`
+					: o.dir
+						? `${STATUS_REASON[o.status]}: it is in ${o.dir}`
+						: STATUS_REASON[o.status],
+			...(o.remedy ? { fix: o.remedy } : {}),
+		});
+	}
+	for (const u of plan.unfixable) {
+		rows.push({
+			subject: u.name,
+			reason: u.why,
+		});
+	}
+	for (const a of plan.pathAdvice) {
+		rows.push({
+			subject: a.prefix,
+			reason: "not on the PATH Claude Code starts with",
+			fix: `add ${a.rcLine} to ${a.rcFile}, then restart Claude Code from a new terminal`,
+		});
+	}
+	return failureReport(
+		`${counted(rows.length, "dependency of", "dependencies of")} ${subject} ${
+			rows.length === 1 ? "needs" : "need"
+		} you`,
+		rows,
+		{ group: false },
+	);
+}
+
+/** The part of the modal API the flow uses. */
+export interface DepsModal {
+	confirm(title: string, message: string): Promise<boolean>;
+	loading(message: string): void;
+	hideModal(): void;
+	failures(report: FailureReport): Promise<void>;
+}
+
+/** Probe, plan, ask once, install, and report — for `bins` of `subject`. */
+export async function installBinsInTui(
+	subject: string,
+	bins: ResolvedBin[],
+	modal: DepsModal,
+): Promise<void> {
+	const env = machineEnv(
+		process.env.HOME || homedir(),
+		process.env.PATH ?? "",
+		process.env.SHELL ?? "",
+	);
+	if (!env || bins.length === 0) return;
+	const { plan } = await assessBins(
+		{ plugins: [subject], bins, problems: [] },
+		env,
+	);
+	let outcomes: ApplyOutcome[] = [];
+	if (plan.steps.length > 0) {
+		const ok = await modal.confirm(
+			"Install Dependencies?",
+			`${subject} needs:\n\n${planLines(plan, env.os).join("\n")}\n\nInstall now?`,
+		);
+		if (!ok) return;
+		modal.loading("Installing dependencies...");
+		try {
+			outcomes = await applyDepsPlan(plan, {
+				yes: true,
+				confirm: async () => true,
+				env,
+				lockPath: defaultLockPath(env.home, process.env.XDG_CACHE_HOME),
+				onEvent: (e) => {
+					if (e.type === "step-start") modal.loading(`Installing ${e.name}...`);
+				},
+			});
+		} finally {
+			modal.hideModal();
+		}
+	}
+	const report = depsFailureReport(subject, outcomes, plan);
+	if (report) await modal.failures(report);
+}

package/src/ui/adapters/startupReports.ts

@@ -212,28 +212,6 @@ export function stepFailureReport(
 	};
 }
 
-/**
- * M8: marketplaces whose refresh failed after startup re-registered them.
- * Until one refreshes, its plugins are read from a copy that may be old.
- */
-export function marketplaceRefreshReport(
-	failures: ReadonlyArray<{ marketplace: string; error: unknown }>,
-): FailureReport | null {
-	return failureReport(
-		`${counted(failures.length, "marketplace")} could not be refreshed`,
-		failures.map(({ marketplace, error }) => {
-			const e = exceptionReason(
-				error instanceof Error ? error.message : String(error),
-			);
-			return {
-				subject: marketplace,
-				reason: e.reason,
-				...(e.fix ? { fix: e.fix } : {}),
-			};
-		}),
-	);
-}
-
 /**
  * M9: generated files the startup gitignore fix could not untrack, each with
  * git's own reason.