@oh-my-pi/pi-tui 18.1.4 → 18.1.5

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## [Unreleased]
 
+## [18.1.5] - 2026-09-03
+
+### Fixed
+
+- Fixed terminal query support in supervised PTY processes, including cursor position reports.
+- Fixed paste-and-submit handling so an Enter keypress received with a bracketed paste is delivered to the previously focused component; `Editor.onLargePaste` now receives `PasteOptions` describing the queued submit.
+
 ## [18.1.3] - 2026-09-02
 
 ### Fixed

package/dist/types/components/editor.d.ts

@@ -57,6 +57,11 @@ export interface EditorTextAssistProvider {
     /** Return replacement candidates for the misspelled word at the cursor. */
     getWordReplacements?(lines: string[], cursorLine: number, cursorCol: number): EditorWordReplacements | null | Promise<EditorWordReplacements | null>;
 }
+/** What the paste transport knew about the input burst before the editor inserts the payload. */
+export interface PasteOptions {
+    /** A submit keypress arrived in the same input burst and will be dispatched right after the paste. */
+    submitAfterPaste?: boolean;
+}
 export declare class Editor implements Component, Focusable {
     #private;
     /** Focusable interface - set by TUI when focus changes */
@@ -89,8 +94,9 @@ export declare class Editor implements Component, Focusable {
      *  the editor inserts nothing and records no undo state, leaving insertion to the host (e.g. a
      *  "wrap in a code block / XML / attach as file" menu for very large pastes), which re-inserts
      *  via {@link insertPaste} or {@link insertText}. Return `false` (or leave unset) for the
-     *  default collapse-to-marker behavior. `lineCount` is the sanitized paste's line count. */
-    onLargePaste?: (text: string, lineCount: number) => boolean;
+     *  default collapse-to-marker behavior. `lineCount` is the sanitized paste's line count;
+     *  `options` carries what the paste transport knew about the burst. */
+    onLargePaste?: (text: string, lineCount: number, options: PasteOptions) => boolean;
     onAutocompleteCancel?: () => void;
     disableSubmit: boolean;
     constructor(theme: EditorTheme);
@@ -210,7 +216,7 @@ export declare class Editor implements Component, Focusable {
     /** Drop any volatile preview, then insert `text` as a single undoable edit. */
     commitVolatileText(text: string): void;
     /** Apply terminal paste semantics to text from non-bracketed paste transports. */
-    pasteText(text: string): void;
+    pasteText(text: string, options?: PasteOptions): void;
     /** Insert `content` as a collapsed `[Paste #N]` marker (stored for expansion on submit via
      *  {@link getExpandedText}). Hosts that intercept large pastes through {@link onLargePaste} use
      *  this to re-insert a (possibly transformed) paste without re-triggering the interception hook. */

package/dist/types/stdin-buffer.d.ts

@@ -43,7 +43,12 @@ export type StdinBufferOptions = {
 };
 export type StdinBufferEventMap = {
     data: [string];
-    paste: [string];
+    /**
+     * A completed bracketed paste. `enter` carries an Enter keypress that shared
+     * the paste's stdin read, so the terminal can dispatch paste and submit to
+     * the same focused component before a paste-triggered overlay can take focus.
+     */
+    paste: [content: string, enter?: string];
 };
 /**
  * Buffers stdin input and emits complete sequences via the 'data' event.

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-tui",
-	"version": "18.1.4",
+	"version": "18.1.5",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"homepage": "https://omp.sh",
 	"author": "Stencil Labs, Inc.",
@@ -37,8 +37,8 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-natives": "18.1.4",
-		"@oh-my-pi/pi-utils": "18.1.4"
+		"@oh-my-pi/pi-natives": "18.1.5",
+		"@oh-my-pi/pi-utils": "18.1.5"
 	},
 	"devDependencies": {
 		"kitty-vt-wasm": "^0.2.0"

package/src/components/editor.ts

@@ -467,6 +467,12 @@ export interface EditorTextAssistProvider {
 type HistoryCursorAnchor = "start" | "end";
 type AutocompleteRequest = { kind: "regular"; explicitTab: boolean } | { kind: "force" };
 
+/** What the paste transport knew about the input burst before the editor inserts the payload. */
+export interface PasteOptions {
+	/** A submit keypress arrived in the same input burst and will be dispatched right after the paste. */
+	submitAfterPaste?: boolean;
+}
+
 export class Editor implements Component, Focusable {
 	#state: EditorState = {
 		lines: [""],
@@ -581,8 +587,9 @@ export class Editor implements Component, Focusable {
 	 *  the editor inserts nothing and records no undo state, leaving insertion to the host (e.g. a
 	 *  "wrap in a code block / XML / attach as file" menu for very large pastes), which re-inserts
 	 *  via {@link insertPaste} or {@link insertText}. Return `false` (or leave unset) for the
-	 *  default collapse-to-marker behavior. `lineCount` is the sanitized paste's line count. */
-	onLargePaste?: (text: string, lineCount: number) => boolean;
+	 *  default collapse-to-marker behavior. `lineCount` is the sanitized paste's line count;
+	 *  `options` carries what the paste transport knew about the burst. */
+	onLargePaste?: (text: string, lineCount: number, options: PasteOptions) => boolean;
 	onAutocompleteCancel?: () => void;
 	disableSubmit: boolean = false;
 
@@ -2148,8 +2155,8 @@ export class Editor implements Component, Focusable {
 	}
 
 	/** Apply terminal paste semantics to text from non-bracketed paste transports. */
-	pasteText(text: string): void {
-		this.#handlePaste(text);
+	pasteText(text: string, options: PasteOptions = {}): void {
+		this.#handlePaste(text, options);
 	}
 
 	/** Insert `content` as a collapsed `[Paste #N]` marker (stored for expansion on submit via
@@ -2289,7 +2296,7 @@ export class Editor implements Component, Focusable {
 		}
 	}
 
-	#handlePaste(pastedText: string): void {
+	#handlePaste(pastedText: string, options: PasteOptions = {}): void {
 		let filteredText = this.#sanitizePastedText(pastedText);
 
 		// If pasting a file path (starts with /, ~, or .) and the character before
@@ -2311,7 +2318,7 @@ export class Editor implements Component, Focusable {
 		// Let the host intercept marker-sized pastes (e.g. the large-paste menu). When it takes
 		// over, the editor inserts nothing and records no undo state — the host re-inserts via
 		// `insertPaste`/`insertText` once the user chooses.
-		if (isMarkerSized && this.onLargePaste?.(filteredText, pastedLines.length)) {
+		if (isMarkerSized && this.onLargePaste?.(filteredText, pastedLines.length, options)) {
 			return;
 		}
 

package/src/stdin-buffer.ts

@@ -375,9 +375,27 @@ export type StdinBufferOptions = {
 	pasteByteLimit?: number;
 };
 
+const KITTY_ENTER = /^\x1b\[13(?:;1)?u/u;
+
+/**
+ * The Enter keypress that immediately follows a bracketed-paste end marker in
+ * the same stdin read: legacy CR/LF, or the kitty CSI-u encoding with no
+ * modifier. Nothing else qualifies — any other trailing byte takes the normal
+ * data route.
+ */
+function leadingEnter(input: string): string | undefined {
+	if (input.startsWith("\r") || input.startsWith("\n")) return input[0];
+	return KITTY_ENTER.exec(input)?.[0];
+}
+
 export type StdinBufferEventMap = {
 	data: [string];
-	paste: [string];
+	/**
+	 * A completed bracketed paste. `enter` carries an Enter keypress that shared
+	 * the paste's stdin read, so the terminal can dispatch paste and submit to
+	 * the same focused component before a paste-triggered overlay can take focus.
+	 */
+	paste: [content: string, enter?: string];
 };
 
 /**
@@ -577,10 +595,15 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 		this.#pasteBytes = 0;
 		this.#pendingKittyPrintableCodepoint = undefined;
 
-		this.emit("paste", pastedContent);
+		// A paste-and-Enter burst (automation, terminals that batch reads) must
+		// not split into two dispatches: the paste may open an overlay that
+		// would then swallow the Enter meant to submit it.
+		const enter = leadingEnter(remaining);
+		this.emit("paste", pastedContent, enter);
 
-		if (remaining.length > 0) {
-			this.process(remaining);
+		const rest = enter === undefined ? remaining : remaining.slice(enter.length);
+		if (rest.length > 0) {
+			this.process(rest);
 		}
 	}
 

package/src/terminal.ts

@@ -1359,10 +1359,13 @@ export class ProcessTerminal implements Terminal {
 			}
 		});
 
-		// Re-wrap paste content with bracketed paste markers for existing editor handling
-		this.#stdinBuffer.on("paste", (content: string) => {
+		// Re-wrap paste content with bracketed paste markers for existing editor
+		// handling. An Enter that shared the paste's stdin read rides along so
+		// paste and submit reach the component focused right now, not one the
+		// paste itself is about to open.
+		this.#stdinBuffer.on("paste", (content: string, enter?: string) => {
 			if (this.#inputHandler) {
-				this.#inputHandler(`\x1b[200~${content}\x1b[201~`);
+				this.#inputHandler(`\x1b[200~${content}\x1b[201~${enter ?? ""}`);
 			}
 		});