magus-cli 7.4.0 → 7.4.1

package/src/services/settings-file.ts

@@ -135,16 +135,22 @@ type CheckedMap<V> = unknown extends V
 
 /**
  * {@link writableMap} for a list the caller pushes into or filters —
- * `enabledMcpjsonServers`. Present but not an array throws the same way.
+ * `enabledMcpjsonServers`, a gitignore manifest's `ignore` and `track`. Present
+ * but not an array throws the same way.
  */
 export function writableList<S extends object, K extends keyof S & string>(
 	settings: S,
 	key: K,
 	settingsPath: string,
-): S[K] {
-	return checkedEntry(settings, key, settingsPath, key, "array");
+): CheckedList<S[K]> {
+	return checkedEntry(settings, key, settingsPath, key, "array") as CheckedList<
+		S[K]
+	>;
 }
 
+/** {@link CheckedMap} for a list: an untyped key comes back as the array it is. */
+type CheckedList<V> = unknown extends V ? unknown[] | undefined : V;
+
 function checkedEntry<S extends object, K extends keyof S & string>(
 	settings: S,
 	key: K,

package/src/services/tool-probe.ts

@@ -1439,6 +1439,36 @@ async function isNpmDefaultPrefix(
 	return real !== null && path.resolve(real) === root;
 }
 
+/**
+ * Is `onPath` — the entry PATH actually runs, before any link is followed —
+ * the launcher the native installer maintains beside `dataHome`?
+ *
+ * The launcher lives one level up from the data home, in `bin`:
+ * `~/.local/share` → `~/.local/bin/claude`. The comparison is on the
+ * DIRECTORIES, never on the files: both the launcher and a hand-made link
+ * resolve into `versions/<version>`, which is precisely what has to be told
+ * apart. Their real paths are compared too, so a symlinked `~/.local` still
+ * matches.
+ */
+async function isNativeLauncher(
+	s: ProbeSession,
+	onPath: string,
+	dataHome: string,
+): Promise<boolean> {
+	const launcherDir = path.resolve(dataHome, "..", "bin");
+	const entryDir = path.resolve(path.dirname(onPath));
+	if (launcherDir === entryDir) return true;
+	const [launcherReal, entryReal] = await Promise.all([
+		s.io.realpath(launcherDir),
+		s.io.realpath(entryDir),
+	]);
+	return (
+		launcherReal !== null &&
+		entryReal !== null &&
+		path.resolve(launcherReal) === path.resolve(entryReal)
+	);
+}
+
 /**
  * Claude Code's native installer keeps every release side by side under
  * `<data>/claude/versions/<version>` and points PATH (`~/.local/bin/claude`) at
@@ -1451,12 +1481,23 @@ async function isNpmDefaultPrefix(
  * number. The version is that name; the latest is npm's `latest` dist-tag for
  * Claude Code, the channel the native installer tracks by default.
  *
+ * **Resolving into `versions/` is not enough: the entry PATH runs has to BE the
+ * native launcher.** A hand-made link earlier on PATH — `/usr/local/bin/claude`
+ * pointed at a release directory by hand, a wrapper someone wrote — resolves
+ * into exactly the same place, and planning `claude update` for it would be a
+ * plan that changes nothing: the updater rewrites the launcher, and PATH goes
+ * on running the other file at the old version. Every run would find it behind
+ * and plan the same no-op again. So the check is on `onPath`, the unresolved
+ * entry, and a copy that is not the launcher falls through to the spec's own
+ * installer — which reports it as a second copy it does not own.
+ *
  * True when it recognised the layout; `f` then holds the whole answer.
  */
 async function probeClaudeNative(
 	s: ProbeSession,
 	spec: BinRequirement,
 	f: ToolFacts,
+	onPath: string,
 	resolvedPath: string,
 ): Promise<boolean> {
 	// The cheap, pure shape test first, so no other tool pays for the IO below.
@@ -1471,7 +1512,10 @@ async function probeClaudeNative(
 	let owned = false;
 	for (const home of dataHomes) {
 		const versions = path.resolve(home, "claude", "versions");
-		owned = versions === dir || (await s.io.realpath(versions)) === dir;
+		if (versions !== dir && (await s.io.realpath(versions)) !== dir) continue;
+		// The directory is the installer's. Only the launcher it maintains
+		// there speaks for it.
+		owned = await isNativeLauncher(s, onPath, home);
 		if (owned) break;
 	}
 	if (!owned) return false;
@@ -1561,8 +1605,9 @@ async function probeInto(
 	f.resolvedPath = resolvedPath;
 
 	// A file Claude Code's native installer owns answers for itself, whatever
-	// installer the spec names.
-	if (await probeClaudeNative(s, spec, f, resolvedPath)) return;
+	// installer the spec names. `onPath` as well as `resolvedPath`: ownership
+	// turns on which file PATH runs, not only on where it points.
+	if (await probeClaudeNative(s, spec, f, onPath, resolvedPath)) return;
 
 	const pinned = pinOf(spec) !== undefined;
 	const via: BinInstaller = spec.via;

package/src/ui/components/modals/ModalContainer.tsx

@@ -1,6 +1,6 @@
 import type { ScrollBoxRenderable } from "@opentui/core";
 import React, { useRef, useState } from "react";
-import { useKeyLayer } from "../../input/KeyRouter.js";
+import { useKeyLayer, usePasteLayer } from "../../input/KeyRouter.js";
 import { type KeyPress, isScrollKey } from "../../input/key-dispatch.js";
 import { useApp, useModal } from "../../state/AppContext.js";
 import { useDimensions } from "../../state/DimensionsContext.js";
@@ -23,6 +23,12 @@ const isPlain = (key: KeyPress) => !key.ctrl && !key.meta;
  * Enter that confirms a dialog confirms only the dialog. Ctrl+C still quits: it
  * is taken above every layer, in src/tui.tsx.
  *
+ * It takes every PASTE for the same reason, and does nothing with it: a search
+ * box on the screen behind still has focus, and without this its query would
+ * grow from a paste aimed at the dialog in front of it. The event itself is not
+ * stopped, so the input modal's focused `<input>` still receives it — the
+ * arrangement the `input` case below already relies on for keys.
+ *
  * - confirm: y / Enter confirm; n / Esc / q cancel.
  * - select:  ↑↓ (j/k) move, Enter picks, Esc / q cancel (a no-op for a
  *            question that must be answered).
@@ -79,6 +85,8 @@ export function ModalContainer() {
 		}
 	};
 
+	usePasteLayer("modal", modal !== null, () => true);
+
 	useKeyLayer("modal", modal !== null, (key) => {
 		if (!modal) return false;
 

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}