magus-cli 7.7.0 → 7.9.0

package/src/services/claude-settings.ts

@@ -573,6 +573,58 @@ export async function removeLocalInstalledPluginVersion(
 	);
 }
 
+/**
+ * Take `pluginId` out of `installedPluginVersions` at `scope`, and touch
+ * nothing else.
+ *
+ * `installedPluginVersions` is magus's own field — Claude Code never writes it
+ * — so a plugin Claude Code uninstalled still has a claim there until magus
+ * clears it, and a stale claim is how an uninstalled plugin kept reading as
+ * installed. Unlike the `remove*InstalledPluginVersion` fallbacks above, this
+ * leaves `enabledPlugins` and the registry alone: those are Claude Code's, and
+ * the uninstall that just ran is what changed them. A file with no claim for
+ * the plugin is not rewritten.
+ */
+export async function forgetInstalledPluginVersion(
+	pluginId: string,
+	scope: "user" | "project" | "local",
+	projectPath?: string,
+): Promise<void> {
+	if (scope === "user") {
+		const settings = await readGlobalSettings();
+		const versions = writableMap(
+			settings,
+			"installedPluginVersions",
+			getGlobalSettingsPath(),
+		);
+		if (!versions || !Object.hasOwn(versions, pluginId)) return;
+		delete versions[pluginId];
+		await writeGlobalSettings(settings);
+		return;
+	}
+	if (scope === "local") {
+		const settings = await readLocalSettings(projectPath);
+		const versions = writableMap(
+			settings,
+			"installedPluginVersions",
+			getLocalSettingsPath(projectPath),
+		);
+		if (!versions || !Object.hasOwn(versions, pluginId)) return;
+		delete versions[pluginId];
+		await writeLocalSettings(settings, projectPath);
+		return;
+	}
+	const settings = await readSettings(projectPath);
+	const versions = writableMap(
+		settings,
+		"installedPluginVersions",
+		getSettingsPath(projectPath),
+	);
+	if (!versions || !Object.hasOwn(versions, pluginId)) return;
+	delete versions[pluginId];
+	await writeSettings(settings, projectPath);
+}
+
 // Status line management
 // Claude Code expects statusLine as an object: { type: "template", template: "..." }
 // or { type: "command", command: "..." }. Writing a bare string causes a validation error
@@ -1000,359 +1052,15 @@ export interface MarketplaceRecoveryResult {
 	reregistered: string[];
 }
 
-// =============================================================================
-// MARKETPLACE RENAME MIGRATION: mag-claude-plugins / MadAppGang-claude-code → magus
-// =============================================================================
-
-const OLD_MARKETPLACE_NAMES = ["mag-claude-plugins", "MadAppGang-claude-code"];
-const NEW_MARKETPLACE_NAME = "magus";
-const NEW_MARKETPLACE_REPO = "MadAppGang/magus";
-const OLD_MARKETPLACE_REPOS = ["MadAppGang/claude-code"];
-
-/**
- * Rename plugin keys in a Record from any old marketplace name to new.
- * e.g., "frontend@mag-claude-plugins" → "frontend@magus"
- *        "dev@MadAppGang-claude-code" → "dev@magus"
- * Returns [migratedRecord, count] — count=0 means no changes.
- */
-function migratePluginKeys<T>(
-	record: Record<string, T> | undefined,
-): [Record<string, T>, number] {
-	if (!record) return [{}, 0];
-	const migrated: Record<string, T> = {};
-	let count = 0;
-	for (const [key, value] of Object.entries(record)) {
-		const oldName = OLD_MARKETPLACE_NAMES.find((n) => key.endsWith(`@${n}`));
-		if (oldName) {
-			const pluginName = key.slice(0, key.lastIndexOf("@"));
-			const newKey = `${pluginName}@${NEW_MARKETPLACE_NAME}`;
-			// Don't overwrite if canonical key already exists
-			if (!record[newKey]) {
-				migrated[newKey] = value;
-			}
-			count++;
-		} else {
-			migrated[key] = value;
-		}
-	}
-	return [migrated, count];
-}
-
-/**
- * Migrate a single settings object in-place.
- * Returns number of keys renamed.
- */
-function migrateSettingsObject(settings: ClaudeSettings): number {
-	let total = 0;
-
-	const [ep, epCount] = migratePluginKeys(settings.enabledPlugins);
-	if (epCount > 0) {
-		settings.enabledPlugins = ep;
-		total += epCount;
-	}
-
-	const [iv, ivCount] = migratePluginKeys(settings.installedPluginVersions);
-	if (ivCount > 0) {
-		settings.installedPluginVersions = iv;
-		total += ivCount;
-	}
-
-	// Migrate extraKnownMarketplaces keys
-	for (const oldName of OLD_MARKETPLACE_NAMES) {
-		if (settings.extraKnownMarketplaces?.[oldName]) {
-			const entry = settings.extraKnownMarketplaces[oldName];
-			delete settings.extraKnownMarketplaces[oldName];
-			if (!settings.extraKnownMarketplaces[NEW_MARKETPLACE_NAME]) {
-				settings.extraKnownMarketplaces[NEW_MARKETPLACE_NAME] = {
-					...entry,
-					source: {
-						...entry.source,
-						repo: NEW_MARKETPLACE_REPO,
-					},
-				};
-			}
-			total++;
-		}
-	}
-
-	// Fix stale repo URL on existing magus entry (e.g. key is "magus" but repo is still "MadAppGang/claude-code")
-	const magusEntry = settings.extraKnownMarketplaces?.[NEW_MARKETPLACE_NAME];
-	if (
-		magusEntry?.source?.repo &&
-		OLD_MARKETPLACE_REPOS.includes(magusEntry.source.repo)
-	) {
-		magusEntry.source.repo = NEW_MARKETPLACE_REPO;
-		total++;
-	}
-
-	return total;
-}
-
-export interface MigrationResult {
-	projectMigrated: number;
-	globalMigrated: number;
-	localMigrated: number;
-	knownMarketplacesMigrated: boolean;
-	registryMigrated: number;
-}
-
-/**
- * Migrate all settings from mag-claude-plugins to magus.
- * Safe to call multiple times — no-ops if already migrated.
- * Runs across project settings, global settings, local settings,
- * known_marketplaces.json, and installed_plugins.json.
- */
-/**
- * Decode a ~/.claude/projects/ directory name back to a filesystem path.
- * Claude Code encodes paths by replacing "/" with "-", which is lossy when
- * directory names themselves contain dashes (e.g., "circl-infra" → "circl/infra").
- * Strategy: split on "-", then greedily recombine segments by checking which
- * combinations actually exist on disk.
- * Returns null if no valid path can be resolved.
- */
-async function decodeProjectDirName(encoded: string): Promise<string | null> {
-	// Split into segments: "-Users-jack-dev-circl-infra" → ["Users","jack","dev","circl","infra"]
-	const segments = encoded.replace(/^-/, "").split("-");
-	if (segments.length === 0) return null;
-
-	// Build path greedily: at each step, try joining the next segment with a dash first
-	// (preserving directory names like "circl-infra"), fall back to slash (new path segment)
-	let current = `/${segments[0]}`;
-	for (let i = 1; i < segments.length; i++) {
-		const withDash = `${current}-${segments[i]}`;
-		const withSlash = `${current}/${segments[i]}`;
-		// Prefer dash (keeps compound names intact) if that path prefix exists
-		if (await fs.pathExists(withDash)) {
-			current = withDash;
-		} else {
-			current = withSlash;
-		}
-	}
-
-	return (await fs.pathExists(current)) ? current : null;
-}
-
-export async function migrateMarketplaceRename(
-	projectPath?: string,
-): Promise<MigrationResult> {
-	const result: MigrationResult = {
-		projectMigrated: 0,
-		globalMigrated: 0,
-		localMigrated: 0,
-		knownMarketplacesMigrated: false,
-		registryMigrated: 0,
-	};
-
-	// 1. Project settings
-	try {
-		const settings = await readSettings(projectPath);
-		const count = migrateSettingsObject(settings);
-		if (count > 0) {
-			await writeSettings(settings, projectPath);
-			result.projectMigrated = count;
-		}
-	} catch {
-		/* skip if unreadable */
-	}
-
-	// 2. Global settings
-	try {
-		const settings = await readGlobalSettings();
-		const count = migrateSettingsObject(settings);
-		if (count > 0) {
-			await writeGlobalSettings(settings);
-			result.globalMigrated = count;
-		}
-	} catch {
-		/* skip if unreadable */
-	}
-
-	// 3. Local settings (settings.local.json)
-	try {
-		const local = await readLocalSettings(projectPath);
-		let localCount = 0;
-		const [ep, epCount] = migratePluginKeys(local.enabledPlugins);
-		if (epCount > 0) {
-			local.enabledPlugins = ep;
-			localCount += epCount;
-		}
-		const [iv, ivCount] = migratePluginKeys(local.installedPluginVersions);
-		if (ivCount > 0) {
-			local.installedPluginVersions = iv;
-			localCount += ivCount;
-		}
-		if (localCount > 0) {
-			await writeLocalSettings(local, projectPath);
-			result.localMigrated = localCount;
-		}
-	} catch {
-		/* skip if unreadable */
-	}
-
-	// 4. known_marketplaces.json — rename old keys + physical directory cleanup
-	const marketplacesDir = path.join(
-		os.homedir(),
-		".claude",
-		"plugins",
-		"marketplaces",
-	);
-	const newDir = path.join(marketplacesDir, NEW_MARKETPLACE_NAME);
-
-	try {
-		const known = await readKnownMarketplaces();
-		let knownModified = false;
-
-		for (const oldName of OLD_MARKETPLACE_NAMES) {
-			if (known[oldName]) {
-				const oldEntry = known[oldName];
-				// If canonical entry doesn't exist yet, create it
-				if (!known[NEW_MARKETPLACE_NAME]) {
-					known[NEW_MARKETPLACE_NAME] = {
-						...oldEntry,
-						source: {
-							...oldEntry.source,
-							repo: "MadAppGang/magus",
-						},
-					};
-				}
-				delete known[oldName];
-				knownModified = true;
-			}
-
-			// Ensure installLocation doesn't reference old directory names
-			if (known[NEW_MARKETPLACE_NAME]?.installLocation?.includes(oldName)) {
-				known[NEW_MARKETPLACE_NAME].installLocation = known[
-					NEW_MARKETPLACE_NAME
-				].installLocation.replace(oldName, NEW_MARKETPLACE_NAME);
-				knownModified = true;
-			}
-		}
-
-		if (knownModified) {
-			await writeKnownMarketplaces(known);
-			result.knownMarketplacesMigrated = true;
-		}
-	} catch {
-		/* skip if unreadable */
-	}
-
-	// 4b. Rename/remove old physical directories (runs even if keys were already migrated)
-	for (const oldName of OLD_MARKETPLACE_NAMES) {
-		const oldDir = path.join(marketplacesDir, oldName);
-		try {
-			if (await fs.pathExists(oldDir)) {
-				if (!(await fs.pathExists(newDir))) {
-					await fs.rename(oldDir, newDir);
-				} else {
-					// Both exist — remove the old one (magus dir is canonical)
-					await fs.remove(oldDir);
-				}
-			}
-		} catch {
-			/* non-fatal: directory cleanup is best-effort */
-		}
-	}
-
-	// 4c. Update git remote URL in the marketplace clone (old → new repo)
-	try {
-		if (await fs.pathExists(path.join(newDir, ".git"))) {
-			const { execSync } = await import("node:child_process");
-			const remote = execSync("git remote get-url origin", {
-				cwd: newDir,
-				encoding: "utf-8",
-				timeout: 5000,
-			}).trim();
-			if (remote.includes("claude-code") && remote.includes("MadAppGang")) {
-				const newRemote = remote.replace("claude-code", NEW_MARKETPLACE_NAME);
-				execSync(`git remote set-url origin "${newRemote}"`, {
-					cwd: newDir,
-					encoding: "utf-8",
-					timeout: 5000,
-				});
-			}
-		}
-	} catch {
-		/* non-fatal: git remote update is best-effort */
-	}
-
-	// 5. installed_plugins.json — rename plugin ID keys
-	try {
-		let regCount = 0;
-		await updateRegistryFile((registry) => {
-			const newPlugins: typeof registry.plugins = {};
-			for (const [pluginId, entries] of Object.entries(registry.plugins)) {
-				const oldName = OLD_MARKETPLACE_NAMES.find((n) =>
-					pluginId.endsWith(`@${n}`),
-				);
-				if (oldName) {
-					const pluginName = pluginId.slice(0, pluginId.lastIndexOf("@"));
-					const newKey = `${pluginName}@${NEW_MARKETPLACE_NAME}`;
-					if (!newPlugins[newKey]) {
-						newPlugins[newKey] = entries;
-					}
-					regCount++;
-				} else {
-					newPlugins[pluginId] = entries;
-				}
-			}
-			if (regCount === 0) return false;
-			registry.plugins = newPlugins;
-			return true;
-		});
-		// After the write, never inside the mutation: a refused write (a corrupt
-		// file, or one another session changed) must not report a migration that
-		// did not land.
-		result.registryMigrated = regCount;
-	} catch {
-		/* skip if unreadable */
-	}
-
-	// 6. Scan all known project settings (derived from ~/.claude/projects/ directory names)
-	try {
-		const projectsDir = path.join(os.homedir(), ".claude", "projects");
-		if (await fs.pathExists(projectsDir)) {
-			const entries = await fs.readdir(projectsDir);
-			const seenPaths = new Set<string>();
-			// Current project (from step 1) already handled — skip it
-			const currentProject = projectPath || process.cwd();
-			seenPaths.add(currentProject);
-
-			for (const entry of entries) {
-				const decoded = await decodeProjectDirName(entry);
-				if (!decoded || seenPaths.has(decoded)) continue;
-				seenPaths.add(decoded);
-
-				const settingsFile = path.join(decoded, ".claude", "settings.json");
-				try {
-					if (await fs.pathExists(settingsFile)) {
-						const raw = await fs.readJson(settingsFile);
-						const count = migrateSettingsObject(raw);
-						if (count > 0) {
-							await fs.writeJson(settingsFile, raw, { spaces: 2 });
-							result.projectMigrated += count;
-						}
-					}
-				} catch {
-					/* skip individual projects that fail */
-				}
-			}
-		}
-	} catch {
-		/* non-fatal: cross-project scan is best-effort */
-	}
-
-	return result;
-}
-
 /**
  * Recover/sync marketplace settings:
  * - Remove entries for marketplaces whose installLocation no longer exists
  * - Fix stale "directory" source for known Magus marketplaces that should be "github"
  *
- * It does NOT touch `autoUpdate`. It used to set it to `true` on every
- * MadAppGang entry whose flag was unset, on every TUI startup — writing a
- * Claude Code-owned field that Claude Code also syncs from settings. See
- * {@link getMarketplaceAutoUpdate}.
+ * A write to Claude Code's registry, so it runs only inside an install the user
+ * asked for, after Claude Code itself answered "not found in marketplace"
+ * (claude-cli's recovery). Opening magus never calls it. It does not touch
+ * `autoUpdate` — see {@link getMarketplaceAutoUpdate}.
  */
 export async function recoverMarketplaceSettings(): Promise<MarketplaceRecoveryResult> {
 	const known = await readKnownMarketplaces();
@@ -1992,9 +1700,8 @@ export async function removeFromInstalledPluginsRegistry(
  *    the reach it states, so those rows are never written here. When such a row is
  *    the one that WINS, the repair refuses outright and names the scope — silently
  *    rewriting nothing would be the worse answer of the two.
- *  - A null repository root matches null in the loader (two rootless directories
- *    are relevant to each other there, and this port now says so). It must not
- *    match here: "the same repository" cannot be true of two directories that are
+ *  - A null repository root matches nothing, here and (since Claude Code
+ *    2.1.284) in the loader too: "the same repository" cannot be true of two directories that are
  *    in no repository at all, and treating it as true would have a repair run
  *    from a scratch directory rewrite another scratch directory's rows. Only the
  *    exact same directory qualifies without a root.
@@ -2209,6 +1916,15 @@ export async function loadedVersionHere(
 	}
 }
 
+/**
+ * {@link repairStaleLoad}'s refusal when `target` has no downloaded copy to
+ * point Claude Code at. Exported so a caller that already names the version —
+ * "installed v1.3.0, but …" — can say it without repeating it.
+ */
+export function notDownloadedReason(target: string): string {
+	return `v${target} is not downloaded — run magus install`;
+}
+
 /**
  * What one {@link repairStaleLoad} attempt did, and whether it worked.
  *
@@ -2326,9 +2042,7 @@ export async function repairStaleLoad(
 		root,
 	);
 	if (!(await fs.pathExists(cacheDir))) {
-		return fail(
-			`no cache directory for v${target} — ${cacheDir} does not exist`,
-		);
+		return fail(notDownloadedReason(target));
 	}
 
 	const file = installedPluginsFile(root);
@@ -2336,22 +2050,22 @@ export async function repairStaleLoad(
 	// precondition the write is checked against, so they have to describe one
 	// moment — see `writeInstalledPluginsRegistry`.
 	const before = await readRegistryBytes(file);
-	if (before === null) return fail(`${file} does not exist`);
+	if (before === null) return fail("no plugin is installed on this machine");
 	let registry: InstalledPluginsRegistry;
 	try {
 		registry = requireRegistry(file, before);
-	} catch (error) {
+	} catch {
 		// The same check every other reader makes; a repair reports it as a result
 		// rather than throwing, because it is one item in a plan of many.
+		// Why it does not parse is `magus doctor`'s to show; here it is only the
+		// reason nothing was changed.
 		return fail(
-			`${file} is not a readable registry — refusing to write over it: ${
-				error instanceof Error ? error.message : String(error)
-			}`,
+			"Claude Code's list of installed plugins cannot be read, so nothing was changed — run magus doctor",
 		);
 	}
 	const rows = registry.plugins[pluginId];
 	if (!Array.isArray(rows) || rows.length === 0) {
-		return fail(`${pluginId} has no rows in ${file}`);
+		return fail("it is not installed on this machine");
 	}
 
 	// One cache for the whole pass: the same project paths repeat across rows,
@@ -2374,13 +2088,9 @@ export async function repairStaleLoad(
 		// `LoaderScope` in plugin-resolution.ts.
 		const scope: string = winner.scope;
 		return fail(
-			`the row Claude Code loads here is the machine-wide ${scope}-scope record at v${
-				winner.version
-			}, which every project on this machine resolves through. This repair only rewrites THIS repository's records, so it will not move it. ${
-				scope === "managed"
-					? "A managed record is administrator policy — raise it with whoever set that policy."
-					: `Update that scope directly instead: claude plugin install ${pluginId} --scope user`
-			}`,
+			scope === "managed"
+				? "Claude Code loads the install your administrator manages here — ask them to update it"
+				: "Claude Code loads the USER install of it here — update it at USER scope",
 		);
 	}
 
@@ -2398,11 +2108,9 @@ export async function repairStaleLoad(
 		try {
 			backup = await registryBackupPath(file, pluginId);
 			await fs.copy(file, backup);
-		} catch (error) {
+		} catch {
 			return fail(
-				`could not back up ${file}: ${
-					error instanceof Error ? error.message : String(error)
-				}`,
+				"could not save a backup before changing anything, so nothing was changed",
 			);
 		}
 
@@ -2428,10 +2136,8 @@ export async function repairStaleLoad(
 			if (backup) await fs.remove(backup).catch(() => {});
 			return fail(
 				error instanceof RegistryChangedError
-					? error.message
-					: `could not write ${file}: ${
-							error instanceof Error ? error.message : String(error)
-						}`,
+					? "another Claude Code session changed its plugins at the same moment, so nothing was changed — run it again"
+					: "the change could not be saved, so nothing was changed",
 			);
 		}
 		await pruneRegistryBackups(file);
@@ -2444,12 +2150,8 @@ export async function repairStaleLoad(
 	let after: InstalledPluginsRegistry;
 	try {
 		after = await readInstalledPluginsRegistry(root);
-	} catch (error) {
-		return fail(
-			`could not re-read ${file} to confirm the repair: ${
-				error instanceof Error ? error.message : String(error)
-			}`,
-		);
+	} catch {
+		return fail("the change was saved, but could not be checked afterwards");
 	}
 	const loaded =
 		pickLoadedEntry(after.plugins[pluginId], projectPath)?.version ?? null;
@@ -2470,8 +2172,10 @@ export async function repairStaleLoad(
 		backup,
 		loaded,
 		ok: false,
-		error: `the loader still resolves ${
-			loaded ? `v${loaded}` : "nothing"
-		} here, not v${target}`,
+		// The user's words, not the mechanism's: this reaches both front ends
+		// verbatim as the reason an item failed, grouped by that reason.
+		error: loaded
+			? `Claude Code still loads v${loaded} in this folder`
+			: "Claude Code loads no version of it in this folder",
 	};
 }

package/src/services/cli-tool-commands.ts

@@ -19,14 +19,115 @@
  * renderer.
  */
 
-import type { CliTool } from "../data/cli-tools.js";
+import {
+	type CatalogueEntry,
+	type CliTool,
+	type OwnedCatalogueEntry,
+	cliTools,
+	isOwnedEntry,
+} from "../data/cli-tools.js";
+import type { ResolvedBin, SelectedBin } from "../types/index.js";
 import type { Command } from "../utils/command-utils.js";
+import { ownedRequirement } from "./plugin-requires.js";
 import {
-	binInstallCommand,
 	binUninstallCommand,
 	binUpgradeCommand,
+	managedInstallCommand,
+	managedTool,
 } from "./toolchain.js";
 
+/**
+ * A catalogue row ready to probe. For a tool a plugin owns, `owned` is that
+ * plugin's requirement — what an install runs through the deps executor — and
+ * the tool's check and installer are read from it.
+ */
+export interface CatalogueTool {
+	tool: CliTool;
+	owned?: ResolvedBin;
+}
+
+/**
+ * A catalogue tool a plugin owns and installs with an option magus does not
+ * version — a release, a Homebrew cask, apt. Shown read-only, as managed by
+ * that plugin: its presence is the dependency probe's answer, and its
+ * install, update and removal are the plugin's declaration, run by
+ * `magus doctor --fix`.
+ */
+export interface PluginManagedTool {
+	entry: OwnedCatalogueEntry;
+	owned: ResolvedBin;
+}
+
+/** One catalogue row: a tool magus versions, or one its plugin manages. */
+export type CatalogueItem = CatalogueTool | PluginManagedTool;
+
+export const isPluginManagedItem = (
+	item: CatalogueItem,
+): item is PluginManagedTool => "entry" in item;
+
+/**
+ * An owned entry as a {@link CliTool}, from its plugin's requirement: null when
+ * that requirement is not installed by a version-managed kind, which the CLI
+ * Tools screen cannot track — such an entry is a {@link PluginManagedTool}.
+ */
+export function ownedCliTool(
+	entry: CatalogueEntry,
+	owned: SelectedBin,
+): CliTool | null {
+	const managed = managedTool(owned);
+	if (!managed) return null;
+	const { name, displayName, description, website, category } = entry;
+	return {
+		name,
+		displayName,
+		description,
+		website,
+		category,
+		checkCommand: owned.check.join(" "),
+		packageManager: managed.via,
+		packageName:
+			managed.package ?? managed.formula ?? managed.module ?? owned.name,
+	};
+}
+
+/** The catalogue entries that need no lookup: every one no plugin owns. */
+export function unownedCatalogue(): CatalogueTool[] {
+	return cliTools.flatMap((e) => (isOwnedEntry(e) ? [] : [{ tool: e }]));
+}
+
+/**
+ * The whole catalogue, in catalogue order, each owned entry resolved through
+ * its plugin's declaration (the copy Claude Code loads here, else the
+ * marketplace clone): a tracked tool when its chosen option is version-managed,
+ * else a {@link PluginManagedTool}. An owned entry whose declaration cannot be
+ * read here is left out: magus cannot say how to check or install it.
+ */
+export async function resolveCatalogue(
+	projectPath: string,
+	owned: (
+		pluginId: string,
+		name: string,
+		projectPath: string,
+	) => Promise<SelectedBin | null> = ownedRequirement,
+): Promise<CatalogueItem[]> {
+	const out: CatalogueItem[] = [];
+	for (const entry of cliTools) {
+		if (!isOwnedEntry(entry)) {
+			out.push({ tool: entry });
+			continue;
+		}
+		const requirement = await owned(entry.ownedBy, entry.name, projectPath);
+		if (!requirement) continue;
+		const resolved = {
+			...requirement,
+			sources: [`plugin:${entry.ownedBy}`],
+		};
+		const tool = ownedCliTool(entry, requirement);
+		out.push(tool ? { tool, owned: resolved } : { entry, owned: resolved });
+	}
+	return out;
+}
+
 /**
  * How a tool turned out to be installed, as detected from its path on disk.
  *
@@ -64,7 +165,7 @@ export type InstallMethod =
  * disagreement unrepresentable rather than merely fixed.
  */
 export function cliToolInstall(tool: CliTool): Command {
-	return binInstallCommand({
+	return managedInstallCommand({
 		name: tool.name,
 		via: tool.packageManager,
 		package: tool.packageName,