@sayknow-cli/tui 0.3.16 → 0.4.1

package/src/components/select-list.ts

@@ -20,8 +20,14 @@ export interface SelectItem {
 	value: string;
 	label: string;
 	description?: string;
-	/** Dim hint text shown inline after cursor when this item is selected */
+	/** Autocomplete hint consumed by Editor; SelectList does not render it. */
 	hint?: string;
+	/**
+	 * Renders dimmed and can never be selected: navigation skips it, selection
+	 * callbacks never fire for it, and a list whose visible items are all
+	 * disabled reports no selection (`getSelectedItem()` returns `null`).
+	 */
+	disabled?: boolean;
 }
 
 export interface SelectListTheme {
@@ -49,7 +55,10 @@ export interface SelectListLayoutOptions {
 
 export class SelectList implements Component {
 	#filteredItems: ReadonlyArray<SelectItem>;
+	/** Index of the selected enabled item, or `-1` when no enabled item exists. */
 	#selectedIndex: number = 0;
+	/** First rendered item while selection is absent. */
+	#viewportStartIndex: number = 0;
 
 	onSelect?: (item: SelectItem) => void;
 	onCancel?: () => void;
@@ -62,16 +71,26 @@ export class SelectList implements Component {
 		private readonly layout: SelectListLayoutOptions = {},
 	) {
 		this.#filteredItems = items;
+		this.#selectedIndex = this.#firstEnabledIndex();
+		this.#syncViewportToIndex(Math.max(0, this.#selectedIndex));
 	}
 
 	setFilter(filter: string): void {
 		this.#filteredItems = this.items.filter(item => item.value.toLowerCase().startsWith(filter.toLowerCase()));
-		// Reset selection when filter changes
-		this.#selectedIndex = 0;
+		this.#selectedIndex = this.#firstEnabledIndex();
+		this.#syncViewportToIndex(Math.max(0, this.#selectedIndex));
 	}
 
 	setSelectedIndex(index: number): void {
-		this.#selectedIndex = Math.max(0, Math.min(index, this.#filteredItems.length - 1));
+		if (this.#filteredItems.length === 0) {
+			this.#selectedIndex = -1;
+			this.#viewportStartIndex = 0;
+			return;
+		}
+		const clamped = Math.max(0, Math.min(index, this.#filteredItems.length - 1));
+		this.#selectedIndex =
+			this.#findEnabledIndex(clamped, 1, false) ?? this.#findEnabledIndex(clamped, -1, false) ?? -1;
+		this.#syncViewportToIndex(this.#selectedIndex >= 0 ? this.#selectedIndex : clamped);
 	}
 
 	invalidate(): void {
@@ -89,11 +108,10 @@ export class SelectList implements Component {
 
 		const primaryColumnWidth = this.#getPrimaryColumnWidth();
 
-		// Calculate visible range with scrolling
-		const startIndex = Math.max(
-			0,
-			Math.min(this.#selectedIndex - Math.floor(this.maxVisible / 2), this.#filteredItems.length - this.maxVisible),
-		);
+		// Calculate visible range with scrolling. Selection owns the viewport when
+		// present; otherwise navigation moves an independent viewport anchor.
+		const startIndex =
+			this.#selectedIndex >= 0 ? this.#startIndexForSelection(this.#selectedIndex) : this.#clampedViewportStart();
 		const endIndex = Math.min(startIndex + this.maxVisible, this.#filteredItems.length);
 
 		// Render visible items
@@ -101,14 +119,16 @@ export class SelectList implements Component {
 			const item = this.#filteredItems[i];
 			if (!item) continue;
 
-			const isSelected = i === this.#selectedIndex;
+			const isSelected = i === this.#selectedIndex && !item.disabled;
 			const descriptionText = item.description ? sanitizeSingleLine(item.description) : undefined;
 			lines.push(this.#renderItem(item, isSelected, width, descriptionText, primaryColumnWidth));
 		}
 
-		// Add scroll indicators if needed
+		// Add scroll indicators if needed. With no selectable item the position
+		// is reported as "-" so an all-disabled list never claims a selection.
 		if (startIndex > 0 || endIndex < this.#filteredItems.length) {
-			const scrollText = `  (${this.#selectedIndex + 1}/${this.#filteredItems.length})`;
+			const position = this.#selectedIndex >= 0 ? `${this.#selectedIndex + 1}` : "-";
+			const scrollText = `  (${position}/${this.#filteredItems.length})`;
 			// Truncate if too long for terminal
 			lines.push(this.theme.scrollInfo(truncateToWidth(scrollText, width - 2, Ellipsis.Omit)));
 		}
@@ -126,30 +146,19 @@ export class SelectList implements Component {
 			}
 			return;
 		}
-		// Up arrow - wrap to bottom when at top
 		if (kb.matches(keyData, "tui.select.up")) {
-			this.#selectedIndex = this.#selectedIndex === 0 ? this.#filteredItems.length - 1 : this.#selectedIndex - 1;
-			this.#notifySelectionChange();
-		}
-		// Down arrow - wrap to top when at bottom
-		else if (kb.matches(keyData, "tui.select.down")) {
-			this.#selectedIndex = this.#selectedIndex === this.#filteredItems.length - 1 ? 0 : this.#selectedIndex + 1;
-			this.#notifySelectionChange();
-		}
-		// PageUp - jump up by one visible page
-		else if (kb.matches(keyData, "tui.select.pageUp")) {
-			this.#selectedIndex = Math.max(0, this.#selectedIndex - this.maxVisible);
-			this.#notifySelectionChange();
-		}
-		// PageDown - jump down by one visible page
-		else if (kb.matches(keyData, "tui.select.pageDown")) {
-			this.#selectedIndex = Math.min(this.#filteredItems.length - 1, this.#selectedIndex + this.maxVisible);
-			this.#notifySelectionChange();
+			this.#moveSelection(-1);
+		} else if (kb.matches(keyData, "tui.select.down")) {
+			this.#moveSelection(1);
+		} else if (kb.matches(keyData, "tui.select.pageUp")) {
+			this.#movePage(-1);
+		} else if (kb.matches(keyData, "tui.select.pageDown")) {
+			this.#movePage(1);
 		}
 		// Enter
 		else if (kb.matches(keyData, "tui.select.confirm") || keyData === "\n") {
 			const selectedItem = this.#filteredItems[this.#selectedIndex];
-			if (selectedItem && this.onSelect) {
+			if (selectedItem && !selectedItem.disabled && this.onSelect) {
 				this.onSelect(selectedItem);
 			}
 		}
@@ -184,6 +193,9 @@ export class SelectList implements Component {
 
 			if (remainingWidth > MIN_DESCRIPTION_WIDTH) {
 				const truncatedDesc = truncateToWidth(descriptionSingleLine, remainingWidth, Ellipsis.Omit);
+				if (item.disabled) {
+					return this.theme.description(`${prefix}${truncatedValue}${spacing}${truncatedDesc}`);
+				}
 				if (isSelected) {
 					return this.theme.selectedText(`${prefix}${truncatedValue}${spacing}${truncatedDesc}`);
 				}
@@ -195,6 +207,9 @@ export class SelectList implements Component {
 
 		const maxWidth = width - prefixWidth - 2;
 		const truncatedValue = this.#truncatePrimary(item, isSelected, maxWidth, maxWidth);
+		if (item.disabled) {
+			return this.theme.description(`${prefix}${truncatedValue}`);
+		}
 		if (isSelected) {
 			return this.theme.selectedText(`${prefix}${truncatedValue}`);
 		}
@@ -242,15 +257,105 @@ export class SelectList implements Component {
 		return sanitizeSingleLine(item.label || item.value);
 	}
 
+	/** First enabled index, or `-1` when every filtered item is disabled. */
+	#firstEnabledIndex(): number {
+		return this.#filteredItems.findIndex(item => !item.disabled);
+	}
+
+	#findEnabledIndex(start: number, direction: 1 | -1, wrap: boolean): number | undefined {
+		for (let step = 0; step < this.#filteredItems.length; step++) {
+			let index = start + step * direction;
+			if (index < 0 || index >= this.#filteredItems.length) {
+				if (!wrap) return undefined;
+				index = (index + this.#filteredItems.length) % this.#filteredItems.length;
+			}
+			if (!this.#filteredItems[index]?.disabled) return index;
+		}
+		return undefined;
+	}
+
+	#moveSelection(direction: 1 | -1): void {
+		if (this.#filteredItems.length === 0) return;
+		if (this.#selectedIndex < 0 && this.#firstEnabledIndex() < 0) {
+			this.#moveViewport(direction, true);
+			return;
+		}
+		const start =
+			this.#selectedIndex < 0
+				? direction === 1
+					? 0
+					: this.#filteredItems.length - 1
+				: (this.#selectedIndex + direction + this.#filteredItems.length) % this.#filteredItems.length;
+		const next = this.#findEnabledIndex(start, direction, true);
+		if (next === undefined) return;
+		if (next === this.#selectedIndex) {
+			// Preserve the legacy enabled-only callback contract while suppressing
+			// no-op previews when disabled entries collapse navigation to one item.
+			if (this.#allItemsEnabled()) this.#notifySelectionChange();
+			return;
+		}
+		this.#selectedIndex = next;
+		this.#syncViewportToIndex(next);
+		this.#notifySelectionChange();
+	}
+
+	#movePage(direction: 1 | -1): void {
+		if (this.#filteredItems.length === 0) return;
+		if (this.#selectedIndex < 0 && this.#firstEnabledIndex() < 0) {
+			this.#moveViewport(direction * this.maxVisible, false);
+			return;
+		}
+		const from = this.#selectedIndex < 0 ? (direction === 1 ? -1 : this.#filteredItems.length) : this.#selectedIndex;
+		const target = Math.max(0, Math.min(this.#filteredItems.length - 1, from + direction * this.maxVisible));
+		const next =
+			this.#findEnabledIndex(target, direction, false) ??
+			this.#findEnabledIndex(target, direction === 1 ? -1 : 1, false);
+		if (next === undefined) return;
+		if (next === this.#selectedIndex) {
+			if (this.#allItemsEnabled()) this.#notifySelectionChange();
+			return;
+		}
+		this.#selectedIndex = next;
+		this.#syncViewportToIndex(next);
+		this.#notifySelectionChange();
+	}
+
+	#allItemsEnabled(): boolean {
+		return this.#filteredItems.every(item => !item.disabled);
+	}
+
+	#maxViewportStart(): number {
+		return Math.max(0, this.#filteredItems.length - this.maxVisible);
+	}
+
+	#clampedViewportStart(): number {
+		return Math.max(0, Math.min(this.#viewportStartIndex, this.#maxViewportStart()));
+	}
+
+	#startIndexForSelection(index: number): number {
+		return Math.max(0, Math.min(index - Math.floor(this.maxVisible / 2), this.#maxViewportStart()));
+	}
+
+	#syncViewportToIndex(index: number): void {
+		this.#viewportStartIndex = this.#startIndexForSelection(index);
+	}
+
+	#moveViewport(delta: number, wrap: boolean): void {
+		const maxStart = this.#maxViewportStart();
+		if (maxStart === 0) return;
+		const next = this.#viewportStartIndex + delta;
+		this.#viewportStartIndex = wrap ? (next + maxStart + 1) % (maxStart + 1) : Math.max(0, Math.min(next, maxStart));
+	}
+
 	#notifySelectionChange(): void {
 		const selectedItem = this.#filteredItems[this.#selectedIndex];
-		if (selectedItem && this.onSelectionChange) {
+		if (selectedItem && !selectedItem.disabled && this.onSelectionChange) {
 			this.onSelectionChange(selectedItem);
 		}
 	}
 
 	getSelectedItem(): SelectItem | null {
 		const item = this.#filteredItems[this.#selectedIndex];
-		return item || null;
+		return item && !item.disabled ? item : null;
 	}
 }

package/src/index.ts

@@ -12,6 +12,7 @@ export * from "./components/input";
 export * from "./components/loader";
 export * from "./components/markdown";
 export * from "./components/sayknow-pet";
+export * from "./components/secret-input";
 export * from "./components/select-list";
 export * from "./components/settings-list";
 export * from "./components/spacer";

package/src/keybindings.ts

@@ -187,6 +187,14 @@ function normalizeKeys(keys: KeyId | KeyId[] | undefined): KeyId[] {
 	return result;
 }
 
+function cloneKeybindingsConfig(config: KeybindingsConfig): KeybindingsConfig {
+	const clone: KeybindingsConfig = {};
+	for (const [keybinding, keys] of Object.entries(config)) {
+		clone[keybinding] = Array.isArray(keys) ? [...keys] : keys;
+	}
+	return clone;
+}
+
 export class KeybindingsManager {
 	#definitions: KeybindingDefinitions;
 	#userBindings: KeybindingsConfig;
@@ -195,7 +203,7 @@ export class KeybindingsManager {
 
 	constructor(definitions: KeybindingDefinitions, userBindings: KeybindingsConfig = {}) {
 		this.#definitions = definitions;
-		this.#userBindings = userBindings;
+		this.#userBindings = cloneKeybindingsConfig(userBindings);
 		this.#rebuild();
 	}
 
@@ -253,12 +261,12 @@ export class KeybindingsManager {
 	}
 
 	setUserBindings(userBindings: KeybindingsConfig): void {
-		this.#userBindings = userBindings;
+		this.#userBindings = cloneKeybindingsConfig(userBindings);
 		this.#rebuild();
 	}
 
 	getUserBindings(): KeybindingsConfig {
-		return { ...this.#userBindings };
+		return cloneKeybindingsConfig(this.#userBindings);
 	}
 
 	getResolvedBindings(): KeybindingsConfig {

package/src/stdin-buffer.ts

@@ -23,6 +23,31 @@ import { EventEmitter } from "events";
 const ESC = "\x1b";
 const BRACKETED_PASTE_START = "\x1b[200~";
 const BRACKETED_PASTE_END = "\x1b[201~";
+const SGR_QUARANTINE_MAX_BYTES = 256;
+const SGR_QUARANTINE_TIMEOUT_MS = 100;
+
+/** True for complete SGR mouse CSI reports. These remain control input, never text. */
+export function isSgrMouseSequence(sequence: string): boolean {
+	return /^\x1b\[<\d+;\d+;\d+[Mm]$/.test(sequence);
+}
+
+/** True when a buffered sequence begins an SGR mouse report, valid or not. */
+function isSgrMousePrefix(sequence: string): boolean {
+	return sequence.startsWith(`${ESC}[<`);
+}
+function isHighSurrogate(codeUnit: number): boolean {
+	return codeUnit >= 0xd800 && codeUnit <= 0xdbff;
+}
+
+function isLowSurrogate(codeUnit: number): boolean {
+	return codeUnit >= 0xdc00 && codeUnit <= 0xdfff;
+}
+
+function singleCodePoint(sequence: string): number | undefined {
+	const codepoint = sequence.codePointAt(0);
+	if (codepoint === undefined) return undefined;
+	return sequence.length === (codepoint > 0xffff ? 2 : 1) ? codepoint : undefined;
+}
 
 function isUtf8LeadByte(byte: number): boolean {
 	return byte >= 0xc2 && byte <= 0xf4;
@@ -102,9 +127,9 @@ function isCompleteSequence(data: string): "complete" | "incomplete" | "not-esca
 		return afterEsc.length >= 2 ? "complete" : "incomplete";
 	}
 
-	// Meta key sequences: ESC followed by a single character
+	// Meta key sequences: ESC followed by a single Unicode code point
 	if (afterEsc.length === 1) {
-		return "complete";
+		return isHighSurrogate(afterEsc.charCodeAt(0)) ? "incomplete" : "complete";
 	}
 
 	// Unknown escape sequence - treat as complete
@@ -137,19 +162,9 @@ function isCompleteCsiSequence(data: string): "complete" | "incomplete" {
 		// Format: ESC[<B;X;Ym or ESC[<B;X;YM
 		if (payload.startsWith("<")) {
 			// Must have format: <digits;digits;digits[Mm]
-			const mouseMatch = /^<\d+;\d+;\d+[Mm]$/.test(payload);
-			if (mouseMatch) {
-				return "complete";
-			}
-			// If it ends with M or m but doesn't match the pattern, still incomplete
-			if (lastChar === "M" || lastChar === "m") {
-				// Check if we have the right structure
-				const parts = payload.slice(1, -1).split(";");
-				if (parts.length === 3 && parts.every(p => /^\d+$/.test(p))) {
-					return "complete";
-				}
-			}
-
+			// SGR-looking reports remain terminal control input even when malformed.
+			// Treat their final byte as complete so trailing user input is preserved.
+			if (lastChar === "M" || lastChar === "m") return "complete";
 			return "incomplete";
 		}
 
@@ -232,6 +247,18 @@ function extractCompleteSequences(buffer: string): { sequences: string[]; remain
 
 		// Try to extract a sequence starting at this position
 		if (remaining.startsWith(ESC)) {
+			// A split Meta + supplementary code point stays buffered after its high
+			// surrogate. If the next code unit cannot complete that pair, flush the
+			// malformed Meta sequence without consuming the following input.
+			if (
+				remaining.length >= 3 &&
+				isHighSurrogate(remaining.charCodeAt(1)) &&
+				!isLowSurrogate(remaining.charCodeAt(2))
+			) {
+				sequences.push(remaining.slice(0, 2));
+				pos += 2;
+				continue;
+			}
 			// Find the end of this escape sequence
 			let seqEnd = 1;
 			while (seqEnd <= remaining.length) {
@@ -256,7 +283,19 @@ function extractCompleteSequences(buffer: string): { sequences: string[]; remain
 				return { sequences, remainder: remaining };
 			}
 		} else {
-			// Not an escape sequence - take a single character
+			// Not an escape sequence - take a single Unicode code point. Keep a
+			// trailing high surrogate buffered so a following string chunk can
+			// complete it.
+			const firstCodeUnit = remaining.charCodeAt(0);
+			if (isHighSurrogate(firstCodeUnit)) {
+				if (remaining.length === 1) return { sequences, remainder: remaining };
+				const secondCodeUnit = remaining.charCodeAt(1);
+				if (isLowSurrogate(secondCodeUnit)) {
+					sequences.push(remaining.slice(0, 2));
+					pos += 2;
+					continue;
+				}
+			}
 			sequences.push(remaining[0]!);
 			pos++;
 		}
@@ -303,6 +342,10 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 	#decoder = new StringDecoder("utf8");
 	#decoderHasPendingUtf8 = false;
 	#pendingSingleUtf8LeadByte: number | undefined;
+	#sgrQuarantine = false;
+	#sgrQuarantineBytes = 0;
+	#sgrQuarantineSemicolons = 0;
+	#sgrQuarantineHasDigit = false;
 
 	constructor(options: StdinBufferOptions = {}) {
 		super();
@@ -310,8 +353,8 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 	}
 
 	process(data: string | Buffer): void {
-		// Clear any pending timeout
-		if (this.#timeout) {
+		// Do not cancel a bounded SGR quarantine while waiting for its final byte.
+		if (this.#timeout && !this.#sgrQuarantine) {
 			clearTimeout(this.#timeout);
 			this.#timeout = undefined;
 		}
@@ -380,6 +423,11 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 			return;
 		}
 
+		if (this.#sgrQuarantine) {
+			str = this.#consumeSgrQuarantine(str);
+			if (str.length === 0) return;
+		}
+
 		this.#buffer += str;
 
 		if (this.#pasteMode) {
@@ -445,13 +493,17 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 		this.#buffer = result.remainder;
 
 		for (const sequence of result.sequences) {
+			if (isSgrMousePrefix(sequence) && !isSgrMouseSequence(sequence)) continue;
 			this.#emitDataSequence(sequence);
 		}
 
 		if (this.#buffer.length > 0) {
 			this.#timeout = setTimeout(() => {
+				if (isSgrMousePrefix(this.#buffer)) {
+					this.#beginSgrQuarantine();
+					return;
+				}
 				const flushed = this.flush();
-
 				for (const sequence of flushed) {
 					this.#emitDataSequence(sequence);
 				}
@@ -459,6 +511,76 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 		}
 	}
 
+	#beginSgrQuarantine(): void {
+		const suffix = this.#buffer.slice(3);
+		let semicolons = 0;
+		let hasDigit = false;
+		for (let index = 0; index < suffix.length; index += 1) {
+			const char = suffix[index]!;
+			if (/\d/u.test(char)) {
+				hasDigit = true;
+				continue;
+			}
+			if (char === ";" && hasDigit && semicolons < 2) {
+				semicolons += 1;
+				hasDigit = false;
+				continue;
+			}
+			const remainder = suffix.slice(index);
+			this.#buffer = "";
+			this.#pendingKittyPrintableCodepoint = undefined;
+			if (remainder) this.process(remainder);
+			return;
+		}
+		this.#buffer = "";
+		this.#pendingKittyPrintableCodepoint = undefined;
+		this.#sgrQuarantine = true;
+		this.#sgrQuarantineBytes = suffix.length;
+		this.#sgrQuarantineSemicolons = semicolons;
+		this.#sgrQuarantineHasDigit = hasDigit;
+		this.#timeout = setTimeout(() => this.#endSgrQuarantine(), SGR_QUARANTINE_TIMEOUT_MS);
+	}
+
+	#endSgrQuarantine(): void {
+		if (this.#timeout) clearTimeout(this.#timeout);
+		this.#timeout = undefined;
+		this.#sgrQuarantine = false;
+		this.#sgrQuarantineBytes = 0;
+		this.#sgrQuarantineSemicolons = 0;
+		this.#sgrQuarantineHasDigit = false;
+	}
+
+	#consumeSgrQuarantine(data: string): string {
+		for (let index = 0; index < data.length; index += 1) {
+			const char = data[index]!;
+			if (this.#sgrQuarantineBytes >= SGR_QUARANTINE_MAX_BYTES) {
+				let resume = index;
+				while (resume < data.length && /[\d;]/u.test(data[resume]!)) resume += 1;
+				if (resume < data.length && /[Mm]/u.test(data[resume]!)) resume += 1;
+				this.#endSgrQuarantine();
+				return data.slice(resume);
+			}
+			if (/\d/u.test(char)) {
+				this.#sgrQuarantineHasDigit = true;
+				this.#sgrQuarantineBytes += 1;
+				continue;
+			}
+			if (char === ";" && this.#sgrQuarantineHasDigit && this.#sgrQuarantineSemicolons < 2) {
+				this.#sgrQuarantineSemicolons += 1;
+				this.#sgrQuarantineHasDigit = false;
+				this.#sgrQuarantineBytes += 1;
+				continue;
+			}
+			if ((char === "M" || char === "m") && this.#sgrQuarantineSemicolons === 2 && this.#sgrQuarantineHasDigit) {
+				this.#endSgrQuarantine();
+				return data.slice(index + 1);
+			}
+			this.#endSgrQuarantine();
+			return data.slice(index);
+		}
+		return "";
+	}
+
 	#consumePendingSingleUtf8LeadAsMeta(): string | undefined {
 		const byte = this.#pendingSingleUtf8LeadByte;
 		if (byte === undefined) return undefined;
@@ -467,7 +589,7 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 		return legacyMetaSequence(byte);
 	}
 	#emitDataSequence(sequence: string): void {
-		const rawCodepoint = sequence.length === 1 ? sequence.codePointAt(0) : undefined;
+		const rawCodepoint = singleCodePoint(sequence);
 		if (rawCodepoint !== undefined && rawCodepoint === this.#pendingKittyPrintableCodepoint) {
 			this.#pendingKittyPrintableCodepoint = undefined;
 			return;
@@ -482,6 +604,7 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 			clearTimeout(this.#timeout);
 			this.#timeout = undefined;
 		}
+		if (this.#sgrQuarantine) this.#endSgrQuarantine();
 
 		const pendingMeta = this.#consumePendingSingleUtf8LeadAsMeta();
 
@@ -489,6 +612,12 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 			return pendingMeta === undefined ? [] : [pendingMeta];
 		}
 
+		if (isSgrMousePrefix(this.#buffer)) {
+			this.#buffer = "";
+			this.#pendingKittyPrintableCodepoint = undefined;
+			return pendingMeta === undefined ? [] : [pendingMeta];
+		}
+
 		const sequences = pendingMeta === undefined ? [this.#buffer] : [pendingMeta, this.#buffer];
 		this.#buffer = "";
 		this.#pendingKittyPrintableCodepoint = undefined;
@@ -504,6 +633,10 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 		this.#pasteMode = false;
 		this.#pasteBuffer = "";
 		this.#pendingKittyPrintableCodepoint = undefined;
+		this.#sgrQuarantine = false;
+		this.#sgrQuarantineBytes = 0;
+		this.#sgrQuarantineSemicolons = 0;
+		this.#sgrQuarantineHasDigit = false;
 		// Drop any incomplete multi-byte sequence the decoder is holding so a
 		// stale partial prefix cannot combine with future input. destroy()
 		// resets the decoder by calling clear().

package/src/terminal.ts

@@ -3,6 +3,7 @@ import * as fs from "node:fs";
 import { $env, $flag } from "@sayknow-cli/utils";
 import { setKittyProtocolActive } from "./keys";
 import { StdinBuffer } from "./stdin-buffer";
+import { isUnderTerminalMultiplexer } from "./terminal-capabilities";
 
 const TERMINAL_PROGRESS_KEEPALIVE_MS = 1000;
 const TERMINAL_PROGRESS_ACTIVE_SEQUENCE = "\x1b]9;4;3\x07";
@@ -113,6 +114,9 @@ export interface Terminal {
 
 	// Stop the terminal and restore state
 	stop(): void;
+	// Enable or disable opt-in SGR mouse reporting. Implementations that do not
+	// own a real terminal may ignore this.
+	setMouseEnabled?(enabled: boolean): void;
 
 	/**
 	 * Drain stdin before exiting to prevent Kitty key release events from
@@ -211,6 +215,26 @@ function isWindowsSubsystemForLinux(): boolean {
 	return process.platform === "linux" && (!!$env.WSL_DISTRO_NAME || !!$env.WSL_INTEROP);
 }
 const STDOUT_ERROR_HANDLER_GRACE_MS = 250;
+const stdoutErrorSubscribers = new Set<(err: Error) => void>();
+export function __stdoutErrorSubscriberCountForTests(): number {
+	return stdoutErrorSubscribers.size;
+}
+export function __stdoutErrorDispatcherInstalledForTests(): boolean {
+	return process.stdout.listeners("error").includes(dispatchStdoutError);
+}
+const dispatchStdoutError = (err: Error): void => {
+	for (const subscriber of stdoutErrorSubscribers) subscriber(err);
+};
+
+function subscribeToStdoutErrors(subscriber: (err: Error) => void): void {
+	if (stdoutErrorSubscribers.size === 0) process.stdout.on("error", dispatchStdoutError);
+	stdoutErrorSubscribers.add(subscriber);
+}
+
+function unsubscribeFromStdoutErrors(subscriber: (err: Error) => void): void {
+	stdoutErrorSubscribers.delete(subscriber);
+	if (stdoutErrorSubscribers.size === 0) process.stdout.removeListener("error", dispatchStdoutError);
+}
 
 /**
  * Real terminal using process.stdin/stdout
@@ -240,6 +264,8 @@ export class ProcessTerminal implements Terminal {
 	#osc11PollTimer?: Timer;
 	#mode2031DebounceTimer?: Timer;
 	#progressTimer?: ReturnType<typeof setInterval>;
+	#mouseEnabled = false;
+	#started = false;
 
 	get isProcessTerminal(): boolean {
 		return true;
@@ -257,9 +283,15 @@ export class ProcessTerminal implements Terminal {
 		this.#appearanceCallbacks.push(callback);
 	}
 
+	setMouseEnabled(enabled: boolean): void {
+		this.#mouseEnabled = enabled && !isUnderTerminalMultiplexer(Bun.env);
+		if (this.#started) this.#safeWrite(this.#mouseEnabled ? "\x1b[?1000h\x1b[?1006h" : "\x1b[?1000l\x1b[?1006l");
+	}
+
 	start(onInput: (data: string) => void, onResize: () => void): void {
 		this.#inputHandler = onInput;
 		this.#resizeHandler = onResize;
+		this.#started = true;
 
 		// Register for emergency cleanup
 		activeTerminal = this;
@@ -283,6 +315,8 @@ export class ProcessTerminal implements Terminal {
 
 		// Enable bracketed paste mode - terminal will wrap pastes in \x1b[200~ ... \x1b[201~
 		this.#safeWrite("\x1b[?2004h");
+		// SGR mouse reporting is opt-in and never enabled inside tmux or screen.
+		if (this.#mouseEnabled) this.#safeWrite("\x1b[?1000h\x1b[?1006h");
 
 		// Set up resize handler immediately
 		process.stdout.on("resize", this.#resizeHandler);
@@ -294,7 +328,7 @@ export class ProcessTerminal implements Terminal {
 			this.#stdoutErrorHandler = (err: Error) => {
 				this.#markUnavailable(err, "stdout-error");
 			};
-			process.stdout.on("error", this.#stdoutErrorHandler);
+			subscribeToStdoutErrors(this.#stdoutErrorHandler);
 		}
 
 		// Refresh terminal dimensions - they may be stale after suspend/resume
@@ -714,6 +748,8 @@ export class ProcessTerminal implements Terminal {
 		}
 
 		// Disable bracketed paste mode
+		this.#started = false;
+		this.#mouseEnabled = false;
 		this.#safeWrite("\x1b[?2004l");
 		this.#safeWrite("\x1b[?1000l");
 		this.#safeWrite("\x1b[?1006l");
@@ -787,7 +823,7 @@ export class ProcessTerminal implements Terminal {
 		// of surfacing as uncaught exceptions that kill the tmux pane.
 		this.#stdoutErrorHandlerCleanupTimer = setTimeout(() => {
 			if (this.#stdoutErrorHandler) {
-				process.stdout.removeListener("error", this.#stdoutErrorHandler);
+				unsubscribeFromStdoutErrors(this.#stdoutErrorHandler);
 				this.#stdoutErrorHandler = undefined;
 			}
 			this.#stdoutErrorHandlerCleanupTimer = undefined;