magus-cli 7.5.4 → 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,
@@ -32,6 +32,7 @@ import {
 	formatUpdateOutcome,
 	parseProfileChoice,
 	prepareProfileStartup,
+	profileIdForName,
 	unparseableNeed,
 } from "../../services/profile-startup.js";
 import { applyProfileChoice } from "../../services/profile-state.js";
@@ -166,17 +167,67 @@ 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) => {
+			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,
@@ -187,13 +238,14 @@ export function useProfileStartupModal(
 				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}…`,
 					},
 				});
@@ -212,6 +264,10 @@ export function useProfileStartupModal(
 					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({
@@ -246,6 +302,9 @@ export function useProfileStartupModal(
 							error.path === getManifestPath(projectPath)
 								? unparseableNeed(error)
 								: current;
+						// Still unanswered, and `next` is what a lost error modal
+						// returns to.
+						flowRef.current = { need: next, working: false };
 						dispatch({
 							type: "SHOW_MODAL",
 							modal: {
@@ -277,6 +336,7 @@ export function useProfileStartupModal(
 			 * say it is done.
 			 */
 			const updateFormat = (): void => {
+				flowRef.current = { need, working: true };
 				dispatch({
 					type: "SHOW_MODAL",
 					modal: { type: "loading", message: "Updating the profile format…" },
@@ -285,6 +345,8 @@ export function useProfileStartupModal(
 					.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;
@@ -292,6 +354,7 @@ export function useProfileStartupModal(
 						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: {
@@ -304,6 +367,8 @@ export function useProfileStartupModal(
 							});
 							return;
 						}
+						// Nothing left to ask: the converted profile is active.
+						answered();
 						onActivated?.();
 						dispatch({
 							type: "SHOW_MODAL",
@@ -320,6 +385,7 @@ export function useProfileStartupModal(
 						});
 					})
 					.catch((error: unknown) => {
+						flowRef.current = { need, working: false };
 						dispatch({
 							type: "SHOW_MODAL",
 							modal: {
@@ -333,18 +399,71 @@ export function useProfileStartupModal(
 					});
 			};
 
+			/**
+			 * "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, current),
+						onChoose: (choice) =>
+							choice.kind === "adopt"
+								? askName(choice.id, current)
+								: apply(choice, false, current),
 						onUpdateFormat: updateFormat,
-						onQuit,
+						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
@@ -355,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);