magus-cli 7.7.0 → 7.9.0

package/src/ui/screens/AliasScreen.tsx

@@ -32,6 +32,8 @@ import {
 	validateAliasName,
 	withoutDerivedChannel,
 } from "../../services/alias-store.js";
+import { failureReport } from "../adapters/failureReport.js";
+import { stepFailureReport } from "../adapters/startupReports.js";
 import {
 	FlagDetailEditor,
 	type FlagDetailEditorHandle,
@@ -39,7 +41,7 @@ import {
 import { ScreenLayout } from "../components/layout/index.js";
 import { useScreenKeys } from "../input/KeyRouter.js";
 import { moveDirection } from "../keymap.js";
-import { useApp, useModal, useNotify } from "../state/AppContext.js";
+import { useApp, useFailurePopup, useModal } from "../state/AppContext.js";
 import { displayWidth, truncate } from "../text-width.js";
 import { theme } from "../theme.js";
 
@@ -114,7 +116,7 @@ type ViewMode = { kind: "main" } | { kind: "flag-detail"; flagId: string };
 export function AliasScreen() {
 	const { state } = useApp();
 	const modal = useModal();
-	const notify = useNotify();
+	const showFailures = useFailurePopup();
 
 	const [config, setConfig] = useState<AliasConfig | null>(null);
 	const [shells, setShells] = useState<ShellTarget[]>([]);
@@ -127,11 +129,6 @@ export function AliasScreen() {
 		string,
 		FlagValue
 	> | null>(null);
-	// Transient write feedback shown on the header status line (not a blocking
-	// modal). Auto-clears after a few seconds. Errors still use a modal since
-	// they need to be read and acknowledged.
-	const [writeStatus, setWriteStatus] = useState<string | null>(null);
-
 	// A hand-written `claude` alias found OUTSIDE any managed block on mount.
 	// Set when the rc file has no managed block but a stray alias we could
 	// adopt — drives the one-time "import it?" offer below. Cleared once the
@@ -144,13 +141,6 @@ export function AliasScreen() {
 		[number, number] | null
 	>(null);
 
-	// Clear the write status line a few seconds after it appears.
-	useEffect(() => {
-		if (!writeStatus) return;
-		const t = setTimeout(() => setWriteStatus(null), 4000);
-		return () => clearTimeout(t);
-	}, [writeStatus]);
-
 	// One-time "adopt a hand-written alias?" offer. Fires when the mount load
 	// found a stray `claude` alias outside any managed block. We import only the
 	// flags we recognized; whether we also TAKE OWNERSHIP (remove the original
@@ -421,14 +411,12 @@ export function AliasScreen() {
 			try {
 				await saveAliasName(name);
 			} catch (err) {
-				await modal.message(
-					"Save failed",
-					err instanceof Error ? err.message : String(err),
-					"error",
+				await showFailures(
+					stepFailureReport("The alias name was not saved", name, err),
 				);
 			}
 		},
-		[modal],
+		[showFailures],
 	);
 
 	// Cascade dependencies on every mutation:
@@ -500,12 +488,16 @@ export function AliasScreen() {
 		if (v === null) return;
 		const reason = validateAliasName(v);
 		if (reason) {
-			await modal.message("Invalid alias name", reason, "error");
+			await showFailures(
+				failureReport("The alias name was not changed", [
+					{ subject: v === "" ? "(empty)" : v, reason },
+				]),
+			);
 			return;
 		}
 		setConfig((prev) => (prev ? { ...prev, aliasName: v } : prev));
 		void persistAliasName(v);
-	}, [config, modal, persistAliasName]);
+	}, [config, modal, persistAliasName, showFailures]);
 
 	const editSelected = useCallback(async () => {
 		if (!selectedRow) return;
@@ -566,10 +558,16 @@ export function AliasScreen() {
 			shells.find((s) => s.exists);
 
 		if (!target) {
-			// Nothing was written. Named files, because creating one is the fix.
-			notify(
-				"No shell config to write to — create ~/.zshrc, ~/.bashrc or ~/.config/fish/config.fish first",
-				"warning",
+			// Nothing was written — a failure, like the write failing below. Named
+			// files, because creating one is the fix.
+			await showFailures(
+				failureReport("The alias was not written", [
+					{
+						subject: "shell config",
+						reason: "there is no shell config file to write it to",
+						fix: "Create ~/.zshrc, ~/.bashrc or ~/.config/fish/config.fish, then press w again",
+					},
+				]),
 			);
 			return;
 		}
@@ -579,7 +577,7 @@ export function AliasScreen() {
 			// the FIRST write replaces that line in place (absorbing it into the
 			// managed block) rather than appending a second alias. Once the block
 			// exists, the writer ignores the range and splices by markers.
-			const r = await writeAliasToShell(
+			await writeAliasToShell(
 				config,
 				target,
 				pendingAdoptRange ? { adoptLineRange: pendingAdoptRange } : {},
@@ -587,23 +585,20 @@ export function AliasScreen() {
 			// The adopted line is now gone (replaced by the block); drop the range
 			// so subsequent writes don't try to re-target a line that moved.
 			if (pendingAdoptRange) setPendingAdoptRange(null);
-			// Non-blocking confirmation on the status line — no "press any key".
-			const name = r.path.split("/").pop() || r.path;
-			setWriteStatus(
-				`✓ ${r.action === "created" ? "Created" : "Updated"} ${name} — source it or open a new shell`,
-			);
+			// Written: no message. The header shows it — the snapshot now matches
+			// the in-memory flags, so "unsaved, w writes …" disappears.
 			setShells(await detectShells());
-			// We just wrote the rc file with current in-memory flag values, so
-			// the snapshot now matches in-memory state. Dirty indicator clears.
 			setRcSnapshot(config.flags);
 		} catch (err) {
-			await modal.message(
-				"Write failed",
-				err instanceof Error ? err.message : String(err),
-				"error",
+			await showFailures(
+				stepFailureReport(
+					"The alias was not written",
+					`${target.kind} config`,
+					err,
+				),
 			);
 		}
-	}, [config, shells, modal, notify, pendingAdoptRange]);
+	}, [config, shells, pendingAdoptRange, showFailures]);
 
 	// ── Keyboard ──────────────────────────────────────────────────────────
 	// j/k navigate the selectable subset, jumping over headers/legend lines.
@@ -830,13 +825,11 @@ export function AliasScreen() {
 		: 0;
 	const subtitle = inDetail
 		? `editing ${detailFlag.flag}`
-		: writeStatus
-			? writeStatus
-			: config
-				? `${enabledCount} flag${enabledCount === 1 ? "" : "s"} enabled${
-						dirty ? ` │ * unsaved, w writes ${writeLabel}` : ""
-					}`
-				: "";
+		: config
+			? `${enabledCount} flag${enabledCount === 1 ? "" : "s"} enabled${
+					dirty ? ` │ * unsaved, w writes ${writeLabel}` : ""
+				}`
+			: "";
 
 	return (
 		<ScreenLayout

package/src/ui/screens/CliToolsScreen.tsx

@@ -1,19 +1,26 @@
-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";
 import { moveDirection } from "../keymap.js";
-import { useApp, useModal, useNotify } from "../state/AppContext.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,15 +29,28 @@ import {
 	probeTools,
 	specForCatalogTool,
 } from "../../services/tool-probe.js";
+import { managedBins } from "../../services/toolchain.js";
 import type { Command } from "../../utils/command-utils.js";
-import { formatCommand } 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,
 	cliToolEnterAction,
+	cliToolFailureReport,
+	cliToolNotDone,
+	cliToolsNotUpdatedReport,
+	commandFailureReason,
 	countToolRows,
+	isPluginManagedRow,
+	rowName,
 } from "../adapters/cliToolsAdapter.js";
+import { installBinsInTui } from "../adapters/depsAdapter.js";
 import { ScrollableList } from "../components/ScrollableList.js";
 import {
 	renderCliToolDetail,
@@ -38,7 +58,8 @@ 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;
 
 // ─── Session cache ─────────────────────────────────────────────────────────────
 //
@@ -47,7 +68,7 @@ const execFileAsync = promisify(execFile);
 // 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();
@@ -57,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),
 	);
 }
@@ -91,10 +115,10 @@ export function CliToolsScreen() {
 	const { state, dispatch } = useApp();
 	const { cliTools: cliToolsState } = state;
 	const modal = useModal();
-	const notify = useNotify();
+	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. */
@@ -104,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;
@@ -128,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));
@@ -209,47 +283,64 @@ export function CliToolsScreen() {
 	};
 
 	/**
-	 * Run one installer command and report success.
+	 * 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 and discarded here; the modal is the progress
-	 * indicator.
+	 * 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<{ ok: boolean; error?: string }> => {
-		try {
-			await execFileAsync(command.cmd, [...command.args], { timeout: 60000 });
-			return { ok: true };
-		} catch (err) {
-			const msg = err instanceof Error ? err.message : String(err);
-			return { ok: false, error: msg };
-		}
+	const runCommand = async (command: Command): Promise<string | null> => {
+		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 result = await runCommand(command);
+		const reason = await runCommand(command);
 		modal.hideModal();
 
-		if (result.ok) {
+		if (reason === null) {
 			handleRefresh();
-		} else {
-			await modal.message(
-				"Error",
-				`Failed to ${action.toLowerCase()} ${tool.displayName}.\n\nTry running manually:\n${formatCommand(command)}`,
-				"error",
-			);
+			return;
 		}
+		await showFailures(
+			cliToolFailureReport(
+				`${tool.displayName} was not ${cliToolNotDone(enter.kind)}`,
+				[{ tool: tool.displayName, command, reason }],
+			),
+		);
 	};
 
 	/**
@@ -268,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;
@@ -285,6 +377,11 @@ export function CliToolsScreen() {
 			methods
 				.map((m) => `The ${m} install stays: ${blockers.get(m)}.`)
 				.join("\n");
+		const blockerRows = (methods: readonly InstallMethod[]) =>
+			methods.map((method) => ({
+				method,
+				reason: blockers.get(method) ?? "magus cannot remove it",
+			}));
 
 		// One choice per install that can be KEPT — but only where keeping it
 		// removes something. "Keep npm" beside an unremovable native copy would
@@ -298,10 +395,8 @@ export function CliToolsScreen() {
 			}));
 
 		if (options.length === 0) {
-			await modal.message(
-				`${tool.displayName} conflict`,
-				`Installed via ${allMethods.join(" + ")}, and magus can remove none of them.\n\n${stuckList(allMethods)}\n\nRemove one by hand, then press r.`,
-				"error",
+			await showFailures(
+				cliToolConflictStuckReport(tool.displayName, blockerRows(allMethods)),
 			);
 			return;
 		}
@@ -319,42 +414,37 @@ export function CliToolsScreen() {
 		const leftBehind = stuck.filter((m) => m !== keep);
 		modal.loading(`Removing ${toRemove.join(", ")} install(s)...`);
 
-		const errors: string[] = [];
+		const failed: Array<{
+			method: InstallMethod;
+			command: Command;
+			reason: string;
+		}> = [];
+		const unremovable = blockerRows(leftBehind);
 		for (const method of toRemove) {
 			const cmd = cliToolUninstall(tool, method, install.brewFormula);
 			// Unreachable: `removable` was built from this same call. Reported
 			// rather than skipped, because a silent skip is the defect above.
 			if (!cmd) {
-				errors.push(`${method}: no uninstall command`);
+				unremovable.push({
+					method,
+					reason: "magus has no uninstall command for it",
+				});
 				continue;
 			}
-			const result = await runCommand(cmd);
-			if (!result.ok) errors.push(`${method}: ${formatCommand(cmd)}`);
+			const reason = await runCommand(cmd);
+			if (reason !== null) failed.push({ method, command: cmd, reason });
 		}
 
 		modal.hideModal();
 
-		const stays =
-			leftBehind.length > 0
-				? `${stuckList(leftBehind)}\nRemove it by hand if you want it gone.`
-				: "";
-
-		// A failed removal is an error, and stays a dialog with the commands to
-		// run. An install magus could never remove is only a warning: nothing
-		// failed, and the row still shows the conflict until it is dealt with.
-		if (errors.length > 0) {
-			await modal.message(
-				"Partly removed",
-				[
-					`These removals failed. Run them by hand:\n${errors.join("\n")}`,
-					stays,
-				]
-					.filter((part) => part !== "")
-					.join("\n\n"),
-				"error",
+		// A failed removal goes into the failure popup with the command to run,
+		// and so does an install left behind beside it. An install magus could
+		// never remove is not, on its own, a failure: nothing failed, and the row
+		// still shows the conflict until it is dealt with.
+		if (failed.length > 0 || unremovable.length > leftBehind.length) {
+			await showFailures(
+				cliToolConflictPartialReport(tool.displayName, failed, unremovable),
 			);
-		} else if (stays !== "") {
-			notify(stays.replace(/\n/g, " "), "warning");
 		}
 
 		handleRefresh();
@@ -364,20 +454,28 @@ 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");
-		if (updatable.length === 0) {
-			notify("No tool is known to be behind");
-			return;
-		}
+		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)...`);
 
+		// Every failure is kept: the reload shows the tool still behind, and
+		// only this says why.
+		const failed: CliToolCommandFailure[] = [];
 		for (const row of updatable) {
-			await runCommand(row.updateCommand ?? row.installCommand);
+			const command = row.updateCommand ?? row.installCommand;
+			const reason = await runCommand(command);
+			if (reason !== null) {
+				failed.push({ tool: row.tool.displayName, command, reason });
+			}
 		}
 
 		modal.hideModal();
 		handleRefresh();
+		await showFailures(cliToolsNotUpdatedReport(failed));
 	};
 
 	const selectedRow = rows[cliToolsState.selectedIndex];
@@ -406,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
@@ -429,7 +530,7 @@ export function CliToolsScreen() {
 					selectedIndex={cliToolsState.selectedIndex}
 					renderItem={renderCliToolRow}
 					maxHeight={dimensions.listPanelHeight}
-					getKey={(row) => row.tool.name}
+					getKey={rowName}
 				/>
 			}
 			detailPanel={(detailWidth) =>