magus-cli 7.7.0 → 7.8.0

package/src/ui/App.tsx

@@ -24,22 +24,20 @@ import {
 	checkForUpdates,
 	getCurrentVersion,
 } from "../services/version-check.js";
+import {
+	gitignoreStartupReport,
+	marketplaceRefreshReport,
+	profileStartupReport,
+	staleRepairReport,
+} from "./adapters/startupReports.js";
 import { ScreenErrorBoundary } from "./components/ScreenErrorBoundary.js";
 import { TABS } from "./components/TabBar.js";
 import { ProgressBar } from "./components/layout/ProgressBar.js";
 import { ModalContainer } from "./components/modals/index.js";
-import {
-	startupFixNotices,
-	useGitignoreModal,
-} from "./hooks/useGitignoreModal.js";
-import {
-	activationWarnings,
-	useProfileStartupModal,
-} from "./hooks/useProfileStartupModal.js";
-import {
-	staleLoadRepairNotices,
-	useStaleLoadModal,
-} from "./hooks/useStaleLoadModal.js";
+import { nextStartupStep } from "./hooks/startupQueue.js";
+import { useGitignoreModal } from "./hooks/useGitignoreModal.js";
+import { useProfileStartupModal } from "./hooks/useProfileStartupModal.js";
+import { useStaleLoadModal } from "./hooks/useStaleLoadModal.js";
 import { KeyRouter, useKeyLayer } from "./input/KeyRouter.js";
 import { type GlobalHandlers, runGlobalBindings } from "./keymap.js";
 import {
@@ -60,14 +58,12 @@ import {
 	useApp,
 	useModal,
 	useNavigation,
-	useNotify,
 } from "./state/AppContext.js";
 import {
 	DimensionsProvider,
 	useDimensions,
 } from "./state/DimensionsContext.js";
-import type { Notice, Screen } from "./state/types.js";
-import { truncate } from "./text-width.js";
+import type { FailureReport, Screen } from "./state/types.js";
 import { theme } from "./theme.js";
 
 export const VERSION = getCurrentVersion();
@@ -185,72 +181,6 @@ function UpdateBanner({ result }: { result: VersionCheckResult }) {
 	);
 }
 
-/**
- * NoticeBanner Component
- * The app's one notice line (or a few): what an action did, from `useNotify`.
- * It sits above the screen and outside the modal slot, so it never takes a key
- * and never stands in the way of a startup question. Each line clears itself
- * at its `expiresAt` — counting only time with no modal open.
- *
- * One notice is exactly ONE row: the layout reserves one row per notice
- * (`transientBannerCount`), so a line that wrapped would push the screen's
- * last rows off the terminal. Hence no wrapping, and the text clipped to the
- * width — the start of a line says what happened, and that is what survives.
- */
-function NoticeBanner({ notices }: { notices: readonly Notice[] }) {
-	const { state, dispatch } = useApp();
-	const { terminalWidth } = useDimensions();
-	const modalOpen = state.modal !== null;
-	const paused = state.noticesPausedAt !== null;
-
-	// Hold the notices while a modal is open. A warning posted just before a
-	// startup question, or under it, would otherwise run down behind it and be
-	// gone by the time the user has answered.
-	useEffect(() => {
-		dispatch({
-			type: modalOpen ? "PAUSE_NOTICES" : "RESUME_NOTICES",
-			now: Date.now(),
-		});
-	}, [modalOpen, dispatch]);
-
-	// One timer, for the line that expires first; the reducer then drops every
-	// line past its time, and the next render schedules the one after. None
-	// while paused: RESUME_NOTICES moves every `expiresAt` on first.
-	useEffect(() => {
-		if (notices.length === 0 || paused) return;
-		const next = Math.min(...notices.map((n) => n.expiresAt));
-		const timer = setTimeout(
-			() => dispatch({ type: "EXPIRE_NOTICES", now: Date.now() }),
-			Math.max(0, next - Date.now()),
-		);
-		return () => clearTimeout(timer);
-	}, [notices, paused, dispatch]);
-
-	// The box's left and right padding.
-	const width = Math.max(0, terminalWidth - 2);
-	return (
-		<>
-			{notices.map((notice) => (
-				<box key={notice.id} paddingLeft={1} paddingRight={1} height={1}>
-					<text
-						wrapMode="none"
-						fg={
-							notice.tone === "warning"
-								? theme.colors.warning
-								: theme.colors.success
-						}
-					>
-						{truncate(
-							`${notice.tone === "warning" ? "⚠" : "✓"} ${notice.text}`,
-							width,
-						)}
-					</text>
-				</box>
-			))}
-		</>
-	);
-}
-
 /**
  * ProgressIndicator Component
  * Shows progress bar when operations are running
@@ -282,13 +212,12 @@ interface AppContentInnerProps {
 
 function AppContentInner({ updateInfo, onExit }: AppContentInnerProps) {
 	const { state } = useApp();
-	const { progress, notices } = state;
+	const { progress } = state;
 	const dimensions = useDimensions();
 
 	return (
 		<box flexDirection="column" height={dimensions.terminalHeight}>
 			{updateInfo?.updateAvailable && <UpdateBanner result={updateInfo} />}
-			<NoticeBanner notices={notices} />
 			{progress && <ProgressIndicator {...progress} />}
 			<box
 				flexDirection="column"
@@ -336,7 +265,6 @@ interface AppContentProps {
 function AppContent({ onExit }: AppContentProps) {
 	const { state, dispatch } = useApp();
 	const { progress } = state;
-	const notify = useNotify();
 	const [updateInfo, setUpdateInfo] = useState<VersionCheckResult | null>(null);
 	const [gitignoreData, setGitignoreData] = useState<QueuedGitignore | null>(
 		null,
@@ -354,6 +282,19 @@ function AppContent({ onExit }: AppContentProps) {
 	const [profileNeed, setProfileNeed] = useState<ProfileStartupNeed | null>(
 		null,
 	);
+	// What startup work could not do — the profile gate's refusals and its
+	// activations, a marketplace refresh — waiting for the modal slot, oldest
+	// first. Each is the one failure popup; the TUI says nothing else.
+	const [startupReports, setStartupReports] = useState<FailureReport[]>([]);
+	const queueReports = React.useCallback(
+		(...reports: Array<FailureReport | null>) => {
+			const present = reports.filter((r): r is FailureReport => r !== null);
+			if (present.length > 0) {
+				setStartupReports((queued) => [...queued, ...present]);
+			}
+		},
+		[],
+	);
 	const gitignoreModal = useGitignoreModal();
 	const [brokenPluginCount, setBrokenPluginCount] = useState<number | null>(
 		null,
@@ -409,8 +350,8 @@ function AppContent({ onExit }: AppContentProps) {
 	// The hooks keep the slot occupied for their whole flow (a loading modal
 	// while their fix runs, never HIDE_MODAL mid-flow), because an empty slot is
 	// what lets the next question in. A flow that succeeds ends by hiding its
-	// loading modal and reporting through `useNotify`: a notice is not in the
-	// modal slot, so it cannot hold the next question back or be replaced by it. That does not stop a SCREEN from emptying
+	// loading modal and reports nothing: the screen it leaves shows the result.
+	// That does not stop a SCREEN from emptying
 	// it: `useModal().confirm` hides its modal when answered and the screen shows
 	// its loading modal a microtask later. A key pressed before the profile check
 	// resolved lands the profile question in exactly that gap, and the screen's
@@ -436,8 +377,32 @@ function AppContent({ onExit }: AppContentProps) {
 	// it and then the fresh one asked the same question twice. The fresh result
 	// replaces the queued one instead (see the check effect below).
 	useEffect(() => {
-		if (state.modal) return;
-		if (gitignoreData && !gitignorePending) {
+		// The order lives in `nextStartupStep`, where it is tested: failure
+		// reports first — something that already happened, and the question
+		// after it may be answered differently once it is known — so the profile
+		// gate's refusals land before the profile question, which they do not
+		// replace; then gitignore, broken plugins, and the profile last.
+		const step = nextStartupStep({
+			modalOpen: !!state.modal,
+			reports: startupReports,
+			gitignoreReady: !!gitignoreData && !gitignorePending,
+			brokenCount: brokenPluginCount,
+			profileNeed,
+		});
+		if (!step) return;
+		if (step.kind === "report") {
+			setStartupReports(step.rest);
+			dispatch({
+				type: "SHOW_MODAL",
+				modal: {
+					type: "failures",
+					report: step.report,
+					onDismiss: () => dispatch({ type: "HIDE_MODAL" }),
+				},
+			});
+			return;
+		}
+		if (step.kind === "gitignore" && gitignoreData) {
 			// Anything older than what is now on screen is dropped on arrival.
 			gitignoreCheck.current.shown = gitignoreData.request;
 			const need = gitignoreData.need;
@@ -447,15 +412,18 @@ function AppContent({ onExit }: AppContentProps) {
 				generated: need.generated,
 				// In place, then back to the app: tracked generated files are
 				// untracked, missing entries added; other items stay for the tab.
+				// A file git would not untrack is named with git's reason.
 				onFixSafe: async () =>
-					startupFixNotices(await applyStartupFixes(state.projectPath)),
+					gitignoreStartupReport(
+						(await applyStartupFixes(state.projectPath)).failed,
+					),
 			});
 			setGitignoreData(null);
 			return;
 		}
-		if (brokenPluginCount !== null) {
+		if (step.kind === "stale-load") {
 			staleLoadModal.show({
-				brokenCount: brokenPluginCount,
+				brokenCount: step.brokenCount,
 				// Re-surveys before repairing, like the gitignore fixer: the registry
 				// may have moved between the startup scan and the user pressing Enter,
 				// and repairing from the stale count would act on rows that are no
@@ -465,8 +433,10 @@ function AppContent({ onExit }: AppContentProps) {
 				// The pins are re-read with it, from the same helper the survey used: a
 				// repair that capped at a different ceiling than the offer was counted
 				// against would move rows the dialog never mentioned.
+				//
+				// A repair that did not take is named, with its reason.
 				onFix: async () =>
-					staleLoadRepairNotices(
+					staleRepairReport(
 						await repairAllStaleLoads(
 							state.projectPath,
 							undefined,
@@ -479,10 +449,12 @@ function AppContent({ onExit }: AppContentProps) {
 		}
 		// Not cleared here — see above. Re-called on every empty slot until the
 		// hook reports it answered.
-		if (profileNeed) profileModal.show(profileNeed);
+		if (step.kind === "profile") profileModal.show(step.need);
 	}, [
 		state.modal,
 		state.projectPath,
+		dispatch,
+		startupReports,
 		gitignoreData,
 		gitignorePending,
 		gitignoreModal,
@@ -572,25 +544,21 @@ function AppContent({ onExit }: AppContentProps) {
 				// edits into the active profile, regenerate from a changed
 				// profiles.json, restore a lost marker — then the question, if one
 				// is left to ask.
-				const { need, notices, problems, activations } =
-					await prepareProfileStartup(process.cwd());
-				// A refusal never blocks the TUI at startup: it is shown beside what
-				// the gate did, as a warning, and the user is still asked whatever
-				// is left. What a re-render left to act on — a plugin that will not
-				// load, one not downloaded yet — is a warning too, in user terms.
-				for (const line of notices) notify(line);
-				for (const activation of activations) {
-					for (const line of activationWarnings(activation)) {
-						notify(line.text, line.tone);
-					}
-				}
-				for (const line of problems) notify(line, "warning");
+				// A refusal never blocks the TUI at startup: the user is still asked
+				// whatever is left, and the screens show the state as it is. What
+				// the gate refused, and what its re-render could not do, go into ONE
+				// failure popup first — one step, one popup — queued in the same
+				// tick as the question, so it is shown before it.
+				const { need, problems, activations } = await prepareProfileStartup(
+					process.cwd(),
+				);
+				queueReports(profileStartupReport(problems, activations ?? []));
 				if (!needsNothing(need)) setProfileNeed(need);
 			} catch {
 				// non-fatal: the Profiles tab still works by hand
 			}
 		})();
-	}, [notify]);
+	}, [queueReports]);
 
 	// Auto-refresh marketplaces on startup
 	useEffect(() => {
@@ -612,50 +580,29 @@ function AppContent({ onExit }: AppContentProps) {
 		(async () => {
 			try {
 				if (!(await isClaudeAvailable())) return;
-				const added = await autoAddMissingMarketplaces(process.cwd());
-				if (added.length > 0) {
-					notify(`Fixed: added marketplace(s): ${added.join(", ")}`);
-				}
+				await autoAddMissingMarketplaces(process.cwd());
 			} catch {
 				// non-fatal: user can still install marketplaces manually
 			}
 		})();
 
-		// Recover stale marketplace registry entries (e.g. "directory" -> "github")
+		// 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) => {
-				const parts: string[] = [];
-				// Apart from `parts`: a success line would carry them in green,
-				// and a marketplace left stale is something the user may act on.
-				const failed: string[] = [];
-				if (recovery.reregistered.length > 0) {
-					// Update the marketplace clone now that the source is fixed
-					const { updateMarketplace } = await import(
-						"../services/claude-cli.js"
-					);
-					for (const mp of recovery.reregistered) {
-						try {
-							await updateMarketplace(mp);
-							parts.push(`${mp} refreshed`);
-						} catch {
-							failed.push(mp);
-						}
-					}
-				}
-				if (recovery.removed.length > 0) {
-					parts.push(`removed: ${recovery.removed.join(", ")}`);
-				}
-				if (parts.length > 0) {
-					notify(`Fixed: ${parts.join(" | ")}`);
-				}
-				if (failed.length > 0) {
-					notify(
-						`Could not refresh marketplace(s): ${failed.join(", ")}`,
-						"warning",
-					);
+				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(() => {}); // non-fatal
+			.catch(() => {}); // the recovery itself: non-fatal
 
 		repairAllMarketplaces()
 			.then(async () => {
@@ -665,15 +612,12 @@ function AppContent({ onExit }: AppContentProps) {
 			.catch(() => {
 				dispatch({ type: "HIDE_PROGRESS" });
 			});
-	}, [dispatch, notify]);
+	}, [dispatch, queueReports]);
 
 	return (
 		<DimensionsProvider
 			showProgress={!!progress}
 			showUpdateBanner={!!updateInfo?.updateAvailable}
-			// One row per notice line, so the screen below shrinks rather than
-			// being pushed off the bottom of the terminal.
-			transientBannerCount={state.notices.length}
 		>
 			<AppContentInner updateInfo={updateInfo} onExit={onExit} />
 		</DimensionsProvider>

package/src/ui/adapters/cliToolsAdapter.ts

@@ -17,6 +17,7 @@
  * Pure: no IO, no React. The screen gathers facts; this only assembles.
  */
 
+import path from "node:path";
 import type { CliTool } from "../../data/cli-tools.js";
 import {
 	cliToolInstall,
@@ -31,8 +32,11 @@ import {
 } from "../../services/tool-probe.js";
 import { binCommandForState } from "../../services/toolchain.js";
 import type { BinRequirement, ResolvedBin } from "../../types/index.js";
-import type { Command } from "../../utils/command-utils.js";
+import { type Command, formatCommand } from "../../utils/command-utils.js";
 import type { StatusTone } from "../renderers/pluginStatusText.js";
+import type { FailureReport } from "../state/types.js";
+import { counted, failureReport, withoutBinaryPaths } from "./failureReport.js";
+import { CLAUDE_MISSING_REASON, exceptionReason } from "./pluginsAdapter.js";
 
 export interface CliToolRow {
 	tool: CliTool;
@@ -303,3 +307,201 @@ export function countToolRows(rows: readonly CliToolRow[]): {
 	}
 	return { installed, updates, unverified };
 }
+
+// ─── Failures ────────────────────────────────────────────────────────────────
+//
+// Every installer command that fails goes into the failure popup with why and
+// the command to run by hand. Update-all used to discard them: the reload
+// showed the tool still behind, with no reason anywhere.
+
+/**
+ * The verb for what an Enter action did not do — "installed", "updated",
+ * "reinstalled". The caller writes the headline around it:
+ * `${tool} was not ${cliToolNotDone(kind)}`.
+ */
+export function cliToolNotDone(kind: CliToolEnterAction["kind"]): string {
+	if (kind === "install") return "installed";
+	if (kind === "reinstall") return "reinstalled";
+	return "updated";
+}
+
+/** One installer command that did not succeed. */
+export interface CliToolCommandFailure {
+	/** The tool's display name. */
+	tool: string;
+	command: Command;
+	/** Why, in {@link commandFailureReason}'s words. */
+	reason: string;
+}
+
+/** The longest reason kept from an installer's own output. */
+const MAX_REASON = 160;
+
+/**
+ * npm's bookkeeping lines, which never say why: the error code and syscall
+ * fields, and where its log went.
+ */
+const INSTALLER_NOISE =
+	/^(?:code|errno|syscall|path|dest)\b|^(?:A complete log of this run|Log files were not written|You can rerun|For a full report see)\b/i;
+
+/**
+ * The name a user knows a command by: `/usr/local/bin/npm` → `npm`. Which
+ * copy of npm the machine found is mechanism, never part of a reason.
+ */
+function commandName(command: Command): string {
+	return path.basename(command.cmd) || command.cmd;
+}
+
+/** How a timeout reads, so its fix can be told apart from an ordinary failure. */
+const TIMED_OUT_REASON = /^did not finish within \d+ seconds$/;
+
+/**
+ * The fix for a timeout. Not "Run it yourself": the same command would take
+ * just as long. A slow download is the usual cause, so it names the network
+ * without claiming that is what happened.
+ */
+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.
+ *
+ * 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.
+ */
+export function commandFailureReason(
+	command: Command,
+	error: unknown,
+	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") {
+		return name === "claude"
+			? CLAUDE_MISSING_REASON
+			: `${name} is not installed on this machine`;
+	}
+	if (e.killed || e.signal === "SIGTERM") {
+		return `did not finish within ${Math.round(timeoutMs / 1000)} seconds`;
+	}
+	const lines = String(e.stderr ?? "")
+		.split("\n")
+		.map((line) => line.replace(/^npm (?:ERR!|error)\b/i, "").trim())
+		.filter((line) => line !== "" && !INSTALLER_NOISE.test(line));
+	const said = lines.find((line) => /\berror:\s*\S/i.test(line));
+	let reason = said
+		? said.slice(said.toLowerCase().lastIndexOf("error:") + 6).trim()
+		: (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`;
+	}
+	reason = withoutBinaryPaths(reason);
+	return reason.length > MAX_REASON
+		? `${reason.slice(0, MAX_REASON - 1)}…`
+		: reason;
+}
+
+/**
+ * The fix for one failed installer command.
+ *
+ * Usually the command itself, to run by hand. Not for the three causes that
+ * running the same command again would not cure: a timeout, no `claude` to
+ * run, and no network. Each keeps the fix that does help.
+ */
+export function commandFailureFix(command: Command, reason: string): string {
+	if (TIMED_OUT_REASON.test(reason)) return RETRY_TIMEOUT_FIX;
+	const known = exceptionReason(reason);
+	if (known.fix) return known.fix;
+	return `Run it yourself: ${formatCommand(command)}`;
+}
+
+/** The popup for failed installer commands, each with the fix that helps. */
+export function cliToolFailureReport(
+	headline: string,
+	failures: readonly CliToolCommandFailure[],
+): FailureReport | null {
+	return failureReport(
+		headline,
+		failures.map((f) => ({
+			subject: f.tool,
+			reason: f.reason,
+			fix: commandFailureFix(f.command, f.reason),
+		})),
+		{ group: false },
+	);
+}
+
+/** Update-all: the tools whose update command failed. */
+export function cliToolsNotUpdatedReport(
+	failures: readonly CliToolCommandFailure[],
+): FailureReport | null {
+	const n = failures.length;
+	return cliToolFailureReport(
+		`${counted(n, "tool")} ${n === 1 ? "was" : "were"} not updated`,
+		failures,
+	);
+}
+
+/**
+ * A conflict magus cannot resolve: the tool is installed more than one way
+ * and none of the installs can be removed from here.
+ */
+export function cliToolConflictStuckReport(
+	tool: string,
+	blockers: ReadonlyArray<{ method: string; reason: string }>,
+): FailureReport | null {
+	return failureReport(
+		`${tool} is installed ${blockers.length} ways, and magus can remove none of them`,
+		blockers.map(({ method, reason }) => ({
+			subject: `${method} install`,
+			reason,
+			fix: "Remove one by hand, then press r",
+		})),
+		{ group: false },
+	);
+}
+
+/**
+ * A conflict resolved only in part: each removal that failed, with the
+ * command to run by hand, and each install magus could never remove.
+ */
+export function cliToolConflictPartialReport(
+	tool: string,
+	failed: ReadonlyArray<{ method: string; command: Command; reason: string }>,
+	leftBehind: ReadonlyArray<{ method: string; reason: string }>,
+): FailureReport | null {
+	return failureReport(
+		`${tool} is still installed more than one way`,
+		[
+			...failed.map((f) => ({
+				subject: `${f.method} install`,
+				reason: `was not removed: ${f.reason}`,
+				fix: `Run it yourself: ${formatCommand(f.command)}`,
+			})),
+			...leftBehind.map(({ method, reason }) => ({
+				subject: `${method} install`,
+				reason: `stays: ${reason}`,
+				fix: "Remove it by hand if you want it gone",
+			})),
+		],
+		{ group: false },
+	);
+}