claudeup 6.5.1 → 6.7.1

package/src/ui/screens/CliToolsScreen.tsx

@@ -1,4 +1,4 @@
-import { exec, execFile } from "node:child_process";
+import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import React, { useEffect, useCallback, useState, useRef } from "react";
 import { ScreenLayout } from "../components/layout/index.js";
@@ -7,221 +7,76 @@ import { useApp, 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 { cliToolUninstall } from "../../services/cli-tool-commands.js";
 import {
-	type InstallMethod,
-	cliToolInstall,
-	cliToolUninstall,
-	cliToolUpdate,
-} from "../../services/cli-tool-commands.js";
+	type InstallInfo,
+	PROBE_CONCURRENCY,
+	REAL_TOOL_PROBE_IO,
+	detectInstallMethods,
+	probeTools,
+	specForCatalogTool,
+} from "../../services/tool-probe.js";
 import type { Command } from "../../utils/command-utils.js";
 import { formatCommand } from "../../utils/command-utils.js";
+import {
+	type CliToolRow,
+	buildToolRow,
+	countToolRows,
+	isInstalled,
+} from "../adapters/cliToolsAdapter.js";
 import { ScrollableList } from "../components/ScrollableList.js";
 import {
-	type CliToolStatus,
 	renderCliToolDetail,
 	renderCliToolRow,
 } from "../renderers/cliToolRenderers.js";
 import { theme } from "../theme.js";
 
-const execAsync = promisify(exec);
 const execFileAsync = promisify(execFile);
 
-// ─── Version helpers ───────────────────────────────────────────────────────────
+// ─── Session cache ─────────────────────────────────────────────────────────────
+//
+// The probe itself lives in services/tool-probe.ts — the same one `claudeup
+// update` uses — so this screen and the CLI cannot disagree about a tool. It
+// 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.
 
-// Session-level cache
-let cachedToolStatuses: CliToolStatus[] | null = null;
+let cachedRows: CliToolRow[] | null = null;
 let cacheInitialized = false;
+/** Bumped by every fetch, so a refresh discards the answers of the one before. */
+let fetchGeneration = 0;
 
 function clearCliToolsCache(): void {
-	cachedToolStatuses = null;
+	cachedRows = null;
 	cacheInitialized = false;
 }
 
-function parseVersion(versionOutput: string): string | undefined {
-	const match = versionOutput.match(/v?(\d+\.\d+\.\d+(?:-[\w.]+)?)/);
-	return match ? match[1] : undefined;
-}
-
-function methodFromPath(binPath: string): InstallMethod | null {
-	if (binPath.includes("/.bun/")) return "bun";
-	if (binPath.includes("/homebrew/") || binPath.includes("/Cellar/"))
-		return "brew";
-	if (
-		binPath.includes("/.local/share/claude") ||
-		binPath.includes("/.local/bin/claude")
-	)
-		return "npm";
-	if (binPath.includes("/.nvm/") || binPath.includes("/node_modules/"))
-		return "npm";
-	if (binPath.includes("/.local/share/pnpm") || binPath.includes("/pnpm/"))
-		return "pnpm";
-	if (binPath.includes("/.yarn/")) return "yarn";
-	return null;
-}
-
-interface InstallInfo {
-	primary: InstallMethod;
-	all: InstallMethod[];
-	brewFormula?: string;
-}
-
-/** Extract brew formula name from a Cellar symlink target like ../Cellar/gemini-cli/0.35.2/bin/gemini */
-function extractBrewFormula(
-	binPath: string,
-	linkTarget: string,
-): string | undefined {
-	// Try symlink target first: ../Cellar/{formula}/{version}/...
-	const cellarMatch = linkTarget.match(/Cellar\/([^/]+)\//);
-	if (cellarMatch) return cellarMatch[1];
-	// Try binary path: /opt/homebrew/Cellar/{formula}/...
-	const pathMatch = binPath.match(/Cellar\/([^/]+)\//);
-	if (pathMatch) return pathMatch[1];
-	return undefined;
+/** Rows before anything is known: the catalogue mapping, checking. */
+function initialRows(): CliToolRow[] {
+	return cliTools.map((tool) =>
+		buildToolRow(tool, specForCatalogTool(tool, null, undefined), undefined),
+	);
 }
 
-async function detectInstallMethods(
-	tool: import("../../data/cli-tools.js").CliTool,
-): Promise<InstallInfo> {
-	const fallback = tool.packageManager === "pip" ? "pip" : "unknown";
-	try {
-		// which -a returns all matching binaries across PATH
-		const { stdout } = await execAsync(`which -a ${tool.name} 2>/dev/null`, {
-			timeout: 3000,
-			shell: "/bin/bash",
-		});
-		const paths = stdout
-			.trim()
-			.split("\n")
-			.filter((p) => p && !p.includes("aliased"));
-		if (paths.length === 0)
-			return { primary: fallback as InstallMethod, all: [] };
-
-		const methods: InstallMethod[] = [];
-		let brewFormula: string | undefined;
-
-		for (const binPath of paths) {
-			let method = methodFromPath(binPath);
-			let linkTarget = "";
-
-			// Check symlink target
-			try {
-				const { stdout: lt } = await execAsync(
-					`readlink "${binPath}" 2>/dev/null || true`,
-					{ timeout: 2000, shell: "/bin/bash" },
-				);
-				linkTarget = lt.trim();
-				if (!method) method = methodFromPath(linkTarget);
-			} catch {
-				// ignore
-			}
-
-			// Detect brew formula name
-			if (method === "brew" && !brewFormula) {
-				brewFormula = extractBrewFormula(binPath, linkTarget);
-			}
-
-			if (method && !methods.includes(method)) methods.push(method);
+/** `fn` over `items`, at most `limit` at a time, results in input order. */
+async function mapLimited<T, R>(
+	items: readonly T[],
+	limit: number,
+	fn: (item: T) => Promise<R>,
+): Promise<R[]> {
+	const out: R[] = new Array(items.length);
+	let next = 0;
+	const worker = async () => {
+		while (next < items.length) {
+			const i = next++;
+			const item = items[i];
+			if (item !== undefined) out[i] = await fn(item);
 		}
-
-		const primary = methods[0];
-		if (primary === undefined)
-			return { primary: fallback as InstallMethod, all: [] };
-		return { primary, all: methods, brewFormula };
-	} catch {
-		return { primary: fallback as InstallMethod, all: [] };
-	}
-}
-
-async function getInstalledVersion(
-	tool: import("../../data/cli-tools.js").CliTool,
-): Promise<string | undefined> {
-	try {
-		const { stdout } = await execAsync(tool.checkCommand, { timeout: 5000 });
-		return parseVersion(stdout.trim());
-	} catch {
-		return undefined;
-	}
-}
-
-async function getLatestNpmVersion(
-	packageName: string,
-): Promise<string | undefined> {
-	try {
-		const { stdout } = await execAsync(
-			`npm view ${packageName} version 2>/dev/null`,
-			{ timeout: 10000 },
-		);
-		return stdout.trim() || undefined;
-	} catch {
-		return undefined;
-	}
-}
-
-/**
- * Pick the version out of a PyPI JSON API body.
- *
- * Split out from the fetch so it is testable without a network: the parsing is
- * the part that can be wrong, and the part that must not throw.
- */
-export function versionFromPypiJson(body: unknown): string | undefined {
-	const info = (body as { info?: { version?: unknown } } | null)?.info;
-	return typeof info?.version === "string" ? info.version : undefined;
-}
-
-/**
- * Latest published version of a Python package, straight from PyPI.
- *
- * Was `pip index versions <pkg> | head -1` through a shell, which had three
- * independent problems and only needed one to fail: `pip` is often not an
- * executable at all (the bug this whole change exists for), `pip index` is an
- * experimental subcommand upstream reserves the right to change, and a machine
- * managing its Python tools with uv or pipx may carry no `pip` whatsoever.
- *
- * An HTTP GET needs none of them. Failure mode is unchanged — undefined, so the
- * row simply shows no update badge — because a version check is advisory and
- * must never take the screen down with it.
- */
-async function getLatestPipVersion(
-	packageName: string,
-): Promise<string | undefined> {
-	try {
-		const res = await fetch(
-			`https://pypi.org/pypi/${encodeURIComponent(packageName)}/json`,
-			{ signal: AbortSignal.timeout(10000) },
-		);
-		if (!res.ok) return undefined;
-		return versionFromPypiJson(await res.json());
-	} catch {
-		return undefined;
-	}
-}
-
-async function getLatestVersion(
-	tool: import("../../data/cli-tools.js").CliTool,
-): Promise<string | undefined> {
-	switch (tool.packageManager) {
-		// bun packages are published to the npm registry, so `npm view` resolves them.
-		case "bun":
-		case "npm":
-			return getLatestNpmVersion(tool.packageName);
-		case "pip":
-			return getLatestPipVersion(tool.packageName);
-		// brew/go have no uniform remote version query here — skip the check.
-		default:
-			return undefined;
-	}
-}
-
-function compareVersions(v1: string, v2: string): number {
-	const parts1 = v1.split(/[-.]/).map((p) => Number.parseInt(p, 10) || 0);
-	const parts2 = v2.split(/[-.]/).map((p) => Number.parseInt(p, 10) || 0);
-	for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
-		const p1 = parts1[i] || 0;
-		const p2 = parts2[i] || 0;
-		if (p1 < p2) return -1;
-		if (p1 > p2) return 1;
-	}
-	return 0;
+	};
+	await Promise.all(
+		Array.from({ length: Math.min(limit, items.length) }, worker),
+	);
+	return out;
 }
 
 // ─── Component ─────────────────────────────────────────────────────────────────
@@ -232,68 +87,80 @@ export function CliToolsScreen() {
 	const modal = useModal();
 	const dimensions = useDimensions();
 
-	const [toolStatuses, setToolStatuses] = useState<CliToolStatus[]>(() => {
-		return (
-			cachedToolStatuses ||
-			cliTools.map((tool) => ({
-				tool,
-				installed: false,
-				installedVersion: undefined,
-				checking: true,
-			}))
-		);
-	});
+	const [rows, setRows] = useState<CliToolRow[]>(
+		() => cachedRows || initialRows(),
+	);
 
-	const statusesRef = useRef(toolStatuses);
-	statusesRef.current = toolStatuses;
+	const rowsRef = useRef(rows);
+	rowsRef.current = rows;
 
-	const updateToolStatus = useCallback(
-		(index: number, updates: Partial<CliToolStatus>) => {
-			setToolStatuses((prev) => {
-				const newStatuses = [...prev];
-				newStatuses[index] = { ...newStatuses[index], ...updates };
-				cachedToolStatuses = newStatuses;
-				return newStatuses;
+	const setAndCache = useCallback(
+		(update: (prev: CliToolRow[]) => CliToolRow[]) => {
+			setRows((prev) => {
+				const next = update(prev);
+				cachedRows = next;
+				return next;
 			});
 		},
 		[],
 	);
 
+	/**
+	 * Detection first — it decides which installer each tool is probed through
+	 * (§4.5 of the design: the closure's spec, else the detected installer, else
+	 * the catalogue) — then one shared probe, rows filling in as tools settle.
+	 */
 	const fetchVersionInfo = useCallback(async () => {
-		for (let i = 0; i < cliTools.length; i++) {
-			const tool = cliTools[i];
-
-			// Run all checks in parallel, then update with all results
-			Promise.all([
-				getInstalledVersion(tool),
-				getLatestVersion(tool),
-				detectInstallMethods(tool),
-			]).then(([version, latest, info]) => {
-				updateToolStatus(i, {
-					installedVersion: version,
-					installed: version !== undefined,
-					latestVersion: latest,
-					checking: false,
-					hasUpdate:
-						version && latest ? compareVersions(version, latest) < 0 : false,
-					installMethod: version ? info.primary : undefined,
-					allMethods: version && info.all.length > 1 ? info.all : undefined,
-					updateCommand: version
-						? (cliToolUpdate(tool, info.primary, info.brewFormula) ?? undefined)
-						: undefined,
-					brewFormula: info.brewFormula,
-				});
-			});
-		}
-	}, [updateToolStatus]);
+		const generation = ++fetchGeneration;
+		const projectPath = state.projectPath || process.cwd();
+		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) =>
+				detectInstallMethods(tool, REAL_TOOL_PROBE_IO),
+			),
+		]);
+		if (generation !== fetchGeneration) return;
+
+		const closureBins = active?.closure.bins ?? null;
+		const planned = cliTools.map((tool, i) => ({
+			tool,
+			install: installs[i],
+			spec: specForCatalogTool(tool, closureBins, installs[i]),
+		}));
+		setAndCache(() =>
+			planned.map((p) => buildToolRow(p.tool, p.spec, undefined, p.install)),
+		);
+
+		await probeTools(
+			planned.map((p) => p.spec),
+			REAL_TOOL_PROBE_IO,
+			{
+				onResult: (facts, { index }) => {
+					if (generation !== fetchGeneration) 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;
+					});
+				},
+			},
+		);
+	}, [setAndCache, state.projectPath]);
 
 	useEffect(() => {
 		if (!cacheInitialized) {
 			cacheInitialized = true;
-			cachedToolStatuses = toolStatuses;
-			fetchVersionInfo();
+			cachedRows = rows;
+			void fetchVersionInfo();
 		}
-	}, [fetchVersionInfo, toolStatuses]);
+	}, [fetchVersionInfo, rows]);
 
 	useKeyboard((event) => {
 		if (state.isSearching || state.modal) return;
@@ -303,7 +170,7 @@ export function CliToolsScreen() {
 			dispatch({ type: "CLITOOLS_SELECT", index: newIndex });
 		} else if (event.name === "down" || event.name === "j") {
 			const newIndex = Math.min(
-				toolStatuses.length - 1,
+				rows.length - 1,
 				cliToolsState.selectedIndex + 1,
 			);
 			dispatch({ type: "CLITOOLS_SELECT", index: newIndex });
@@ -320,16 +187,9 @@ export function CliToolsScreen() {
 
 	const handleRefresh = () => {
 		clearCliToolsCache();
-		setToolStatuses(
-			cliTools.map((tool) => ({
-				tool,
-				installed: false,
-				installedVersion: undefined,
-				checking: true,
-			})),
-		);
-		cacheInitialized = false;
-		fetchVersionInfo();
+		setRows(initialRows());
+		cacheInitialized = true;
+		void fetchVersionInfo();
 	};
 
 	/**
@@ -354,17 +214,22 @@ export function CliToolsScreen() {
 	};
 
 	const handleInstall = async () => {
-		const status = toolStatuses[cliToolsState.selectedIndex];
-		if (!status) return;
-
-		const { tool, installed, hasUpdate, updateCommand } = status;
+		const row = rows[cliToolsState.selectedIndex];
+		if (!row || row.checking) return;
+
+		const { tool, status, updateCommand, installCommand } = row;
+		const installed = isInstalled(status);
+		// Enter on an `unknown` row still offers the detected-method command:
+		// an explicit user action, not a plan. The detail panel shows why the
+		// row is unverified beside it.
 		const action = !installed
 			? "Installing"
-			: hasUpdate
+			: status?.state === "upgrade" || status?.state === "unknown"
 				? "Updating"
 				: "Reinstalling";
-		const command =
-			installed && updateCommand ? updateCommand : cliToolInstall(tool);
+		// Both sides come from the row, which built them from the SAME rule its
+		// state came from — a declared tool's pin included.
+		const command = installed && updateCommand ? updateCommand : installCommand;
 
 		modal.loading(`${action} ${tool.displayName}...`);
 		const result = await runCommand(command);
@@ -382,14 +247,16 @@ export function CliToolsScreen() {
 	};
 
 	const handleResolveConflict = async () => {
-		const status = toolStatuses[cliToolsState.selectedIndex];
-		if (!status || !status.allMethods || status.allMethods.length < 2) return;
+		const row = rows[cliToolsState.selectedIndex];
+		const install: InstallInfo | undefined = row?.install;
+		if (!row || !install || install.all.length < 2) return;
 
-		const { tool, allMethods, installMethod, brewFormula } = status;
+		const { tool } = row;
+		const allMethods = install.all;
 
 		// Let user pick which install to keep
 		const options = allMethods.map((method) => ({
-			label: `Keep ${method}${method === installMethod ? " (active)" : ""}, remove others`,
+			label: `Keep ${method}${method === install.primary ? " (active)" : ""}, remove others`,
 			value: method,
 		}));
 
@@ -405,7 +272,7 @@ export function CliToolsScreen() {
 
 		const errors: string[] = [];
 		for (const method of toRemove) {
-			const cmd = cliToolUninstall(tool, method, brewFormula);
+			const cmd = cliToolUninstall(tool, method, install.brewFormula);
 			if (!cmd) continue;
 			const result = await runCommand(cmd);
 			if (!result.ok) errors.push(`${method}: ${formatCommand(cmd)}`);
@@ -425,11 +292,14 @@ export function CliToolsScreen() {
 	};
 
 	const handleUpdateAll = async () => {
-		const updatable = toolStatuses.filter((s) => s.hasUpdate);
+		// 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");
 		if (updatable.length === 0) {
 			await modal.message(
 				"Up to Date",
-				"All tools are already up to date.",
+				"No tool is known to be behind.",
 				"info",
 			);
 			return;
@@ -437,29 +307,33 @@ export function CliToolsScreen() {
 
 		modal.loading(`Updating ${updatable.length} tool(s)...`);
 
-		for (const status of updatable) {
-			const command = status.updateCommand || cliToolInstall(status.tool);
-			await runCommand(command);
+		for (const row of updatable) {
+			await runCommand(row.updateCommand ?? row.installCommand);
 		}
 
 		modal.hideModal();
 		handleRefresh();
 	};
 
-	const selectedStatus = toolStatuses[cliToolsState.selectedIndex];
+	const selectedRow = rows[cliToolsState.selectedIndex];
 
-	const installedCount = toolStatuses.filter((s) => s.installed).length;
-	const updateCount = toolStatuses.filter((s) => s.hasUpdate).length;
+	const counts = countToolRows(rows);
 	const statusContent = (
 		<text fg={theme.colors.text}>
 			<span fg={theme.colors.muted}>Installed: </span>
 			<span fg={theme.colors.info}>
-				{installedCount}/{toolStatuses.length}
+				{counts.installed}/{rows.length}
 			</span>
-			{updateCount > 0 && (
+			{counts.updates > 0 && (
 				<>
 					<span fg={theme.colors.muted}> │ Updates: </span>
-					<span fg={theme.colors.warning}>{updateCount}</span>
+					<span fg={theme.colors.warning}>{counts.updates}</span>
+				</>
+			)}
+			{counts.unverified > 0 && (
+				<>
+					<span fg={theme.colors.muted}> │ Unverified: </span>
+					<span fg={theme.colors.warning}>{counts.unverified}</span>
 				</>
 			)}
 		</text>
@@ -478,14 +352,14 @@ export function CliToolsScreen() {
 			]}
 			listPanel={
 				<ScrollableList
-					items={toolStatuses}
+					items={rows}
 					selectedIndex={cliToolsState.selectedIndex}
 					renderItem={renderCliToolRow}
 					maxHeight={dimensions.listPanelHeight}
-					getKey={(status) => status.tool.name}
+					getKey={(row) => row.tool.name}
 				/>
 			}
-			detailPanel={renderCliToolDetail(selectedStatus)}
+			detailPanel={renderCliToolDetail(selectedRow)}
 		/>
 	);
 }