magus-cli 7.4.0 → 7.5.0

package/src/ui/input/KeyRouter.tsx

@@ -1,29 +1,43 @@
 /**
- * The one keyboard subscriber in the React tree.
+ * The one keyboard subscriber in the React tree — and the one paste subscriber.
  *
- * Components do not call `useKeyboard`. They register a LAYER — modal, input,
- * screen, scroll or global — and this router offers each key to the live layers
- * through `dispatchKey`, top first, so exactly one of them acts on it. The
- * system layer (Ctrl+C) is not here: `src/tui.tsx` takes that key on the
- * renderer before this subscriber runs and stops it there.
+ * Components do not call `useKeyboard`, and no screen listens for a paste of
+ * its own. They register a LAYER — modal, input, screen, scroll or global — and
+ * this router offers each key to the live layers through `dispatchKey`, top
+ * first, so exactly one of them acts on it. The system layer (Ctrl+C) is not
+ * here: `src/tui.tsx` takes that key on the renderer before this subscriber
+ * runs and stops it there.
  *
  * Each key is dispatched inside `flushSync`, so everything a key changes is
  * committed — and every layer's `active` flag and handler refreshed — before the
- * next key is looked at. A paste or a fast typist delivers several keys in one
- * stdin read; without this, `/abc` would open the search box and then send `a`,
- * `b` and `c` to the screen underneath, whose handlers still believed the box
- * was closed.
+ * next key is looked at. A fast typist delivers several keys in one stdin read;
+ * without this, `/abc` would open the search box and then send `a`, `b` and `c`
+ * to the screen underneath, whose handlers still believed the box was closed.
+ *
+ * A PASTE is NOT that burst of keys. Bracketed paste is on (OpenTUI's native
+ * core writes `ESC[?2004h`), so the terminal wraps the clipboard in
+ * `ESC[200~ … ESC[201~` and the renderer emits ONE `paste` event carrying the
+ * whole text — and no `keypress` at all. That is why a search term pasted into
+ * a filter box used to vanish without a trace: every layer here listened for
+ * keys that were never sent. `dispatchPaste` runs the same layer order over the
+ * layers that registered a paste handler.
+ *
+ * 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.
  */
 
 import { appendFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import type { KeyEvent } from "@opentui/core";
-import { flushSync, useKeyboard } from "@opentui/react";
+import type { KeyEvent, PasteEvent } from "@opentui/core";
+import { decodePasteBytes, stripAnsiSequences } from "@opentui/core";
+import { flushSync, useKeyboard, useRenderer } from "@opentui/react";
 import {
 	type ReactNode,
 	createContext,
 	useContext,
+	useEffect,
 	useLayoutEffect,
 	useState,
 } from "react";
@@ -37,12 +51,20 @@ import {
 	type KeyLayer,
 	type KeyLayerId,
 	type KeyPress,
+	type PasteLayer,
 	dispatchKey,
+	dispatchPaste,
 	inputLayerConsumes,
 	typedCharacter,
 } from "./key-dispatch.js";
 
-const LayersContext = createContext<Set<KeyLayer> | null>(null);
+/** The two registries the router dispatches over. */
+interface LayerRegistry {
+	keys: Set<KeyLayer>;
+	pastes: Set<PasteLayer>;
+}
+
+const LayersContext = createContext<LayerRegistry | null>(null);
 
 /** OpenTUI's key event, reduced to the fields the dispatcher reads. */
 export function toKeyPress(event: KeyEvent): KeyPress {
@@ -55,35 +77,96 @@ export function toKeyPress(event: KeyEvent): KeyPress {
 	};
 }
 
+/**
+ * The text a paste event carries, as a single-line search term.
+ *
+ * Three things are stripped, in this order. The bytes are decoded as UTF-8
+ * (`decodePasteBytes`). Any ANSI escape the clipboard carried is removed — a
+ * terminal forwards the clipboard verbatim inside the brackets, so copying
+ * coloured output pastes its escape sequences too, and they are not a search
+ * term. Then every remaining control character goes: a newline or a tab becomes
+ * one space, so a multi-line clipboard reads as words rather than running the
+ * lines together, and the rest are dropped outright.
+ *
+ * The ends are trimmed last, because a copied line almost always carries its
+ * trailing newline and a query ending in a space matches nothing.
+ */
+export function pastedText(event: PasteEvent): string {
+	const decoded = stripAnsiSequences(decodePasteBytes(event.bytes));
+	let out = "";
+	for (const ch of decoded) {
+		const cp = ch.codePointAt(0) ?? 0;
+		// Newline, carriage return, tab: one space — and a RUN of them one space
+		// too, so a CRLF clipboard does not double-space every line break.
+		if (cp === 0x0a || cp === 0x0d || cp === 0x09) {
+			if (!out.endsWith(" ")) out += " ";
+			continue;
+		}
+		// The rest of C0 and C1, dropped. Written as codepoint bounds rather
+		// than a regex character class because the formatter rewrites a
+		// `\u0000` escape inside a regex literal into the raw byte it stands
+		// for — which puts literal control characters in this source file.
+		if (cp < 0x20 || (cp >= 0x7f && cp <= 0x9f)) continue;
+		out += ch;
+	}
+	return out.trim();
+}
+
 /**
  * `MAGUS_DEBUG_KEYS=1` appends every key and the layer that took it to
  * `magus-keys.log` in the temp directory — the first thing to look at when a
- * key "does nothing".
+ * key "does nothing". A paste is logged the same way, as `paste`.
  */
-function logKey(key: KeyPress, consumer: KeyLayerId | null): void {
+function logKey(what: string, consumer: KeyLayerId | null): void {
 	if (process.env.MAGUS_DEBUG_KEYS !== "1") return;
 	try {
 		appendFileSync(
 			path.join(os.tmpdir(), "magus-keys.log"),
-			`${new Date().toISOString()} name=${JSON.stringify(key.name)} seq=${JSON.stringify(key.sequence)} ctrl=${key.ctrl} meta=${key.meta} shift=${key.shift} -> ${consumer ?? "nobody"}\n`,
+			`${new Date().toISOString()} ${what} -> ${consumer ?? "nobody"}\n`,
 		);
 	} catch {
 		// Best-effort logging: never let it break a keypress.
 	}
 }
 
+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}`;
+}
+
 export function KeyRouter({ children }: { children: ReactNode }) {
-	const [layers] = useState(() => new Set<KeyLayer>());
+	const [layers] = useState<LayerRegistry>(() => ({
+		keys: new Set<KeyLayer>(),
+		pastes: new Set<PasteLayer>(),
+	}));
+	const renderer = useRenderer();
 
 	useKeyboard((event) => {
 		const key = toKeyPress(event);
 		let consumer: KeyLayerId | null = null;
 		flushSync(() => {
-			consumer = dispatchKey([...layers], key);
+			consumer = dispatchKey([...layers.keys], key);
 		});
-		logKey(key, consumer);
+		logKey(describeKey(key), consumer);
 	});
 
+	// The ONE paste subscriber. `useKeyboard` has no paste counterpart in
+	// @opentui/react, so this listens on the renderer's key input directly —
+	// once, here, rather than once per screen.
+	useEffect(() => {
+		const onPaste = (event: PasteEvent): void => {
+			const text = pastedText(event);
+			let consumer: KeyLayerId | null = null;
+			flushSync(() => {
+				consumer = dispatchPaste([...layers.pastes], text);
+			});
+			logKey(`paste=${JSON.stringify(text)}`, consumer);
+		};
+		renderer.keyInput.on("paste", onPaste);
+		return () => {
+			renderer.keyInput.off("paste", onPaste);
+		};
+	}, [renderer, layers]);
+
 	return (
 		<LayersContext.Provider value={layers}>{children}</LayersContext.Provider>
 	);
@@ -111,9 +194,40 @@ export function useKeyLayer(
 	});
 
 	useLayoutEffect(() => {
-		layers.add(entry);
+		layers.keys.add(entry);
 		return () => {
-			layers.delete(entry);
+			layers.keys.delete(entry);
+		};
+	}, [layers, entry]);
+}
+
+/**
+ * Register a PASTE layer for as long as the calling component is mounted.
+ *
+ * The counterpart of {@link useKeyLayer}, and refreshed on every commit the
+ * same way. A component registers this only when a paste means something to it:
+ * a layer that does not is simply absent from the order, and the paste falls
+ * through it.
+ */
+export function usePasteLayer(
+	id: KeyLayerId,
+	active: boolean,
+	handlePaste: (text: string) => boolean,
+): void {
+	const layers = useContext(LayersContext);
+	if (!layers) throw new Error("usePasteLayer needs a <KeyRouter> above it");
+	const [entry] = useState<PasteLayer>(() => ({ id, active, handlePaste }));
+
+	useLayoutEffect(() => {
+		entry.id = id;
+		entry.active = active;
+		entry.handlePaste = handlePaste;
+	});
+
+	useLayoutEffect(() => {
+		layers.pastes.add(entry);
+		return () => {
+			layers.pastes.delete(entry);
 		};
 	}, [layers, entry]);
 }
@@ -137,8 +251,8 @@ export interface SearchBox {
 	/** The box has focus: what the user types goes into it. */
 	focused: boolean;
 	query: string;
-	/** Add one typed character. */
-	append(char: string): void;
+	/** Add text: one typed character, or a whole pasted term. */
+	append(text: string): void;
 	/** Delete the last character. */
 	erase(): void;
 	/** Empty the box and stay in it. */
@@ -155,8 +269,18 @@ export interface SearchBox {
  * the box) and Esc (clear the text; on an empty box, leave). Up/Down, Tab and the
  * scroll keys pass through: the list still moves, tabs still cycle, the panel
  * still scrolls.
+ *
+ * It is the input layer for a PASTE too, and the only layer that takes one:
+ * pasted text is appended to the query exactly as typing it would be. With no
+ * box focused nothing consumes a paste — it must never reach the screen or the
+ * global keys, where a clipboard holding `q` would quit the app.
  */
 export function useSearchInput(box: SearchBox): void {
+	usePasteLayer("input", box.focused, (text) => {
+		box.append(text);
+		return true;
+	});
+
 	useKeyLayer("input", box.focused, (key) => {
 		if (!inputLayerConsumes(key)) return false;
 		switch (key.name) {

package/src/ui/input/key-dispatch.ts

@@ -24,6 +24,10 @@
  * - scroll: PgUp / PgDn / Ctrl+U / Ctrl+D scroll the detail panel.
  * - global: tab digits, Tab, `q`, `?`, Esc.
  *
+ * A PASTE follows the same order through `dispatchPaste`, over the layers that
+ * registered a paste handler. It is a separate entry point because a paste is a
+ * separate terminal event, not a burst of keys — see {@link PasteLayer}.
+ *
  * Pure: no React, no OpenTUI. `KeyRouter.tsx` feeds it the live layers.
  */
 
@@ -88,6 +92,50 @@ export function dispatchKey(
 	return null;
 }
 
+/**
+ * A layer that can take a PASTE.
+ *
+ * A terminal does not deliver a paste as keys. With bracketed paste on — and
+ * OpenTUI's native core turns it on — the whole clipboard arrives wrapped in
+ * `ESC[200~ … ESC[201~` and reaches the renderer as ONE `paste` event; no
+ * `keypress` is emitted for any of its characters. So a layer that only
+ * implements `handle()` never sees a pasted search term at all.
+ *
+ * Separate from {@link KeyLayer} because most layers have nothing to do with a
+ * paste: a tab digit, `q` or a scroll key is a keystroke, and pasting "q" must
+ * not quit.
+ */
+export interface PasteLayer {
+	id: KeyLayerId;
+	/** An inactive layer is skipped without its handler being called. */
+	active: boolean;
+	/** True when the layer consumed the text; nothing below it will see it. */
+	handlePaste(text: string): boolean;
+}
+
+/**
+ * Offer pasted `text` to the active layers in LAYER_ORDER and stop at the first
+ * that consumes it — the same rule {@link dispatchKey} follows, so a paste
+ * lands where a keystroke would: a focused search box takes it, a modal above
+ * it takes it first, and with neither open nothing consumes it.
+ *
+ * Empty text is offered to nobody: there is nothing to insert, and a layer that
+ * consumed it would only report a phantom edit.
+ */
+export function dispatchPaste(
+	layers: readonly PasteLayer[],
+	text: string,
+): KeyLayerId | null {
+	if (text.length === 0) return null;
+	for (const id of LAYER_ORDER) {
+		for (const layer of layers) {
+			if (layer.id !== id || !layer.active) continue;
+			if (layer.handlePaste(text)) return id;
+		}
+	}
+	return null;
+}
+
 /** PgUp, PgDn, Ctrl+U, Ctrl+D — the keys that scroll the detail panel. */
 export function isScrollKey(key: KeyPress): boolean {
 	if (key.meta) return false;

package/src/ui/keymap.ts

@@ -826,7 +826,14 @@ const LEGENDS: Partial<Record<Screen, readonly LegendEntry[]>> = {
 			symbol: "?",
 			meaning: "installed; magus cannot tell whether it is current",
 		},
-		{ symbol: "!", meaning: "installed more than one way; c fixes it" },
+		{
+			symbol: "!",
+			meaning: "installed more than one way; c removes what it can",
+		},
+		{
+			symbol: "⊘",
+			meaning: "an install magus cannot remove; take it out by hand",
+		},
 	],
 };
 

package/src/ui/renderers/cliToolRenderers.tsx

@@ -3,6 +3,7 @@ import type { CliTool } from "../../data/cli-tools.js";
 import {
 	type InstallMethod,
 	cliToolUninstall,
+	uninstallBlocker,
 } from "../../services/cli-tool-commands.js";
 import { formatCommand } from "../../utils/command-utils.js";
 import {
@@ -47,7 +48,8 @@ function wrapValue(text: string, width: number): string {
 }
 
 /**
- * The uninstall command as a line the reader can copy.
+ * One line of the conflict list: what happens to this install, and the command
+ * that would do it.
  *
  * This used to be a second, hand-written copy of the screen's own uninstall
  * switch — same shape, and already drifted (`pip uninstall` here,
@@ -55,16 +57,26 @@ function wrapValue(text: string, width: number): string {
  * is not an executable. Now the renderer and the screen ask the same function,
  * so what is shown is what would run.
  *
- * Empty string when there is nothing to offer, which is what the caller
- * interpolates into the conflict list.
+ * An install magus cannot remove says so, rather than reading "remove" beside
+ * an empty command: the conflict fix will not offer to remove it either
+ * (R9.10), and a pane that promises what the dialog refuses is the same lie one
+ * step earlier.
  */
-function uninstallHint(
+function removalLine(
 	tool: CliTool,
 	method: InstallMethod,
 	brewFormula?: string,
-): string {
+): { mark: string; hint: string; removable: boolean } {
+	const blocker = uninstallBlocker(tool, method, brewFormula);
+	if (blocker !== null) {
+		return { mark: "  ⊘ stays  ", hint: `  ${blocker}`, removable: false };
+	}
 	const cmd = cliToolUninstall(tool, method, brewFormula);
-	return cmd ? formatCommand(cmd) : "";
+	return {
+		mark: "  ○ remove ",
+		hint: cmd ? `  ${formatCommand(cmd)}` : "",
+		removable: true,
+	};
 }
 
 function toneColor(tone: StatusTone): UiColor {
@@ -324,30 +336,56 @@ export function renderCliToolDetail(
 							{"\n"}Keep one, remove the rest:
 						</text>
 					</box>
-					{allMethods.map((method, i) => (
-						<box key={method}>
-							<text fg={theme.colors.text}>
-								<span fg={i === 0 ? theme.colors.success : theme.colors.danger}>
-									{i === 0 ? "  ● keep  " : "  ○ remove "}
-								</span>
-								<span fg={theme.colors.warning}>{method}</span>
-								{i > 0 ? (
+					{allMethods.map((method, i) => {
+						if (i === 0) {
+							return (
+								<box key={method}>
+									<text fg={theme.colors.text}>
+										<span fg={theme.colors.success}>{"  ● keep  "}</span>
+										<span fg={theme.colors.warning}>{method}</span>
+										<span fg={theme.colors.dim}> (active in PATH)</span>
+									</text>
+								</box>
+							);
+						}
+						const line = removalLine(tool, method, brewFormula);
+						return (
+							<box key={method}>
+								<text fg={theme.colors.text}>
 									<span
-										fg={theme.colors.dim}
-									>{`  ${uninstallHint(tool, method, brewFormula)}`}</span>
-								) : (
-									<span fg={theme.colors.dim}> (active in PATH)</span>
-								)}
+										fg={
+											line.removable ? theme.colors.danger : theme.colors.muted
+										}
+									>
+										{line.mark}
+									</span>
+									<span fg={theme.colors.warning}>{method}</span>
+									<span fg={theme.colors.dim}>{line.hint}</span>
+								</text>
+							</box>
+						);
+					})}
+					{/* `c` is advertised only while it can remove something. With
+					    every install stuck it opens a dialog with no choices in
+					    it, and a key hint for a key that does nothing reads as a
+					    hung app. */}
+					{allMethods.some(
+						(m) => uninstallBlocker(tool, m, brewFormula) === null,
+					) ? (
+						<box flexDirection="row" marginTop={1}>
+							<text bg={theme.colors.danger} fg={theme.hints.fg}>
+								{" "}
+								c{" "}
 							</text>
+							<text fg={theme.colors.muted}> Resolve — pick which to keep</text>
 						</box>
-					))}
-					<box flexDirection="row" marginTop={1}>
-						<text bg={theme.colors.danger} fg={theme.hints.fg}>
-							{" "}
-							c{" "}
-						</text>
-						<text fg={theme.colors.muted}> Resolve — pick which to keep</text>
-					</box>
+					) : (
+						<box marginTop={1}>
+							<text fg={theme.colors.muted}>
+								magus can remove none of these. Take one out by hand, then r.
+							</text>
+						</box>
+					)}
 				</box>
 			) : null}
 

package/src/ui/screens/CliToolsScreen.tsx

@@ -9,7 +9,11 @@ import { useDimensions } from "../state/DimensionsContext.js";
 
 import { cliTools } from "../../data/cli-tools.js";
 import { loadActiveClosure } from "../../services/active-closure.js";
-import { cliToolUninstall } from "../../services/cli-tool-commands.js";
+import {
+	type InstallMethod,
+	cliToolUninstall,
+	uninstallBlocker,
+} from "../../services/cli-tool-commands.js";
 import {
 	type InstallInfo,
 	PROBE_CONCURRENCY,
@@ -247,6 +251,20 @@ export function CliToolsScreen() {
 		}
 	};
 
+	/**
+	 * Keep one install of a tool installed more than one way.
+	 *
+	 * Two rules, both from R9.10. An install magus cannot remove is never
+	 * offered as something to remove: a choice reading "Keep npm, remove others"
+	 * used to include Claude Code's native copy in "others", find no uninstall
+	 * command for it, `continue` past it and report done — leaving the conflict
+	 * exactly as it was, with the row still showing "!". And whatever is left
+	 * behind is named afterwards, rather than silently skipped.
+	 *
+	 * Which installs can be removed comes from `cliToolUninstall` itself
+	 * (through `uninstallBlocker`), so the list of choices and the commands that
+	 * run cannot disagree about a method.
+	 */
 	const handleResolveConflict = async () => {
 		const row = rows[cliToolsState.selectedIndex];
 		const install: InstallInfo | undefined = row?.install;
@@ -254,38 +272,81 @@ export function CliToolsScreen() {
 
 		const { tool } = row;
 		const allMethods = install.all;
+		const blockers = new Map(
+			allMethods.map((m) => [
+				m,
+				uninstallBlocker(tool, m, install.brewFormula),
+			]),
+		);
+		const removable = allMethods.filter((m) => blockers.get(m) === null);
+		const stuck = allMethods.filter((m) => blockers.get(m) !== null);
+		const stuckList = (methods: readonly InstallMethod[]): string =>
+			methods
+				.map((m) => `The ${m} install stays: ${blockers.get(m)}.`)
+				.join("\n");
+
+		// One choice per install that can be KEPT — but only where keeping it
+		// removes something. "Keep npm" beside an unremovable native copy would
+		// promise a removal magus cannot perform.
+		const options = allMethods
+			.map((keep) => ({ keep, remove: removable.filter((m) => m !== keep) }))
+			.filter(({ remove }) => remove.length > 0)
+			.map(({ keep, remove }) => ({
+				label: `Keep ${keep}${keep === install.primary ? " (active)" : ""}, remove ${remove.join(" + ")}`,
+				value: keep,
+			}));
 
-		// Let user pick which install to keep
-		const options = allMethods.map((method) => ({
-			label: `Keep ${method}${method === install.primary ? " (active)" : ""}, remove others`,
-			value: method,
-		}));
+		if (options.length === 0) {
+			await modal.message(
+				`${tool.displayName} conflict`,
+				`Installed via ${allMethods.join(" + ")}, and magus can remove none of them.\n\n${stuckList(allMethods)}\n\nRemove one by hand, then press r.`,
+				"error",
+			);
+			return;
+		}
 
 		const keep = await modal.select(
 			`Resolve ${tool.displayName} conflict`,
-			`Installed via ${allMethods.join(" + ")}. Which to keep?`,
+			stuck.length > 0
+				? `Installed via ${allMethods.join(" + ")}. Which to keep?\n\n${stuckList(stuck)}`
+				: `Installed via ${allMethods.join(" + ")}. Which to keep?`,
 			options,
 		);
 		if (keep === null) return;
 
-		const toRemove = allMethods.filter((m) => m !== keep);
+		const toRemove = removable.filter((m) => m !== keep);
+		const leftBehind = stuck.filter((m) => m !== keep);
 		modal.loading(`Removing ${toRemove.join(", ")} install(s)...`);
 
 		const errors: string[] = [];
 		for (const method of toRemove) {
 			const cmd = cliToolUninstall(tool, method, install.brewFormula);
-			if (!cmd) continue;
+			// Unreachable: `removable` was built from this same call. Reported
+			// rather than skipped, because a silent skip is the defect above.
+			if (!cmd) {
+				errors.push(`${method}: no uninstall command`);
+				continue;
+			}
 			const result = await runCommand(cmd);
 			if (!result.ok) errors.push(`${method}: ${formatCommand(cmd)}`);
 		}
 
 		modal.hideModal();
 
-		if (errors.length > 0) {
+		const report = [
+			errors.length > 0
+				? `These removals failed. Run them by hand:\n${errors.join("\n")}`
+				: "",
+			leftBehind.length > 0
+				? `${stuckList(leftBehind)}\nRemove it by hand if you want it gone.`
+				: "",
+		].filter((part) => part !== "");
+
+		if (report.length > 0) {
 			await modal.message(
-				"Partial",
-				`Some removals failed. Try manually:\n\n${errors.join("\n")}`,
-				"error",
+				errors.length > 0 ? "Partly removed" : "One install stays",
+				report.join("\n\n"),
+				errors.length > 0 ? "error" : "info",
 			);
 		}
 

package/src/ui/screens/PluginsScreen.tsx

@@ -157,8 +157,12 @@ export function PluginsScreen() {
 		try {
 			const localMarketplaces = await getLocalMarketplacesInfo();
 			const allMarketplaces = getAllMarketplaces(localMarketplaces);
-			// Read-only, never throws. `resolveBins: false`: this screen needs only
-			// the plugin pins, not every declared plugin's binary requirements.
+			// Read-only, and it throws for exactly one thing: a settings file or an
+			// installed_plugins.json that exists and cannot be read. That lands in
+			// the catch below and is shown on this screen, which is the point —
+			// "nothing installed" would be a lie about a file nobody could read.
+			// `resolveBins: false`: this screen needs only the plugin pins, not
+			// every declared plugin's binary requirements.
 			const [pluginData, active] = await Promise.all([
 				getAvailablePlugins(state.projectPath),
 				loadActiveClosure(state.projectPath || process.cwd(), {