@gajae-code/tui 0.12.8 → 0.12.10

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## [0.12.10] - 2026-08-03
+
+## [0.12.9] - 2026-08-03
+### Fixed
+
+- Corrected the off-screen transcript duplication fix released in 0.12.8, which could still render a Bash tool block twice and could stop appended rows reaching native scrollback. It keyed on whether the last committed row's bytes changed, which is neither necessary nor sufficient: a substituted status line changes that row without anything moving, and repeated or blank rows at the frontier hide a real insertion. The suffix commit now repaints the live viewport instead when two things hold together: the previously visible rows reappear almost intact at some uniform offset below their old index, and the rows that offset pulls into the top of the visible region are exactly the last rows already committed to scrollback — which is the damage itself, since those are the rows about to be emitted twice. Requiring both keeps an ordinary append committing even when repeated or blank rows make it look displaced. Rendered rows carry no identity, so no test on their bytes can prove which logical row moved; this is a policy for which failure to prefer when a frame is ambiguous, chosen to be never worse than the previous behavior and strictly better on every duplication case found.
+
+### Fixed
+
+- `Ctrl+J` now inserts a newline when multiplexers such as Herdr forward it through Kitty CSI-u or xterm `modifyOtherKeys`, matching the existing legacy line-feed behavior and displayed shortcut.
+- A terminal that disappears under a running session (tmux pane killed, SSH connection dropped, terminal window closed) no longer kills the agent process. The in-flight `stdin` read fails with `EIO`, and `process.stdin` had no `error` listener, so the event was rethrown as an uncaught exception; an `EIO` on `stdin` now retires the terminal the same way `stdout` errors already did. Only `EIO` is treated as a detach — any other `stdin` error (`EBADF`, `EPIPE`, an unexpected platform failure) keeps its default `EventEmitter` propagation and leaves the terminal usable, so the new listener cannot silently swallow unrelated stream failures.
+
 ## [0.12.8] - 2026-08-02
 ### Fixed
 

package/dist/types/terminal.d.ts

@@ -77,6 +77,8 @@ export declare function resolveTerminalColumns(stream?: TerminalSizeStream, envC
 export declare function resolveTerminalRows(stream?: TerminalSizeStream, envRows?: string | undefined): number;
 export declare function __stdoutErrorSubscriberCountForTests(): number;
 export declare function __stdoutErrorDispatcherInstalledForTests(): boolean;
+export declare function __stdinErrorSubscriberCountForTests(): number;
+export declare function __stdinErrorDispatcherInstalledForTests(): boolean;
 /**
  * Real terminal using process.stdin/stdout
  */

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/tui",
-	"version": "0.12.8",
+	"version": "0.12.10",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"homepage": "https://gajae-code.com",
 	"author": "Yeachan-Heo and Gajae Code Contributors",
@@ -36,8 +36,8 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@gajae-code/natives": "0.12.8",
-		"@gajae-code/utils": "0.12.8",
+		"@gajae-code/natives": "0.12.10",
+		"@gajae-code/utils": "0.12.10",
 		"lru-cache": "11.3.6",
 		"marked": "18.0.6"
 	},

package/src/components/editor.ts

@@ -1366,6 +1366,7 @@ export class Editor implements Component, Focusable {
 		}
 		// New line
 		else if (
+			matchesKey(data, "ctrl+j") || // Ctrl+J (Kitty/modifyOtherKeys)
 			(data.charCodeAt(0) === 10 && data.length > 1) || // Ctrl+Enter with modifiers
 			matchesKey(data, "ctrl+enter") || // Ctrl+Enter (Kitty/modifyOtherKeys, including lock bits/keypad Enter)
 			matchesKey(data, "ctrl+shift+enter") || // Ctrl+Shift+Enter (Kitty/modifyOtherKeys combined modifier)

package/src/terminal.ts

@@ -224,6 +224,46 @@ function unsubscribeFromStdoutErrors(subscriber: (err: Error) => void): void {
 	if (stdoutErrorSubscribers.size === 0) process.stdout.removeListener("error", dispatchStdoutError);
 }
 
+const STDIN_ERROR_HANDLER_GRACE_MS = 250;
+const stdinErrorSubscribers = new Set<(err: Error) => void>();
+export function __stdinErrorSubscriberCountForTests(): number {
+	return stdinErrorSubscribers.size;
+}
+export function __stdinErrorDispatcherInstalledForTests(): boolean {
+	return process.stdin.listeners("error").includes(dispatchStdinError);
+}
+/**
+ * A vanished controlling terminal fails the in-flight stdin read with EIO.
+ * That is the only stdin error this module owns; every other failure
+ * (EBADF, EPIPE, an unexpected platform error) keeps its default
+ * EventEmitter propagation so it stays observable instead of being
+ * downgraded to a silently retired terminal.
+ */
+function isTerminalDetachStdinError(err: Error): boolean {
+	return (err as NodeJS.ErrnoException).code === "EIO";
+}
+const dispatchStdinError = (err: Error): void => {
+	if (!isTerminalDetachStdinError(err)) {
+		// Our listener must not be the reason a non-EIO error stops propagating.
+		// When no other "error" listener exists, EventEmitter would have thrown;
+		// rethrowing from inside emit() reproduces that exact contract.
+		const hasOtherListener = process.stdin.listeners("error").some(listener => listener !== dispatchStdinError);
+		if (!hasOtherListener) throw err;
+		return;
+	}
+	for (const subscriber of stdinErrorSubscribers) subscriber(err);
+};
+
+function subscribeToStdinErrors(subscriber: (err: Error) => void): void {
+	if (stdinErrorSubscribers.size === 0) process.stdin.on("error", dispatchStdinError);
+	stdinErrorSubscribers.add(subscriber);
+}
+
+function unsubscribeFromStdinErrors(subscriber: (err: Error) => void): void {
+	stdinErrorSubscribers.delete(subscriber);
+	if (stdinErrorSubscribers.size === 0) process.stdin.removeListener("error", dispatchStdinError);
+}
+
 /**
  * Real terminal using process.stdin/stdout
  */
@@ -242,6 +282,8 @@ export class ProcessTerminal implements Terminal {
 	#windowsVTInputRestore?: () => void;
 	#stdoutErrorHandler?: (err: Error) => void;
 	#stdoutErrorHandlerCleanupTimer?: Timer;
+	#stdinErrorHandler?: (err: Error) => void;
+	#stdinErrorHandlerCleanupTimer?: Timer;
 	#appearanceCallbacks: Array<(appearance: TerminalAppearance) => void> = [];
 	#appearance: TerminalAppearance | undefined;
 	#osc11Pending = false;
@@ -330,6 +372,21 @@ export class ProcessTerminal implements Terminal {
 			};
 			subscribeToStdoutErrors(this.#stdoutErrorHandler);
 		}
+		// stdin carries the same hazard as stdout: when the controlling PTY
+		// disappears (tmux pane killed, SSH dropped, terminal closed) the next
+		// read fails with EIO. `process.stdin` is an EventEmitter, so an
+		// unobserved "error" event is rethrown as an uncaught exception that
+		// kills the whole agent process instead of just retiring the terminal.
+		if (this.#stdinErrorHandlerCleanupTimer) {
+			clearTimeout(this.#stdinErrorHandlerCleanupTimer);
+			this.#stdinErrorHandlerCleanupTimer = undefined;
+		}
+		if (!this.#stdinErrorHandler) {
+			this.#stdinErrorHandler = (err: Error) => {
+				this.#markUnavailable(err, "stdin-error");
+			};
+			subscribeToStdinErrors(this.#stdinErrorHandler);
+		}
 
 		// Refresh terminal dimensions - they may be stale after suspend/resume
 		// (SIGWINCH is lost while process is stopped). Unix only.
@@ -860,6 +917,7 @@ export class ProcessTerminal implements Terminal {
 			this.#resizeHandler = undefined;
 		}
 		this.#scheduleStdoutErrorHandlerCleanup();
+		this.#scheduleStdinErrorHandlerCleanup();
 
 		// Pause stdin to prevent any buffered input (e.g., Ctrl+D) from being
 		// re-interpreted after raw mode is disabled. This fixes a race condition
@@ -889,6 +947,22 @@ export class ProcessTerminal implements Terminal {
 		this.#stdoutErrorHandlerCleanupTimer.unref?.();
 	}
 
+	#scheduleStdinErrorHandlerCleanup(): void {
+		if (!this.#stdinErrorHandler) return;
+		if (this.#stdinErrorHandlerCleanupTimer) clearTimeout(this.#stdinErrorHandlerCleanupTimer);
+		// stdin.pause() below does not cancel a read already in flight, so a PTY
+		// that vanishes during teardown still delivers EIO after stop() returns.
+		// Keep the listener armed for the same grace window as stdout.
+		this.#stdinErrorHandlerCleanupTimer = setTimeout(() => {
+			if (this.#stdinErrorHandler) {
+				unsubscribeFromStdinErrors(this.#stdinErrorHandler);
+				this.#stdinErrorHandler = undefined;
+			}
+			this.#stdinErrorHandlerCleanupTimer = undefined;
+		}, STDIN_ERROR_HANDLER_GRACE_MS);
+		this.#stdinErrorHandlerCleanupTimer.unref?.();
+	}
+
 	write(data: string): void {
 		this.#safeWrite(data);
 		if (this.#writeLogPath) {

package/src/tui.ts

@@ -4134,24 +4134,51 @@ export class TUI extends Container {
 		// the mutated off-screen prefix; the latest frame is updated below so each
 		// appended row is emitted exactly once.
 		if (firstChanged < prevViewportTop && appendedLines) {
-			// A same-length substitution above the viewport (a streaming status line,
-			// say) leaves every later row at its original index, so the visible suffix
-			// can still be committed. Growth *inside* the off-screen prefix instead
-			// shifts committed content down across the scrollback frontier: the rows
-			// this frame would commit already sit in native scrollback under their old
+			// A substitution above the viewport (a streaming status line, say) leaves
+			// every later row at its original index, so the visible suffix can still be
+			// committed. An insertion *inside* the off-screen prefix instead displaces
+			// committed content down across the scrollback frontier: the rows this
+			// frame would commit already sit in native scrollback under their old
 			// index, so emitting them appends a second copy — a pending tool block
 			// stranded above its own completed copy, with the rows between duplicated.
-			// The last committed row changing is the observable signal of that shift.
-			const committedBoundary = prevViewportTop - 1;
-			const committedBoundaryShifted =
-				committedBoundary >= diffStart &&
-				(this.#previousLines[committedBoundary] ?? "") !== (newLines[committedBoundary] ?? "");
-			if (committedBoundaryShifted) {
-				const reason = `offscreen growth shifted committed rows (${firstChanged} < ${prevViewportTop})`;
-				logRedraw(reason);
-				if (useViewportRepaintPath) viewportRepaint(reason);
-				else fullRender(true, reason);
-				return;
+			//
+			// Rendered bytes carry no row identity, so no test on them can prove which
+			// logical row moved: a substitution changes rows without moving anything,
+			// an insertion moves everything without necessarily changing any given row,
+			// and a run of repeated rows makes a plain append look exactly like a
+			// displacement. Since the two are not always distinguishable, look for the
+			// harm rather than the cause, and require both halves of it.
+			//
+			// First, a displacement moves the whole visible region down by one uniform
+			// offset, so the previously visible rows must reappear almost intact
+			// `offset` rows lower. Second — and this is what an append behind repeated
+			// rows cannot fake — the rows that displacement pulls into the top of the
+			// visible region must be exactly the last `offset` rows already committed
+			// to native scrollback. That second half is the damage itself: those rows
+			// are about to be emitted a second time. Rows merely rewritten in place
+			// push nothing back into view, so they still commit their suffix.
+			const shift = newLines.length - this.#previousLines.length;
+			const visibleRows = this.#previousLines.length - prevViewportTop;
+			if (shift > 0 && prevViewportTop > diffStart && visibleRows > 1) {
+				for (let offset = 1; offset <= Math.min(shift, prevViewportTop, visibleRows - 1); offset++) {
+					let recommittedRows = 0;
+					for (let j = 0; j < offset; j++) {
+						if (this.#previousLines[prevViewportTop - offset + j] === newLines[prevViewportTop + j]) {
+							recommittedRows += 1;
+						}
+					}
+					if (recommittedRows < offset) continue;
+					let displacedRows = 0;
+					for (let i = prevViewportTop; i < this.#previousLines.length; i++) {
+						if (this.#previousLines[i] === newLines[i + offset]) displacedRows += 1;
+					}
+					if (displacedRows < visibleRows - offset) continue;
+					const reason = `offscreen insertion displaced committed rows (${firstChanged} < ${prevViewportTop}, offset=${offset}/${visibleRows})`;
+					logRedraw(reason);
+					if (useViewportRepaintPath) viewportRepaint(reason);
+					else fullRender(true, reason);
+					return;
+				}
 			}
 			let suffixStart = -1;
 			for (let i = Math.max(diffStart, prevViewportTop); i < maxLines; i++) {