magus-cli 7.7.0 → 7.9.0

package/src/services/toolchain.ts

@@ -1,16 +1,28 @@
 /**
- * Toolchain detection + bootstrap for the package managers a profile's binary
- * deps need (bun, brew, npm, pip, go).
+ * The commands that install, upgrade, pin and remove a version-managed tool
+ * (bun, brew, npm, pip, go), and the bridge between a requirement and that
+ * version-managed view.
  *
- * `magus install` requires whatever installers the resolved closure uses. In
- * source form bun is already guaranteed (bin/magus.js hard-exits without it),
- * but once magus ships as a compiled binary an end user may lack bun — so bun
- * is treated as a bootstrappable toolchain exactly like brew.
+ * Installing a requirement goes through requires-probe's `renderInstall` and
+ * the deps executor (`services/deps-plan.ts`); this module builds only what
+ * `magus update` and the CLI Tools screen run beyond a first install.
  */
 
-import type { BinInstaller, ResolvedBin } from "../types/index.js";
+import {
+	type InstallOption,
+	assertNever,
+	currentPlatform,
+	renderInstall,
+} from "../shared/plugin/hooks/lib/requires-probe.js";
+import type {
+	BinInstaller,
+	ManagedBin,
+	ManagedTool,
+	ResolvedBin,
+	SelectedBin,
+} from "../types/index.js";
 import type { Command } from "../utils/command-utils.js";
-import { which, whichSync } from "../utils/command-utils.js";
+import { whichSync } from "../utils/command-utils.js";
 
 // -- Python CLI applications -------------------------------------------------
 
@@ -160,125 +172,119 @@ export function resetPythonCliInstallerMemo(): void {
 }
 
 // ----------------------------------------------------------------------------
+//
+// The version-managed view of a requirement.
+//
+// A requirement (plugin `requires`, or a profile cliTool mapped onto the
+// profile-only kinds) is installed by requires-probe's `renderInstall` and the
+// deps executor. `magus update` and the CLI Tools screen additionally track
+// the installed VERSION of the kinds that have one — bun, brew, npm, pip, go —
+// and they work in the {@link ManagedTool} shape. These functions are the one
+// bridge between the two, in both directions.
 
-/**
- * The executable that proves a toolchain is installed.
- *
- * `pip` is deliberately absent: which executable proves it depends on the
- * machine, so it is resolved by {@link resolvePythonCliInstaller} instead.
- */
-const TOOLCHAIN_PROBE: Record<Exclude<BinInstaller, "pip">, string> = {
-	bun: "bun",
-	brew: "brew",
-	npm: "npm",
-	go: "go",
-};
-
-/** The executable whose presence proves `name` is usable. */
-function toolchainProbe(name: BinInstaller): string {
-	return name === "pip"
-		? resolvePythonCliInstaller().probe
-		: TOOLCHAIN_PROBE[name];
-}
-
-/** Official one-line bootstrap for the toolchains magus will install. */
-export const TOOLCHAIN_BOOTSTRAP: Partial<Record<BinInstaller, string>> = {
-	bun: "curl -fsSL https://bun.sh/install | bash",
-	brew: '/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"',
-};
-
-export interface ToolchainStatus {
-	name: BinInstaller;
-	present: boolean;
-	/** Binary names in the closure that need this toolchain. */
-	requiredBy: string[];
-	/** Bootstrap command, when magus can install this toolchain itself. */
-	bootstrap?: string;
-}
-
-/** Is a given toolchain available on PATH? */
-export async function isToolchainPresent(name: BinInstaller): Promise<boolean> {
-	return (await which(toolchainProbe(name))) !== null;
-}
+const pinned = (version: string | undefined) => (version ? { version } : {});
 
 /**
- * Determine which toolchains a resolved closure's binary deps require, and
- * whether each is present. Only toolchains actually needed are returned.
+ * The version-managed view of a selected requirement, or null when its chosen
+ * option is not one of the {@link BinInstaller} kinds (apt, release,
+ * bootstrap, uv-script, uv-module: their version is the declaration's, and
+ * `magus doctor --fix` installs them).
  */
-export async function detectToolchains(
-	bins: ResolvedBin[],
-): Promise<ToolchainStatus[]> {
-	const requiredBy = new Map<BinInstaller, string[]>();
-	for (const bin of bins) {
-		const list = requiredBy.get(bin.via) ?? [];
-		list.push(bin.name);
-		requiredBy.set(bin.via, list);
+export function managedTool(bin: SelectedBin): ManagedTool | null {
+	const option = bin.chosen;
+	if (!option) return null;
+	const check = bin.check.join(" ");
+	switch (option.via) {
+		case "bun":
+		case "npm":
+		case "pip":
+			return {
+				name: bin.name,
+				via: option.via,
+				package: option.package,
+				check,
+				...pinned(option.version),
+			};
+		case "go":
+			return {
+				name: bin.name,
+				via: "go",
+				module: option.package,
+				check,
+				...pinned(option.version),
+			};
+		case "brew":
+			// A cask is installed, upgraded and removed with `--cask`, which the
+			// version-managed view does not speak: its declaration manages it.
+			return option.cask !== undefined
+				? null
+				: { name: bin.name, via: "brew", formula: option.formula, check };
+		case "apt":
+		case "release":
+		case "bootstrap":
+		case "uv-script":
+		case "uv-module":
+			return null;
+		default:
+			return assertNever(option);
 	}
+}
 
-	const statuses: ToolchainStatus[] = [];
-	for (const [name, names] of requiredBy) {
-		statuses.push({
-			name,
-			present: await isToolchainPresent(name),
-			requiredBy: names,
-			bootstrap: TOOLCHAIN_BOOTSTRAP[name],
-		});
+/** {@link managedTool} over a closure's bins, keeping each one's provenance. */
+export function managedBins(bins: readonly ResolvedBin[]): ManagedBin[] {
+	const out: ManagedBin[] = [];
+	for (const bin of bins) {
+		const tool = managedTool(bin);
+		if (tool) out.push({ ...tool, sources: [...bin.sources] });
 	}
-	// Stable order: bun, brew, npm, pip, go.
-	const order: BinInstaller[] = ["bun", "brew", "npm", "pip", "go"];
-	statuses.sort((a, b) => order.indexOf(a.name) - order.indexOf(b.name));
-	return statuses;
+	return out;
 }
 
-/**
- * The install command for a single binary requirement.
- *
- * `python` is injectable so tests can pin one and stay machine-independent —
- * the default depends on what is on PATH, so an assertion against a literal
- * `uv tool …` would pass here and fail on a runner without uv.
- *
- * `pkg@version` and `pkg==version` are each ONE argv token. That join is
- * precisely where a string was dangerous: `bin.package` is hand-authored
- * profile/marketplace data, and under a shell a space or a `;` in it would have
- * become extra words. Here it cannot.
- */
-export function binInstallCommand(
-	bin: {
-		name: string;
-		via: BinInstaller;
-		package?: string;
-		formula?: string;
-		module?: string;
-		version?: string;
-	},
-	python: PythonCliInstaller = resolvePythonCliInstaller(),
-): Command {
-	const pkg = bin.package ?? bin.name;
-	const at = bin.version ? `@${bin.version}` : "";
-	switch (bin.via) {
+/** The install option a {@link ManagedTool} stands for. */
+export function managedOption(t: ManagedTool): InstallOption {
+	switch (t.via) {
+		case "brew":
+			return { via: "brew", formula: t.formula ?? t.name };
+		case "go":
+			return { via: "go", package: t.module ?? t.name, ...pinned(t.version) };
 		case "bun":
-			return { cmd: "bun", args: ["install", "-g", `${pkg}${at}`] };
 		case "npm":
-			return { cmd: "npm", args: ["install", "-g", `${pkg}${at}`] };
 		case "pip":
-			return python.install(pkg, bin.version);
-		case "brew":
-			return { cmd: "brew", args: ["install", bin.formula ?? bin.name] };
-		case "go":
 			return {
-				cmd: "go",
-				args: [
-					"install",
-					`${bin.module ?? bin.name}@${bin.version ?? "latest"}`,
-				],
+				via: t.via,
+				package: t.package ?? t.name,
+				...pinned(t.version),
 			};
+		default:
+			return assertNever(t.via);
+	}
+}
+
+/**
+ * The command that installs a {@link ManagedTool}, rendered by requires-probe's
+ * `renderInstall` — the one renderer every install goes through — so the pin
+ * travels in the same token (`pkg@version`, `pkg==version`) it does there.
+ */
+export function managedInstallCommand(t: ManagedTool): Command {
+	const step = renderInstall(
+		{ name: t.name, check: [], install: [] },
+		managedOption(t),
+		{
+			...(currentPlatform() ?? { os: "linux", arch: "amd64" }),
+			pluginRoot: "",
+		},
+	);
+	if (step.kind !== "argv") {
+		throw new Error(`${t.via} renders a ${step.kind} step, not a command`);
 	}
+	const [cmd = "", ...args] = step.argv;
+	return { cmd, args };
 }
 
 /**
  * The command that advances an ALREADY-INSTALLED binary to the newest version.
  *
- * Distinct from {@link binInstallCommand} because two of the five installers
+ * Distinct from {@link managedInstallCommand} because two of the five installers
  * treat "install" as a no-op once the package is present: `brew install` on an
  * installed formula prints "already installed" and changes nothing, and `pip
  * install` without `--upgrade` does the same. Reusing the install command for
@@ -363,7 +369,7 @@ export function claudeNativeUpgradeCommand(pin?: string): Command {
  * {@link binUpgradeCommand} goes to the newest version, past the pin, and a
  * plain `uv tool install pkg==v` is a no-op once any version is installed.
  *
- * bun, npm and go take the version in the same token `binInstallCommand` builds
+ * bun, npm and go take the version in the same token `managedInstallCommand` builds
  * (`pkg@v`), and each replaces an installed version with it. pip goes through
  * the resolved installer's own `pin`. brew installs only its newest version, so
  * there is nothing to return — the planner never asks for it (a brew pin below
@@ -387,7 +393,7 @@ export function binPinCommand(
 		case "bun":
 		case "npm":
 		case "go":
-			return binInstallCommand(bin, python);
+			return managedInstallCommand(bin);
 		case "pip":
 			return python.pin(bin.package ?? bin.name, bin.version);
 		case "brew":
@@ -405,7 +411,7 @@ export function binPinCommand(
  * `bun install -g pkg@latest` and left the tool permanently ahead of its pin,
  * a state magus cannot leave. Both now come through here.
  *
- * `install` → {@link binInstallCommand} (which appends the pin, when there is
+ * `install` → {@link managedInstallCommand} (which appends the pin, when there is
  * one). An upgrade whose target IS the pin → {@link binPinCommand}, because
  * {@link binUpgradeCommand} would overshoot it. Any other upgrade → the newest
  * version.
@@ -426,7 +432,7 @@ export function binCommandForState(
 	},
 	python: PythonCliInstaller = resolvePythonCliInstaller(),
 ): Command | null {
-	if (state === "install") return binInstallCommand(bin, python);
+	if (state === "install") return managedInstallCommand(bin);
 	if (bin.version && target === bin.version) return binPinCommand(bin, python);
 	return binUpgradeCommand(bin, python);
 }