magus-cli 7.5.3 → 7.6.0

package/src/ui/hooks/useProfileStartupModal.ts

@@ -15,7 +15,7 @@
  * leave, which is why it needs the app's own exit.
  */
 
-import { useCallback } from "react";
+import { useCallback, useRef } from "react";
 import { getManifestPath } from "../../services/manifest.js";
 import {
 	type ActivationResult,
@@ -25,10 +25,14 @@ import {
 import type { DisplacedArtifact } from "../../services/profile-live.js";
 import {
 	type ProfileStartupNeed,
+	UPDATE_FORMAT_VALUE,
 	buildProfileOptions,
 	defaultOptionIndex,
 	describeNeed,
+	formatUpdateOutcome,
 	parseProfileChoice,
+	prepareProfileStartup,
+	profileIdForName,
 	unparseableNeed,
 } from "../../services/profile-startup.js";
 import { applyProfileChoice } from "../../services/profile-state.js";
@@ -39,6 +43,8 @@ import type { ModalState } from "../state/types.js";
 export interface BuildProfileModalArgs {
 	need: ProfileStartupNeed;
 	onChoose: (choice: ProfileChoice) => void;
+	/** "Update it now" on the `old-format` question — not a profile choice. */
+	onUpdateFormat?: () => void;
 	/**
 	 * Leave magus. NOT "dismiss" — there is deliberately no way to carry on
 	 * without a profile, because there is nothing to carry on with.
@@ -49,7 +55,7 @@ export interface BuildProfileModalArgs {
 export function buildProfileStartupModal(
 	args: BuildProfileModalArgs,
 ): ModalState {
-	const { need, onChoose, onQuit } = args;
+	const { need, onChoose, onUpdateFormat, onQuit } = args;
 	const { title, message } = describeNeed(need);
 	return {
 		type: "select",
@@ -60,6 +66,10 @@ export function buildProfileStartupModal(
 		// developer who has local work and therefore still gets asked.
 		defaultIndex: defaultOptionIndex(need),
 		onSelect: (value: string) => {
+			if (value === UPDATE_FORMAT_VALUE && onUpdateFormat) {
+				onUpdateFormat();
+				return;
+			}
 			const choice = parseProfileChoice(value, need);
 			if (choice) onChoose(choice);
 			else onQuit();
@@ -157,26 +167,85 @@ export function describeFailure(
 	].join("\n");
 }
 
-export function useProfileStartupModal(
-	onQuit: () => void,
+export interface ProfileStartupModalCallbacks {
+	/** Leave magus: the modal's only non-action. */
+	onQuit: () => void;
 	/** Called once a choice has activated a profile — see App's gitignore re-check. */
-	onActivated?: () => void,
-) {
+	onActivated?: () => void;
+	/**
+	 * The question is ANSWERED: a profile is active, or the user chose to quit.
+	 * Until this fires the caller must treat the question as outstanding and
+	 * call `show` again whenever the modal slot is empty — see `show`.
+	 */
+	onAnswered: () => void;
+}
+
+/**
+ * Where the profile question stands between `show` calls. `need` is the
+ * 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 — its result modal takes the slot when it settles.
+ */
+interface ProfileFlow {
+	need: ProfileStartupNeed;
+	working: boolean;
+}
+
+export function useProfileStartupModal({
+	onQuit,
+	onActivated,
+	onAnswered,
+}: ProfileStartupModalCallbacks) {
 	const { state, dispatch } = useApp();
 	const { navigateToScreen } = useNavigation();
 	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
+	// in flight, without a render in between.
+	const flowRef = useRef<ProfileFlow | null>(null);
 
+	/**
+	 * Show the profile question, or put it back.
+	 *
+	 * The caller calls this again whenever the modal slot is empty and the
+	 * question is unanswered. The modal cannot be dismissed, so an empty slot
+	 * then means something else took the slot and closed it — a screen's
+	 * `confirm` resolving, say, before its loading modal lands. So a second call
+	 * re-asks the question that was on screen, and never re-runs an automatic
+	 * activation. While work is in flight it does nothing: that work puts its own
+	 * result up when it settles, and asking again meanwhile would let a second
+	 * choice race the first.
+	 */
 	const show = useCallback(
 		(need: ProfileStartupNeed) => {
-			/** Apply a choice, reporting the outcome either way. */
-			const apply = (choice: ProfileChoice, automatic: boolean): void => {
+			const answered = (): void => {
+				flowRef.current = null;
+				onAnswered();
+			};
+			const quit = (): void => {
+				answered();
+				onQuit();
+			};
+
+			/**
+			 * Apply a choice, reporting the outcome either way. `current` is the
+			 * question it answers — after "Update it now" that is a NEW question,
+			 * whose manifest is the converted one, not the one magus opened with.
+			 */
+			const apply = (
+				choice: ProfileChoice,
+				automatic: boolean,
+				current: ProfileStartupNeed = need,
+			): void => {
+				flowRef.current = { need: current, working: true };
 				dispatch({
 					type: "SHOW_MODAL",
 					modal: {
 						type: "loading",
 						message:
 							choice.kind === "adopt"
-								? `Creating "${choice.id}"…`
+								? `Creating "${choice.name ?? choice.id}"…`
 								: `Activating ${choice.id}…`,
 					},
 				});
@@ -191,10 +260,14 @@ export function useProfileStartupModal(
 				// where they left it. `.magus-backups/` is gitignored, so git status
 				// showed the deletion and no sign of the copy.
 				const moved: DisplacedArtifact[] = [];
-				void applyProfileChoice(choice, need.manifest, projectPath, {
+				void applyProfileChoice(choice, current.manifest, projectPath, {
 					onDisplace: (artifact) => moved.push(artifact),
 				})
 					.then((result: ActivationResult) => {
+						// 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?.();
 						const { profileId, displaced } = result;
 						dispatch({
@@ -228,7 +301,10 @@ export function useProfileStartupModal(
 							error instanceof SettingsParseError &&
 							error.path === getManifestPath(projectPath)
 								? unparseableNeed(error)
-								: need;
+								: current;
+						// Still unanswered, and `next` is what a lost error modal
+						// returns to.
+						flowRef.current = { need: next, working: false };
 						dispatch({
 							type: "SHOW_MODAL",
 							modal: {
@@ -241,7 +317,7 @@ export function useProfileStartupModal(
 									error,
 									moved,
 									projectPath,
-									need.declaredDefault,
+									current.declaredDefault,
 								),
 								variant: "error",
 								// A failure leaves the project without an active profile, so
@@ -254,17 +330,140 @@ export function useProfileStartupModal(
 					});
 			};
 
+			/**
+			 * "Update it now" on an old profile format: update it — the same gate
+			 * the CLI runs after its own question — then ask whatever is left, or
+			 * say it is done.
+			 */
+			const updateFormat = (): void => {
+				flowRef.current = { need, working: true };
+				dispatch({
+					type: "SHOW_MODAL",
+					modal: { type: "loading", message: "Updating the profile format…" },
+				});
+				void prepareProfileStartup(projectPath, { convert: true })
+					.then((result) => {
+						const outcome = formatUpdateOutcome(result);
+						if (outcome.kind === "ask") {
+							// Converted, but no profile is active yet: a new question,
+							// still unanswered.
+							onActivated?.();
+							ask(outcome.need);
+							return;
+						}
+						if (outcome.kind === "failed") {
+							// Refused, so still the old format: back to the question,
+							// as the CLI stops on the same lines.
+							flowRef.current = { need, working: false };
+							dispatch({
+								type: "SHOW_MODAL",
+								modal: {
+									type: "message",
+									title: outcome.title,
+									message: outcome.message,
+									variant: "error",
+									onDismiss: () => ask(need),
+								},
+							});
+							return;
+						}
+						// Nothing left to ask: the converted profile is active.
+						answered();
+						onActivated?.();
+						dispatch({
+							type: "SHOW_MODAL",
+							modal: {
+								type: "message",
+								title: outcome.title,
+								message: outcome.message,
+								variant: "success",
+								onDismiss: () => {
+									dispatch({ type: "HIDE_MODAL" });
+									navigateToScreen("profiles");
+								},
+							},
+						});
+					})
+					.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",
+								onDismiss: () => ask(need),
+							},
+						});
+					});
+			};
+
+			/**
+			 * "Save what you have" picked: ask what to call it, with the generated
+			 * id as the suggestion. An invalid name is explained above the field and
+			 * asked again with what was typed still in it; Escape creates nothing
+			 * and goes back to the profile question.
+			 */
+			const askName = (
+				suggestion: string,
+				current: ProfileStartupNeed,
+				typed: string = suggestion,
+				reason?: string,
+			): void => {
+				dispatch({
+					type: "SHOW_MODAL",
+					modal: {
+						type: "input",
+						title: "Save as a new profile",
+						label: reason ? `${reason}\n\nProfile name` : "Profile name",
+						defaultValue: typed,
+						onSubmit: (value: string) => {
+							const check = profileIdForName(
+								value.trim() === "" ? suggestion : value,
+								current.manifest,
+							);
+							if (!check.ok) {
+								askName(suggestion, current, value, check.reason);
+								return;
+							}
+							apply(
+								{ kind: "adopt", id: check.id, name: check.name },
+								false,
+								current,
+							);
+						},
+						onCancel: () => ask(current),
+					},
+				});
+			};
+
 			function ask(current: ProfileStartupNeed = need): void {
+				flowRef.current = { need: current, working: false };
 				dispatch({
 					type: "SHOW_MODAL",
 					modal: buildProfileStartupModal({
 						need: current,
-						onChoose: (choice) => apply(choice, false),
-						onQuit,
+						onChoose: (choice) =>
+							choice.kind === "adopt"
+								? askName(choice.id, current)
+								: apply(choice, false, current),
+						onUpdateFormat: updateFormat,
+						onQuit: quit,
 					}),
 				});
 			}
 
+			const flow = flowRef.current;
+			// Work in flight owns the slot's next state; see the doc comment above.
+			if (flow?.working) return;
+			// Shown before and lost: put back the question that was on screen, not
+			// the one magus opened with, and never re-run an automatic activation.
+			if (flow) {
+				ask(flow.need);
+				return;
+			}
+
 			// 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 outcome modal, so it
@@ -275,7 +474,7 @@ export function useProfileStartupModal(
 			}
 			ask();
 		},
-		[dispatch, navigateToScreen, projectPath, onQuit, onActivated],
+		[dispatch, navigateToScreen, projectPath, onQuit, onActivated, onAnswered],
 	);
 
 	return { show };

package/src/ui/hooks/useStaleLoadModal.ts

@@ -91,7 +91,11 @@ export function useStaleLoadModal() {
 					// 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.
-					void Promise.resolve(args.onFix())
+					//
+					// Called inside `.then` so a synchronous throw reaches `.catch`
+					// too; otherwise the loading modal stays up and swallows every key.
+					void Promise.resolve()
+						.then(() => args.onFix())
 						.then((summary) => {
 							dispatch({
 								type: "SHOW_MODAL",

package/src/ui/input/KeyRouter.tsx

@@ -25,6 +25,10 @@
  * The paste event is deliberately NOT stopped: OpenTUI hands it to the focused
  * renderable afterwards, which is how the input modal's `<input>` still takes a
  * paste of its own — exactly the arrangement the modal layer relies on for keys.
+ *
+ * With ONE exception, for keys and pastes alike: an event never reaches a
+ * renderable that took focus while this router was dispatching it. See
+ * {@link dispatchThenGuardFocus}.
  */
 
 import { appendFileSync } from "node:fs";
@@ -133,6 +137,41 @@ function describeKey(key: KeyPress): string {
 	return `name=${JSON.stringify(key.name)} seq=${JSON.stringify(key.sequence)} ctrl=${key.ctrl} meta=${key.meta} shift=${key.shift}`;
 }
 
+/**
+ * Run `dispatch` for one key or paste event, committed synchronously, and then
+ * keep that event away from any renderable that took focus DURING it.
+ *
+ * OpenTUI delivers an event in two phases: every global listener first (this
+ * router is one), then every focused renderable. The renderable set is read
+ * AFTER the global phase returns (`InternalKeyHandler.emitWithPriority` in
+ * @opentui/core 0.1.107), not when the event arrived. And `flushSync` commits
+ * inside the global phase, so a modal this key opened is mounted, and its
+ * `<input focused>` has registered its handler, before that read happens.
+ * Left alone, the one keypress acts twice. MEASURED: Enter on "Save what you
+ * have" in the startup select opened the "Save as a new profile" input AND
+ * submitted its prefilled name, so the profile was created with no chance to
+ * type. By the same path, a screen key that opens an input before its first
+ * `await` (`n` on Styles, `r` on Profiles) reaches the new box as a typed
+ * letter, and Enter on such a row submits it.
+ *
+ * So the rule: an event goes to the renderable that held focus when it was
+ * pressed, or to nobody. When focus moved during dispatch, `preventDefault()`
+ * makes OpenTUI skip the renderable phase. Keys meant for an input modal that
+ * was already open are untouched: the router's modal layer does not move focus
+ * for them, and they reach the `<input>` as before.
+ */
+function dispatchThenGuardFocus(
+	renderer: { readonly currentFocusedRenderable: unknown },
+	event: { preventDefault(): void },
+	dispatch: () => void,
+): void {
+	const focusedBefore = renderer.currentFocusedRenderable;
+	flushSync(dispatch);
+	if (renderer.currentFocusedRenderable !== focusedBefore) {
+		event.preventDefault();
+	}
+}
+
 export function KeyRouter({ children }: { children: ReactNode }) {
 	const [layers] = useState<LayerRegistry>(() => ({
 		keys: new Set<KeyLayer>(),
@@ -143,7 +182,7 @@ export function KeyRouter({ children }: { children: ReactNode }) {
 	useKeyboard((event) => {
 		const key = toKeyPress(event);
 		let consumer: KeyLayerId | null = null;
-		flushSync(() => {
+		dispatchThenGuardFocus(renderer, event, () => {
 			consumer = dispatchKey([...layers.keys], key);
 		});
 		logKey(describeKey(key), consumer);
@@ -156,7 +195,9 @@ export function KeyRouter({ children }: { children: ReactNode }) {
 		const onPaste = (event: PasteEvent): void => {
 			const text = pastedText(event);
 			let consumer: KeyLayerId | null = null;
-			flushSync(() => {
+			// Same guard as keys: no paste handler moves focus today, but a paste
+			// that did must not land in the box it just opened.
+			dispatchThenGuardFocus(renderer, event, () => {
 				consumer = dispatchPaste([...layers.pastes], text);
 			});
 			logKey(`paste=${JSON.stringify(text)}`, consumer);

package/src/ui/keymap.ts

@@ -156,7 +156,7 @@ const PLUGINS = [
 		"save-profile",
 		["s"],
 		"profile",
-		"Save the enabled plugins as a profile",
+		"Save the installed plugins as a profile",
 		60,
 	),
 	bind(

package/src/ui/renderers/pluginRenderers.tsx

@@ -2,8 +2,11 @@ import type React from "react";
 import { getMarketplaceVersion } from "../../services/marketplace-fetcher.js";
 import {
 	compareVersions,
-	isEnabledButNotInstalled,
+	hasMissingFiles,
+	isInstalledAnywhere,
 	isInstalledInScope,
+	scopeFilesMissing,
+	versionInScope,
 } from "../../services/plugin-manager.js";
 import type { ScopeStatus } from "../../services/plugin-manager.js";
 import type { PluginComponentKind } from "../../services/skills-manager.js";
@@ -195,9 +198,12 @@ function pluginRow(
 	isSelected: boolean,
 ): React.ReactNode {
 	const { plugin } = item;
-	const hasUser = !!plugin.userScope?.enabled;
-	const hasProject = !!plugin.projectScope?.enabled;
-	const hasLocal = !!plugin.localScope?.enabled;
+	// The squares and the name colour read the one installed-at-scope test, the
+	// same one the detail panel's dots read, so the row and the panel beside it
+	// cannot show two different states.
+	const hasUser = isInstalledInScope(plugin.userScope);
+	const hasProject = isInstalledInScope(plugin.projectScope);
+	const hasLocal = isInstalledInScope(plugin.localScope);
 	const hasAnyScope = hasUser || hasProject || hasLocal;
 
 	// Everything after the name — version, history badge, status — comes from
@@ -257,24 +263,13 @@ function pluginRow(
 		);
 	}
 
-	const installedSomewhere =
-		isInstalledInScope(plugin.userScope) ||
-		isInstalledInScope(plugin.projectScope) ||
-		isInstalledInScope(plugin.localScope);
-
 	return (
 		<text fg={theme.colors.text}>
 			<span> </span>
 			<ScopeSquares user={hasUser} project={hasProject} local={hasLocal} />
 			<span> </span>
 			<span fg={theme.colors.dim}>{arrow}</span>
-			<span
-				fg={
-					hasAnyScope && installedSomewhere
-						? theme.colors.text
-						: theme.colors.muted
-				}
-			>
+			<span fg={hasAnyScope ? theme.colors.text : theme.colors.muted}>
 				{displayName}
 			</span>
 			<RowSegments segments={segments} selected={false} />
@@ -344,14 +339,10 @@ function pluginDetail(
 	fetched?: PluginContentsEntry,
 ): React.ReactNode {
 	const { plugin, status } = item;
-	// "Installed" has to mean the same thing here as in the list row. Reading the
-	// `enabledPlugins` flag alone made this panel print "● Installed" for the
-	// exact plugin the row beside it was labelling "not installed".
-	const isInstalled =
-		isInstalledInScope(plugin.userScope) ||
-		isInstalledInScope(plugin.projectScope) ||
-		isInstalledInScope(plugin.localScope);
-	const brokenInstall = isEnabledButNotInstalled(plugin);
+	// "Installed" means the same thing here as in the list row: the one
+	// installed-at-scope test, at any scope.
+	const isInstalled = isInstalledAnywhere(plugin);
+	const filesMissing = hasMissingFiles(plugin);
 	// The ⬆ marker and the U hint claim that pressing U does something. That is
 	// exactly the classifier's update/repair, and nothing else.
 	const needsWork = status?.action === "update" || status?.action === "repair";
@@ -453,25 +444,25 @@ function pluginDetail(
 			<box marginTop={1}>
 				<text
 					fg={
-						isInstalled
-							? theme.colors.success
-							: brokenInstall
-								? theme.colors.danger
+						filesMissing
+							? theme.colors.danger
+							: isInstalled
+								? theme.colors.success
 								: theme.colors.muted
 					}
 				>
-					{isInstalled
-						? "● Installed"
-						: brokenInstall
-							? "○ Not installed — enabled in settings, no files on disk"
+					{filesMissing
+						? "● Installed — files missing"
+						: isInstalled
+							? "● Installed"
 							: "○ Not installed"}
 				</text>
 			</box>
-			{brokenInstall ? (
+			{filesMissing ? (
 				<box>
 					<text fg={theme.colors.muted}>
 						Claude Code cannot load it in this state. Press the scope key to
-						repair.
+						reinstall.
 					</text>
 				</box>
 			) : null}
@@ -631,10 +622,15 @@ function pluginDetail(
 /**
  * One line of the detail panel's scope breakdown.
  *
- * The filled dot means installed — registry-backed, same as everywhere else.
- * A scope that is enabled with nothing installed is called out explicitly
- * rather than shown as a plain empty dot, because those two states need
- * different actions from the user and used to look identical.
+ * The filled dot means what the list row's square means — installed at this
+ * scope — because both read `isInstalledInScope`. The version shows only where
+ * the plugin is installed: a registry row can be inherited from another
+ * directory of the same repository, and magus run in `tools/magus` once showed
+ * "Project team v0.8.1" for a plugin that directory's settings never turn on and
+ * Claude Code started there never loads.
+ *
+ * Installed with no version is named, in the danger colour, because it needs an
+ * action — the scope key reinstalls — and a plain dot would read as healthy.
  */
 function ScopeLine({
 	keyHint,
@@ -647,18 +643,16 @@ function ScopeLine({
 	qualifier: string;
 	scope?: ScopeStatus;
 }): React.ReactNode {
-	const installed = isInstalledInScope(scope);
+	const version = versionInScope(scope);
 	return (
 		<text fg={theme.colors.text}>
 			<ScopeKeyChip scopeKey={keyHint} />
-			<ScopeDot installed={installed} />
+			<ScopeDot installed={isInstalledInScope(scope)} />
 			<span>{name}</span>
 			<span fg={theme.colors.muted}> {qualifier}</span>
-			{scope?.version ? (
-				<span fg={theme.colors.info}> v{scope.version}</span>
-			) : null}
-			{!installed && scope?.enabled ? (
-				<span fg={theme.colors.danger}> enabled, not installed</span>
+			{version ? <span fg={theme.colors.info}> v{version}</span> : null}
+			{scopeFilesMissing(scope) ? (
+				<span fg={theme.colors.danger}> files missing</span>
 			) : null}
 		</text>
 	);

package/src/ui/renderers/pluginRowText.ts

@@ -38,8 +38,12 @@ export function pluginRowText(item: PluginPluginItem): PluginRowText {
 	// A version is shown only when it carries information. "0.0.0" means
 	// installed with an unknown version (Anthropic's official plugins record
 	// exactly that) — it is never printed, and nothing below depends on it.
-	const installed = status?.installed ?? plugin.installedVersion;
-	const shown = isKnownVersion(installed ?? undefined) ? installed : undefined;
+	//
+	// The classifier's version and nothing else. A fallback to
+	// `plugin.installedVersion` printed a version where the classifier had none —
+	// "v0.8.1 files missing", with 0.8.1 read off a scope not installed here.
+	const installed = status?.installed ?? undefined;
+	const shown = isKnownVersion(installed) ? installed : undefined;
 
 	// "What just changed" and "what state it is in now" are independent facts
 	// and both can be true at once: an external update can move a plugin

package/src/ui/renderers/pluginStatusText.ts

@@ -57,13 +57,14 @@ export function pluginStatusText(
 			return { suffix: " BROKEN — press a to fix", tone: "danger" };
 		case "install":
 			// `absent` only ever comes from a profile pin (see `pinForRow`), so it
-			// may say so. An undeclared row that is merely enabled must not.
+			// may say so. An undeclared row whose files are missing must not.
 			return status.reason === "absent"
 				? { suffix: " not installed — profile declares it", tone: "warning" }
-				: // Enabled with nothing on disk is a broken state; a missing
+				: // Files missing is installed, and broken — never "not installed",
+					// which would contradict the filled square beside it. A missing
 					// declared plugin is routine work. Red against amber is the
 					// distinction that matters.
-					{ suffix: ` not installed${withNote}`, tone: "danger" };
+					{ suffix: ` ${status.note ?? "files missing"}`, tone: "danger" };
 		case "current":
 			return { suffix: withNote, tone: "muted" };
 	}