magus-cli 7.7.0 → 7.9.0

package/src/ui/hooks/useProfileStartupModal.ts

@@ -17,10 +17,7 @@
 
 import { useCallback, useRef } from "react";
 import { getManifestPath } from "../../services/manifest.js";
-import type {
-	ActivationResult,
-	ProfileChoice,
-} from "../../services/profile-activate.js";
+import type { ProfileChoice } from "../../services/profile-activate.js";
 import type { DisplacedArtifact } from "../../services/profile-live.js";
 import {
 	type ProfileStartupNeed,
@@ -36,8 +33,17 @@ import {
 } from "../../services/profile-startup.js";
 import { applyProfileChoice } from "../../services/profile-state.js";
 import { SettingsParseError } from "../../services/settings-file.js";
-import { useApp, useNotify } from "../state/AppContext.js";
-import type { ModalState, NoticeLine } from "../state/types.js";
+import { exceptionReason } from "../adapters/pluginsAdapter.js";
+import {
+	activationFailureReport,
+	profileProblemsReport,
+	stepFailureReport,
+} from "../adapters/startupReports.js";
+import { useApp } from "../state/AppContext.js";
+import type { FailureReport, ModalState } from "../state/types.js";
+
+/** The headline for every way "Update it now" can fail. */
+const FORMAT_NOT_UPDATED = "The profile format was not updated";
 
 export interface BuildProfileModalArgs {
 	need: ProfileStartupNeed;
@@ -84,81 +90,6 @@ export function buildProfileStartupModal(
 	};
 }
 
-/** `typescript-lsp@claude-plugins-official` → `typescript-lsp`. */
-function pluginName(pluginId: string): string {
-	const at = pluginId.lastIndexOf("@");
-	return at > 0 ? pluginId.slice(0, at) : pluginId;
-}
-
-/** "a", "a and b", "a, b and c". */
-function listed(names: readonly string[]): string {
-	if (names.length <= 1) return names.join("");
-	return `${names.slice(0, -1).join(", ")} and ${names[names.length - 1]}`;
-}
-
-/**
- * What an activation did, as notices — for the startup question and the
- * Profiles tab alike: one line saying which profile is in use, then
- * {@link activationWarnings}.
- */
-export function activationNotices(result: ActivationResult): NoticeLine[] {
-	return [
-		{ text: `Using profile "${result.profileId}"`, tone: "success" },
-		...activationWarnings(result),
-	];
-}
-
-/**
- * What an activation left for the user to act on, one warning per thing, in
- * user terms. Alone, without {@link activationNotices}' "Using profile" line,
- * for an activation the user did not ask for — a re-render at startup, a
- * profile format update — where which profile is in use is not news.
- *
- * Deliberately NOT {@link activationNotes}, which the CLI prints. Several of
- * its lines are for a terminal log and would only be noise on this banner:
- * where displaced files were backed up (the backup still happens; nobody needs
- * to be told where), edits recorded into the profile being left (the switch
- * confirmation already said so), skills handed back to the team. Tracked
- * generated files are left out too: every activation signals
- * PROFILE_ACTIVATED, and the app re-runs its gitignore check on it — the
- * startup question and a Profiles-tab switch alike — which asks about exactly
- * those files, with a way to fix them.
- */
-export function activationWarnings(result: ActivationResult): NoticeLine[] {
-	const lines: NoticeLine[] = [];
-	const report = result.dependencies;
-	for (const { plugin, dependency } of report?.blocked ?? []) {
-		lines.push({
-			text: `${pluginName(plugin)} won't load: profile "${result.profileId}" turns off ${pluginName(dependency)}, which it needs`,
-			tone: "warning",
-		});
-	}
-	// The plugin's details are not on this machine yet, so what it depends on
-	// could not be enabled. One line for all of them: the fix is the same.
-	const missing = (report?.unreadable ?? []).map(pluginName);
-	if (missing.length > 0) {
-		lines.push({
-			text: `${listed(missing)} ${missing.length === 1 ? "isn't" : "aren't"} downloaded yet — run magus install`,
-			tone: "warning",
-		});
-	}
-	for (const f of result.skills.failed) {
-		lines.push({
-			text: `Skill "${f.skill}" could not be installed: ${f.reason}`,
-			tone: "warning",
-		});
-	}
-	// The one case that names a path: two copies of a skill, and which to keep
-	// is the user's call — they need to know where the other one is.
-	for (const c of result.conversion.conflicts) {
-		lines.push({
-			text: `Skill "${c.folder}" exists in two versions; kept ${c.kept}, the other is at ${c.other}`,
-			tone: "warning",
-		});
-	}
-	return lines;
-}
-
 /** Project-relative, so a path does not wrap over two lines. */
 function rel(p: string, projectPath: string): string {
 	return p.startsWith(projectPath) ? p.slice(projectPath.length + 1) : p;
@@ -184,27 +115,50 @@ export function describeFailure(
 	moved: DisplacedArtifact[],
 	projectPath: string,
 	declaredDefault: string | null,
-): string {
-	const reason = error instanceof Error ? error.message : String(error);
+	choice: ProfileChoice,
+): FailureReport {
+	const profile =
+		choice.kind === "adopt" ? (choice.name ?? choice.id) : choice.id;
+	const headline =
+		choice.kind === "adopt"
+			? `Profile "${profile}" was not created`
+			: `Profile "${profile}" was not activated`;
+	const e = exceptionReason(
+		error instanceof Error ? error.message : String(error),
+	);
 	if (moved.length === 0) {
-		return `${reason}\n\nNothing was moved, so this project is exactly as it was.`;
+		return {
+			headline,
+			rows: [
+				{
+					subject: profile,
+					reason: `${e.reason}; nothing was moved, so this project is exactly as it was`,
+				},
+			],
+			fix: e.fix ?? null,
+		};
 	}
-	return [
-		reason,
-		"",
-		"This did not finish, and these were already moved aside. They are kept:",
-		...moved.map(
-			(d) => `  ${rel(d.link, projectPath)} → ${rel(d.savedTo, projectPath)}`,
-		),
-		"",
+	return {
+		headline,
+		rows: [
+			{
+				subject: profile,
+				reason: `${e.reason}; this did not finish, and these files were already moved aside`,
+			},
+			...moved.map((d) => ({
+				subject: rel(d.link, projectPath),
+				reason: `is kept at ${rel(d.savedTo, projectPath)}`,
+			})),
+		],
 		// The trap the reviewer found: re-choosing "save what you have" after a
 		// partial failure runs adoption again, and adoption reads settings.json —
 		// which is now in the backup. It would capture an empty plugin set into a
 		// second profile and call that the user's setup.
-		declaredDefault !== null
-			? `Activating ${declaredDefault} again is safe. Do NOT save-what-you-have — the files above have moved, so it would capture an empty set.`
-			: "Activating a profile again is safe. Do NOT save-what-you-have — the files above have moved, so it would capture an empty set.",
-	].join("\n");
+		fix:
+			declaredDefault !== null
+				? `Activating ${declaredDefault} again is safe. Do NOT save-what-you-have — the files above have moved, so it would capture an empty set.`
+				: "Activating a profile again is safe. Do NOT save-what-you-have — the files above have moved, so it would capture an empty set.",
+	};
 }
 
 export interface ProfileStartupModalCallbacks {
@@ -228,8 +182,8 @@ export interface ProfileStartupModalCallbacks {
  * question on screen NOW, which is not always the one magus opened with: "Update
  * it now" asks a new one, and a manifest that stopped parsing turns the question
  * into the unparseable one. `working` is true while an activation or a format
- * update is running — when it settles it empties the slot (success, reported as
- * a notice) or puts its error modal there.
+ * update is running — when it settles it empties the slot (success) or puts its
+ * error modal there.
  */
 interface ProfileFlow {
 	need: ProfileStartupNeed;
@@ -242,7 +196,6 @@ export function useProfileStartupModal({
 	onAnswered,
 }: ProfileStartupModalCallbacks) {
 	const { state, dispatch } = useApp();
-	const notify = useNotify();
 	const projectPath = state.projectPath;
 	// A ref, not state: `show` is recreated on every render, and the flow must
 	// survive that — a re-show has to know what was last asked, and that work is
@@ -271,6 +224,26 @@ export function useProfileStartupModal({
 				answered();
 				onQuit();
 			};
+			/**
+			 * End a flow that activated a profile: empty the slot, or — when the
+			 * activation could not do something — put the failure popup in it.
+			 * Either way the question is already answered, so dismissing the popup
+			 * lets the next startup question in.
+			 */
+			const settle = (report: FailureReport | null): void => {
+				if (!report) {
+					dispatch({ type: "HIDE_MODAL" });
+					return;
+				}
+				dispatch({
+					type: "SHOW_MODAL",
+					modal: {
+						type: "failures",
+						report,
+						onDismiss: () => dispatch({ type: "HIDE_MODAL" }),
+					},
+				});
+			};
 
 			/**
 			 * Apply a choice, reporting the outcome either way. `current` is the
@@ -306,20 +279,17 @@ export function useProfileStartupModal({
 				void applyProfileChoice(choice, current.manifest, projectPath, {
 					onDisplace: (artifact) => moved.push(artifact),
 				})
-					.then((result: ActivationResult) => {
+					.then((result) => {
 						// Answered here, on success — NOT when the question was shown.
 						// Clearing it on show let a screen's modal replace it and the
 						// question never came back.
 						answered();
 						onActivated?.();
 						// No result modal and no jump to the Profiles tab: the user
-						// stays where they are, told in the notice banner. An automatic
-						// activation is reported the same way, so it is never
-						// invisible.
-						dispatch({ type: "HIDE_MODAL" });
-						for (const line of activationNotices(result)) {
-							notify(line.text, line.tone);
-						}
+						// stays where they are, and the screen reloads under them —
+						// unless the activation could not do something, which the one
+						// failure popup says once it has settled.
+						settle(activationFailureReport([result]));
 					})
 					.catch((error: unknown) => {
 						// The manifest stopped parsing between launch and this answer —
@@ -337,18 +307,14 @@ export function useProfileStartupModal({
 						dispatch({
 							type: "SHOW_MODAL",
 							modal: {
-								type: "message",
-								title:
-									choice.kind === "adopt"
-										? "Could not create the profile"
-										: "Could not activate the profile",
-								message: describeFailure(
+								type: "failures",
+								report: describeFailure(
 									error,
 									moved,
 									projectPath,
 									current.declaredDefault,
+									choice,
 								),
-								variant: "error",
 								// A failure leaves the project without an active profile, so
 								// dismissing returns to the question — including when the
 								// attempt was automatic, which is the one case where there
@@ -373,37 +339,47 @@ export function useProfileStartupModal({
 				void prepareProfileStartup(projectPath, { convert: true })
 					.then((result) => {
 						const outcome = formatUpdateOutcome(result);
-						// What the conversion's activation warns about — a plugin that
-						// will not load, one not downloaded yet, a skill that failed —
-						// in user terms. Posted whichever way it went, except a refusal,
-						// which converted nothing. Posting under the next question is
-						// safe: notices do not run down while a modal is open.
-						const warnings = (): void => {
-							for (const activation of result.activations) {
-								for (const line of activationWarnings(activation)) {
-									notify(line.text, line.tone);
-								}
-							}
-						};
+						const report = activationFailureReport(result.activations ?? []);
 						if (outcome.kind === "ask") {
 							// Converted, but no profile is active yet: a new question,
-							// still unanswered.
+							// still unanswered — asked once what the conversion could not
+							// do has been read.
 							onActivated?.();
+							if (report) {
+								flowRef.current = { need: outcome.need, working: false };
+								dispatch({
+									type: "SHOW_MODAL",
+									modal: {
+										type: "failures",
+										report,
+										onDismiss: () => ask(outcome.need),
+									},
+								});
+								return;
+							}
 							ask(outcome.need);
-							warnings();
 							return;
 						}
 						if (outcome.kind === "failed") {
 							// Refused, so still the old format: back to the question,
 							// as the CLI stops on the same lines.
+							// Each refusal in the failure popup, the file it is about
+							// named, and what to do about it.
+							// A "failed" outcome always carries problems; the fallback
+							// only keeps the popup's type honest.
 							flowRef.current = { need, working: false };
+							const refused =
+								profileProblemsReport(result.problems, FORMAT_NOT_UPDATED) ??
+								stepFailureReport(
+									FORMAT_NOT_UPDATED,
+									"profile",
+									outcome.message,
+								);
 							dispatch({
 								type: "SHOW_MODAL",
 								modal: {
-									type: "message",
-									title: outcome.title,
-									message: outcome.message,
-									variant: "error",
+									type: "failures",
+									report: refused,
 									onDismiss: () => ask(need),
 								},
 							});
@@ -412,19 +388,20 @@ export function useProfileStartupModal({
 						// Nothing left to ask: the converted profile is active.
 						answered();
 						onActivated?.();
-						dispatch({ type: "HIDE_MODAL" });
-						notify(outcome.notice);
-						warnings();
+						settle(report);
 					})
 					.catch((error: unknown) => {
 						flowRef.current = { need, working: false };
 						dispatch({
 							type: "SHOW_MODAL",
 							modal: {
-								type: "message",
-								title: "Could not update the profile format",
-								message: `${error instanceof Error ? error.message : String(error)}\n\nYour profiles are kept. Open magus again to retry.`,
-								variant: "error",
+								type: "failures",
+								report: stepFailureReport(
+									FORMAT_NOT_UPDATED,
+									"profile",
+									error,
+									"Your profiles are kept. Open magus again to retry",
+								),
 								onDismiss: () => ask(need),
 							},
 						});
@@ -494,15 +471,15 @@ export function useProfileStartupModal({
 
 			// The repo already answered and there is nothing of the user's to
 			// replace: asking here would ask someone to re-decide what their team
-			// decided, with nothing at stake. Reported in the notice banner, so it
-			// is never invisible.
+			// decided, with nothing at stake. The Profiles tab names the profile
+			// in use.
 			if (need.autoActivate && need.declaredDefault !== null) {
 				apply({ kind: "activate", id: need.declaredDefault });
 				return;
 			}
 			ask();
 		},
-		[dispatch, notify, projectPath, onQuit, onActivated, onAnswered],
+		[dispatch, projectPath, onQuit, onActivated, onAnswered],
 	);
 
 	return { show };

package/src/ui/hooks/useStaleLoadModal.ts

@@ -1,6 +1,7 @@
 import { useCallback } from "react";
-import { useApp, useNavigation, useNotify } from "../state/AppContext.js";
-import type { ModalState, NoticeLine } from "../state/types.js";
+import { stepFailureReport } from "../adapters/startupReports.js";
+import { useApp, useNavigation } from "../state/AppContext.js";
+import type { FailureReport, ModalState } from "../state/types.js";
 
 /**
  * Startup broken-plugin modal: magus launches, finds that Claude Code will load
@@ -71,13 +72,20 @@ export function buildStaleLoadModal(args: BuildStaleLoadModalArgs): ModalState {
 export function useStaleLoadModal() {
 	const { dispatch } = useApp();
 	const { navigateToScreen } = useNavigation();
-	const notify = useNotify();
 
 	const show = useCallback(
 		(args: {
 			brokenCount: number;
-			/** Runs the repair. Resolves to what to tell the user afterwards. */
-			onFix: () => Promise<readonly NoticeLine[]> | readonly NoticeLine[];
+			/**
+			 * Runs the repair and answers what it could not fix — null when every
+			 * plugin now loads its installed version. The Plugins screen shows
+			 * what now loads; the failures go into the one failure popup.
+			 */
+			onFix: () =>
+				| Promise<FailureReport | null | undefined>
+				| FailureReport
+				| null
+				| undefined;
 		}) => {
 			if (args.brokenCount === 0) return;
 			const dismiss = () => dispatch({ type: "HIDE_MODAL" });
@@ -88,33 +96,34 @@ export function useStaleLoadModal() {
 						type: "SHOW_MODAL",
 						modal: { type: "loading", message: "Repairing plugins…" },
 					});
-					// The outcome is REPORTED, never assumed. `repairStaleLoad` re-asks
-					// the loader after writing and can legitimately answer "still not
-					// loading the target"; swallowing that would leave the user believing
-					// a broken plugin was fixed.
+					// The outcome is never assumed: `repairStaleLoad` re-asks the loader
+					// after writing, and a plugin it could not fix still reads BROKEN on
+					// the Plugins screen.
 					//
 					// Called inside `.then` so a synchronous throw reaches `.catch`
 					// too; otherwise the loading modal stays up and swallows every key.
+					const fail = (report: FailureReport) =>
+						dispatch({
+							type: "SHOW_MODAL",
+							modal: { type: "failures", report, onDismiss: dismiss },
+						});
 					void Promise.resolve()
 						.then(() => args.onFix())
-						.then((summary) => {
-							// Hidden, not replaced: the loading modal swallows every key,
-							// and the result belongs in the notice banner, outside the
-							// modal slot the next startup question is waiting for.
-							dispatch({ type: "HIDE_MODAL" });
-							for (const line of summary) notify(line.text, line.tone);
+						.then((report) => {
+							// The loading modal must go — it swallows every key — and the
+							// next startup question is waiting for the slot. A repair
+							// that did not take puts the failure popup there instead.
+							if (report) fail(report);
+							else dispatch({ type: "HIDE_MODAL" });
 						})
 						.catch((err) => {
-							dispatch({
-								type: "SHOW_MODAL",
-								modal: {
-									type: "message",
-									title: "Plugin repair failed",
-									message: err instanceof Error ? err.message : String(err),
-									variant: "error",
-									onDismiss: dismiss,
-								},
-							});
+							fail(
+								stepFailureReport(
+									"The plugins were not repaired",
+									"repair",
+									err,
+								),
+							);
 						});
 				},
 				onOpenTab: () => {
@@ -125,47 +134,8 @@ export function useStaleLoadModal() {
 			});
 			dispatch({ type: "SHOW_MODAL", modal });
 		},
-		[dispatch, navigateToScreen, notify],
+		[dispatch, navigateToScreen],
 	);
 
 	return { show };
 }
-
-/**
- * What the repair did, as notices: one line for every plugin that now loads
- * the version installed, and a warning for each that still does not.
- *
- * Exported and pure so the wording is tested rather than inspected by eye. The
- * lines say what loads NOW, because that — not the row count — is the thing
- * the user came here to change. A failure is never folded into the success
- * line: `ok` is the loader re-asked after the write, and a repair that did not
- * take must read as one.
- */
-export function staleLoadRepairNotices(
-	results: ReadonlyArray<{
-		pluginId: string;
-		target: string;
-		ok: boolean;
-		error?: string;
-	}>,
-): NoticeLine[] {
-	if (results.length === 0) {
-		return [{ text: "Nothing needed repairing", tone: "success" }];
-	}
-	const lines: NoticeLine[] = [];
-	const fixed = results.filter((r) => r.ok);
-	if (fixed.length > 0) {
-		lines.push({
-			text: `Now loading ${fixed.map((r) => `${r.pluginId} v${r.target}`).join(", ")}`,
-			tone: "success",
-		});
-	}
-	for (const r of results) {
-		if (r.ok) continue;
-		lines.push({
-			text: `${r.pluginId} not repaired: ${r.error ?? "repair did not take effect"}`,
-			tone: "warning",
-		});
-	}
-	return lines;
-}

package/src/ui/keymap.ts

@@ -166,6 +166,13 @@ const PLUGINS = [
 		"Remove a deprecated plugin from every scope",
 		30,
 	),
+	bind(
+		"set-env",
+		["e"],
+		"settings",
+		"Set the variables a plugin's MCP server needs",
+		35,
+	),
 	bind("add-marketplace", ["n"], "add marketplace", "Add a marketplace", 30),
 	bind("team-help", ["t"], "team", "How to share marketplaces with a team", 10),
 	refresh("Refresh the local marketplace caches"),
@@ -374,7 +381,13 @@ const ALIAS = [
 		"Turn the flag on or off; in the flag editor, the row",
 		90,
 	),
-	bind("write", ["w"], "write", "Write the alias to your shell's rc file", 85),
+	bind(
+		"write",
+		["w"],
+		"write",
+		"Write the alias to your shell's rc file; a new shell picks it up",
+		85,
+	),
 	bind("edit", ["e"], "edit", "Edit the flag's value", 80),
 	bind("reset", ["r"], "reset", "Reset the row to its default", 50),
 	bind("add", ["a"], "add", "Flag editor: add a value", 80),