magus-cli 7.7.0 → 7.9.0

package/src/types/index.ts

@@ -1,4 +1,9 @@
 import type { ModelsConfig } from "../services/models-core.js";
+import type {
+	InstallOption,
+	Requirement,
+	Via,
+} from "../shared/plugin/hooks/lib/requires-probe.js";
 
 export interface McpServer {
 	name: string;
@@ -409,14 +414,52 @@ export interface ProfileManifest {
 	profiles: Record<string, ProfileManifestEntry>;
 }
 
-// ─── Plugin binary requirements (plugin.json `requires.bin`) ────────────────────
+// ─── Binary requirements (profile cliTools, and plugin requires) ────────────────
 
-/** How a binary dependency is installed. */
-export type BinInstaller = "bun" | "brew" | "npm" | "pip" | "go";
+/**
+ * What a plugin or a profile needs on the machine. One shape for both: a
+ * plugin's `requires` entry as requires-probe parses it, and a profile
+ * cliTools entry mapped onto the profile-only `npm`/`pip`/`go` kinds (or
+ * `bun`/`brew`) by `cliToolToBin`.
+ */
+export type BinRequirement = Requirement;
+export type BinInstallOption = InstallOption;
+
+/**
+ * A requirement with the install option chosen for this machine — selected
+ * once, where the requirement is resolved — and the plugin directory a
+ * `${CLAUDE_PLUGIN_ROOT}` check or a plugin-relative script resolves against
+ * (absent for a profile cliTool).
+ */
+export interface SelectedBin extends Requirement {
+	/** Null when no option can be used here (`whyUnselectable` says why). */
+	chosen: InstallOption | null;
+	root?: string;
+	/**
+	 * Profile pins the chosen option cannot install at: a tool a plugin owns
+	 * and installs from a release, Homebrew or apt, whose version is the
+	 * declaration's. Never applied, never dropped: `planDeps` reports each as
+	 * unfixable and `magus update` names it.
+	 */
+	refusedPins?: string[];
+}
+
+/** A selected requirement with its provenance: `plugin:<id>` / `profile:<name>.cliTools`. */
+export interface ResolvedBin extends SelectedBin {
+	sources: string[];
+}
+
+/** The install kinds whose installed version magus tracks and updates. */
+export type BinInstaller = Extract<Via, "bun" | "brew" | "npm" | "pip" | "go">;
 
-/** A single binary dependency a plugin (or profile) declares. */
-export interface BinRequirement {
-	/** The executable name expected on PATH (also the dedup key). */
+/**
+ * A requirement whose chosen option is one of the {@link BinInstaller} kinds,
+ * in the shape `magus update` and the CLI Tools screen track versions in.
+ * Derived from a {@link SelectedBin} by `managedTool` (services/toolchain.ts)
+ * or built from a catalogue entry; never declared by hand.
+ */
+export interface ManagedTool {
+	/** The executable name expected on PATH. */
 	name: string;
 	via: BinInstaller;
 	/** Package id for bun/npm/pip (defaults to `name`). */
@@ -425,25 +468,19 @@ export interface BinRequirement {
 	formula?: string;
 	/** Module path for `go install` (defaults to `name`). */
 	module?: string;
-	/** Command that verifies presence, e.g. "tmux -V" (defaults to `<name> --version`). */
+	/** The check, as one display line, e.g. "tmux -V" (defaults to `<name> --version`). */
 	check?: string;
 	/** Optional version pin (real for bun/npm/pip; advisory for brew/go). */
 	version?: string;
 }
 
-/** The `requires` block a plugin may declare in its plugin.json. */
-export interface PluginRequires {
-	bin?: BinRequirement[];
+/** A {@link ManagedTool} with its provenance. */
+export interface ManagedBin extends ManagedTool {
+	sources: string[];
 }
 
 // ─── Resolved install closure (resolver output) ─────────────────────────────────
 
-/** A binary requirement after dedup + pin precedence, with provenance. */
-export interface ResolvedBin extends BinRequirement {
-	/** Where this requirement came from, for diagnostics. */
-	sources: string[];
-}
-
 /**
  * The fully-resolved set of things to install for a profile (or the union of
  * all profiles). Produced by the resolver; consumed by `magus install`.
@@ -486,6 +523,13 @@ export interface ResolvedClosure {
 export interface DependencyReport {
 	/** Enabled only because an enabled plugin depends on them. Sorted. */
 	derived: string[];
+	/**
+	 * For every dependency an enabled plugin declares — derived ones and ones
+	 * the profile also names — the plugin whose plugin.json first asked for it,
+	 * so a report can say which plugin still needs it. Optional because a
+	 * hand-built report may carry no provenance.
+	 */
+	requiredBy?: Record<string, string>;
 	/** Enabled plugins whose plugin.json could not be read here. Sorted. */
 	unreadable: string[];
 	/** A dependency the profile itself turns off: `plugin` will not load. */

package/src/ui/App.tsx

@@ -3,8 +3,6 @@ import { activePluginPins } from "../services/active-closure.js";
 import { isClaudeAvailable } from "../services/claude-cli.js";
 import {
 	findStaleLoads,
-	migrateMarketplaceRename,
-	recoverMarketplaceSettings,
 	repairAllStaleLoads,
 } from "../services/claude-settings.js";
 import {
@@ -12,7 +10,6 @@ import {
 	startupGitignoreNeed,
 } from "../services/gitignore-check.js";
 import { applyStartupFixes } from "../services/gitignore-service.js";
-import { repairAllMarketplaces } from "../services/local-marketplace.js";
 import { autoAddMissingMarketplaces } from "../services/marketplace-sync.js";
 import {
 	type ProfileStartupNeed,
@@ -24,22 +21,19 @@ import {
 	checkForUpdates,
 	getCurrentVersion,
 } from "../services/version-check.js";
+import {
+	gitignoreStartupReport,
+	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 +54,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 +177,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 +208,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 +261,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 +278,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 +346,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 +373,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 +408,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 +429,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 +445,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,39 +540,32 @@ 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(() => {
 		const noRefresh = process.argv.includes("--no-refresh");
 		if (noRefresh) return;
 
-		dispatch({
-			type: "SHOW_PROGRESS",
-			state: { message: "Scanning marketplaces..." },
-		});
-
-		// Migrate old marketplace names -> magus (idempotent), then repair plugin.json files
-		migrateMarketplaceRename().catch(() => {}); // non-blocking, best-effort
-
+		// Opening magus reads Claude Code's files and never writes them: the
+		// marketplace registry, its clones, installed_plugins.json and every
+		// settings.json are Claude Code's. The one change made here goes through
+		// Claude Code's own CLI.
+		//
 		// Auto-add marketplaces referenced by enabledPlugins but missing from
 		// the local registry. Fixes the "fresh clone of a project whose
 		// .claude/settings.json enables @magus plugins but this machine has
@@ -612,68 +573,17 @@ 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")
-		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",
-					);
-				}
-			})
-			.catch(() => {}); // non-fatal
-
-		repairAllMarketplaces()
-			.then(async () => {
-				dispatch({ type: "HIDE_PROGRESS" });
-				dispatch({ type: "DATA_REFRESH_COMPLETE" });
-			})
-			.catch(() => {
-				dispatch({ type: "HIDE_PROGRESS" });
-			});
-	}, [dispatch, notify]);
+	}, []);
 
 	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>