@bubblebrain-ai/bubble 0.0.51 → 0.0.53

package/node_modules/@bubblebrain-ai/pi-tui/dist/src/terminal.d.ts

@@ -0,0 +1,142 @@
+export type KeyboardProtocolNegotiationSequence = {
+    type: "kitty-flags";
+    flags: number;
+} | {
+    type: "device-attributes";
+};
+export declare function parseKeyboardProtocolNegotiationSequence(sequence: string): KeyboardProtocolNegotiationSequence | undefined;
+export declare function isAppleTerminalSession(): boolean;
+export declare function normalizeNativeShiftEnterInput(data: string, shouldDetectNativeShiftEnter: boolean, isShiftPressed: boolean): string;
+export declare function normalizeAppleTerminalInput(data: string, isAppleTerminal: boolean, isShiftPressed: boolean): string;
+/** A long wall-clock gap while the event loop could not run is the portable
+ * signal Node exposes for laptop sleep/wake. */
+export declare function isTerminalWakeGap(elapsedMs: number, thresholdMs?: number): boolean;
+/**
+ * Minimal terminal interface for TUI
+ */
+export interface Terminal {
+    start(onInput: (data: string) => void, onResize: () => void, onResume?: () => void): void;
+    stop(): void;
+    /**
+     * Drain stdin before exiting to prevent Kitty key release events from
+     * leaking to the parent shell over slow SSH connections.
+     * @param maxMs - Maximum time to drain (default: 1000ms)
+     * @param idleMs - Exit early if no input arrives within this time (default: 50ms)
+     */
+    drainInput(maxMs?: number, idleMs?: number): Promise<void>;
+    write(data: string): void;
+    get columns(): number;
+    get rows(): number;
+    get kittyProtocolActive(): boolean;
+    moveBy(lines: number): void;
+    hideCursor(): void;
+    showCursor(): void;
+    clearLine(): void;
+    clearFromCursor(): void;
+    clearScreen(): void;
+    setTitle(title: string): void;
+    setProgress(active: boolean): void;
+}
+/**
+ * Resolve how long to wait for the rest of an escape sequence before
+ * dispatching a lone ESC as the Escape key. Legacy Alt+key input is ESC plus
+ * another byte, so high-latency transports need a longer reassembly window.
+ */
+export declare function resolveEscapeTimeoutMs(env?: NodeJS.ProcessEnv): number;
+/**
+ * Real terminal using process.stdin/stdout
+ */
+export declare class ProcessTerminal implements Terminal {
+    private wasRaw;
+    private inputHandler?;
+    private resizeHandler?;
+    private resumeHandler?;
+    private _kittyProtocolActive;
+    private _modifyOtherKeysActive;
+    private keyboardProtocolPushed;
+    private keyboardProtocolNegotiationBuffer;
+    private keyboardProtocolBufferFlushTimer?;
+    private stdinBuffer?;
+    private stdinDataHandler?;
+    private progressInterval?;
+    private wakeCheckInterval?;
+    private lastWakeCheckAt;
+    private lastWakeRecoveryAt?;
+    private readonly handleContinue;
+    private writeLogPath;
+    get kittyProtocolActive(): boolean;
+    get modifyOtherKeysActive(): boolean;
+    start(onInput: (data: string) => void, onResize: () => void, onResume?: () => void): void;
+    /**
+     * Reassert every terminal-side input contract after system wake. macOS may
+     * preserve tty raw flags while leaving Node stdin paused or Ghostty's
+     * private keyboard modes reset.
+     */
+    private recoverAfterWake;
+    private startWakeRecovery;
+    private checkForWake;
+    /**
+     * SIGCONT and the overdue watchdog timer are commonly delivered together
+     * after a long process suspension. Collapse them into one atomic recovery so
+     * the freshly rebuilt stdin parser cannot be torn down a second time while
+     * the user is already typing or pasting.
+     */
+    private requestWakeRecovery;
+    private stopWakeRecovery;
+    private resetKeyboardInputPipeline;
+    /**
+     * Set up StdinBuffer to split batched input into individual sequences.
+     * This ensures components receive single events, making matchesKey/isKeyRelease work correctly.
+     *
+     * Also watches for Kitty protocol response and enables it when detected.
+     * This is done here (after stdinBuffer parsing) rather than on raw stdin
+     * to handle the case where the response arrives split across multiple events.
+     */
+    private setupStdinBuffer;
+    /**
+     * Query terminal for Kitty keyboard protocol support and enable it if available.
+     *
+     * Kitty's progressive enhancement detection requires requesting the desired
+     * flags before querying them. The trailing DA query is a sentinel supported by
+     * terminals that do not know Kitty keyboard protocol; receiving DA before a
+     * Kitty response enables modifyOtherKeys fallback without a startup timeout.
+     *
+     * The requested flags are:
+     * - 1 = disambiguate escape codes
+     * - 2 = report event types (press/repeat/release)
+     * - 4 = report alternate keys (shifted key, base layout key)
+     */
+    private queryAndEnableKittyProtocol;
+    private handleKeyboardProtocolNegotiationSequence;
+    private readKeyboardProtocolNegotiationSequence;
+    private setKeyboardProtocolNegotiationBuffer;
+    private clearKeyboardProtocolNegotiationBuffer;
+    private flushKeyboardProtocolNegotiationBufferAsInput;
+    private scheduleKeyboardProtocolNegotiationBufferFlush;
+    private clearKeyboardProtocolNegotiationBufferFlushTimer;
+    private forwardInputSequence;
+    private enableModifyOtherKeys;
+    private disableModifyOtherKeys;
+    /**
+     * On Windows, add ENABLE_VIRTUAL_TERMINAL_INPUT (0x0200) to the stdin
+     * console handle so the terminal sends VT sequences for modified keys
+     * (e.g. \x1b[Z for Shift+Tab). Without this, libuv's ReadConsoleInputW
+     * discards modifier state and Shift+Tab arrives as plain \t.
+     */
+    private enableWindowsVTInput;
+    drainInput(maxMs?: number, idleMs?: number): Promise<void>;
+    stop(): void;
+    write(data: string): void;
+    get columns(): number;
+    get rows(): number;
+    moveBy(lines: number): void;
+    hideCursor(): void;
+    showCursor(): void;
+    clearLine(): void;
+    clearFromCursor(): void;
+    clearScreen(): void;
+    setTitle(title: string): void;
+    setProgress(active: boolean): void;
+    private clearProgressInterval;
+}
+//# sourceMappingURL=terminal.d.ts.map

package/node_modules/@bubblebrain-ai/pi-tui/dist/src/terminal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal.d.ts","sourceRoot":"","sources":["../../src/terminal.ts"],"names":[],"mappings":"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"}

package/node_modules/@bubblebrain-ai/pi-tui/dist/src/terminal.js

@@ -0,0 +1,544 @@
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { setKittyProtocolActive } from "./keys.js";
+import { isNativeModifierPressed } from "./native-modifiers.js";
+import { StdinBuffer } from "./stdin-buffer.js";
+const cjsRequire = createRequire(import.meta.url);
+const TERMINAL_PROGRESS_KEEPALIVE_MS = 1000;
+const TERMINAL_PROGRESS_ACTIVE_SEQUENCE = "\x1b]9;4;3\x07";
+const TERMINAL_PROGRESS_CLEAR_SEQUENCE = "\x1b]9;4;0\x07";
+const NATIVE_SHIFT_ENTER_SEQUENCE = "\x1b[13;2u";
+const DESIRED_KITTY_KEYBOARD_PROTOCOL_FLAGS = 7;
+const KEYBOARD_PROTOCOL_RESPONSE_FRAGMENT_TIMEOUT_MS = 150;
+const KITTY_KEYBOARD_PROTOCOL_QUERY = `\x1b[>${DESIRED_KITTY_KEYBOARD_PROTOCOL_FLAGS}u\x1b[?u\x1b[c`;
+const TERMINAL_WAKE_CHECK_INTERVAL_MS = 1_000;
+const TERMINAL_WAKE_GAP_MS = 5_000;
+const TERMINAL_WAKE_RECOVERY_COOLDOWN_MS = 2_000;
+export function parseKeyboardProtocolNegotiationSequence(sequence) {
+    const kittyFlags = sequence.match(/^\x1b\[\?(\d+)u$/);
+    if (kittyFlags) {
+        return { type: "kitty-flags", flags: Number.parseInt(kittyFlags[1], 10) };
+    }
+    if (/^\x1b\[\?[\d;]*c$/.test(sequence)) {
+        return { type: "device-attributes" };
+    }
+    return undefined;
+}
+function isKeyboardProtocolNegotiationSequencePrefix(sequence) {
+    return sequence === "\x1b[" || /^\x1b\[\?[\d;]*$/.test(sequence);
+}
+export function isAppleTerminalSession() {
+    return process.platform === "darwin" && process.env.TERM_PROGRAM === "Apple_Terminal";
+}
+export function normalizeNativeShiftEnterInput(data, shouldDetectNativeShiftEnter, isShiftPressed) {
+    if (shouldDetectNativeShiftEnter && data === "\r" && isShiftPressed)
+        return NATIVE_SHIFT_ENTER_SEQUENCE;
+    return data;
+}
+export function normalizeAppleTerminalInput(data, isAppleTerminal, isShiftPressed) {
+    return normalizeNativeShiftEnterInput(data, isAppleTerminal, isShiftPressed);
+}
+/** A long wall-clock gap while the event loop could not run is the portable
+ * signal Node exposes for laptop sleep/wake. */
+export function isTerminalWakeGap(elapsedMs, thresholdMs = TERMINAL_WAKE_GAP_MS) {
+    return Number.isFinite(elapsedMs) && elapsedMs >= thresholdMs;
+}
+const DEFAULT_ESCAPE_TIMEOUT_MS = 10;
+const DEFAULT_SSH_ESCAPE_TIMEOUT_MS = 100;
+/**
+ * Resolve how long to wait for the rest of an escape sequence before
+ * dispatching a lone ESC as the Escape key. Legacy Alt+key input is ESC plus
+ * another byte, so high-latency transports need a longer reassembly window.
+ */
+export function resolveEscapeTimeoutMs(env = process.env) {
+    const configured = Number(env.PI_TUI_ESC_TIMEOUT);
+    if (Number.isFinite(configured) && configured > 0) {
+        return configured;
+    }
+    if (env.SSH_CONNECTION || env.SSH_TTY) {
+        return DEFAULT_SSH_ESCAPE_TIMEOUT_MS;
+    }
+    return DEFAULT_ESCAPE_TIMEOUT_MS;
+}
+/**
+ * Real terminal using process.stdin/stdout
+ */
+export class ProcessTerminal {
+    constructor() {
+        this.wasRaw = false;
+        this._kittyProtocolActive = false;
+        this._modifyOtherKeysActive = false;
+        this.keyboardProtocolPushed = false;
+        this.keyboardProtocolNegotiationBuffer = "";
+        this.lastWakeCheckAt = 0;
+        this.handleContinue = () => this.requestWakeRecovery();
+        this.writeLogPath = (() => {
+            const env = process.env.PI_TUI_WRITE_LOG || "";
+            if (!env)
+                return "";
+            try {
+                if (fs.statSync(env).isDirectory()) {
+                    const now = new Date();
+                    const ts = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}_${String(now.getHours()).padStart(2, "0")}-${String(now.getMinutes()).padStart(2, "0")}-${String(now.getSeconds()).padStart(2, "0")}`;
+                    return path.join(env, `tui-${ts}-${process.pid}.log`);
+                }
+            }
+            catch {
+                // Not an existing directory - use as-is (file path)
+            }
+            return env;
+        })();
+    }
+    get kittyProtocolActive() {
+        return this._kittyProtocolActive;
+    }
+    get modifyOtherKeysActive() {
+        return this._modifyOtherKeysActive;
+    }
+    start(onInput, onResize, onResume) {
+        this.inputHandler = onInput;
+        this.resizeHandler = onResize;
+        this.resumeHandler = onResume;
+        // Save previous state and enable raw mode
+        this.wasRaw = process.stdin.isRaw || false;
+        if (process.stdin.setRawMode) {
+            process.stdin.setRawMode(true);
+        }
+        process.stdin.setEncoding("utf8");
+        process.stdin.resume();
+        // Enable bracketed paste mode - terminal will wrap pastes in \x1b[200~ ... \x1b[201~
+        process.stdout.write("\x1b[?2004h");
+        // Set up resize handler immediately
+        process.stdout.on("resize", this.resizeHandler);
+        // Refresh terminal dimensions - they may be stale after suspend/resume
+        // (SIGWINCH is lost while process is stopped). Unix only.
+        if (process.platform !== "win32") {
+            process.kill(process.pid, "SIGWINCH");
+        }
+        // On Windows, enable ENABLE_VIRTUAL_TERMINAL_INPUT so the console sends
+        // VT escape sequences (e.g. \x1b[Z for Shift+Tab) instead of raw console
+        // events that lose modifier information. Must run AFTER setRawMode(true)
+        // since that resets console mode flags.
+        this.enableWindowsVTInput();
+        // Query Kitty keyboard protocol and fall back to modifyOtherKeys when DA confirms no Kitty response.
+        // See: https://sw.kovidgoyal.net/kitty/keyboard-protocol/
+        this.queryAndEnableKittyProtocol();
+        this.startWakeRecovery();
+    }
+    /**
+     * Reassert every terminal-side input contract after system wake. macOS may
+     * preserve tty raw flags while leaving Node stdin paused or Ghostty's
+     * private keyboard modes reset.
+     */
+    recoverAfterWake() {
+        if (!this.inputHandler)
+            return;
+        if (process.stdin.setRawMode)
+            process.stdin.setRawMode(true);
+        process.stdin.setEncoding("utf8");
+        this.resetKeyboardInputPipeline();
+        process.stdin.resume();
+        process.stdout.write("\x1b[?2004h");
+        this.queryAndEnableKittyProtocol();
+        // Dimensions and the alternate-screen buffer can both be stale even when
+        // macOS did not deliver a SIGWINCH for the wake.
+        this.resizeHandler?.();
+        this.resumeHandler?.();
+    }
+    startWakeRecovery() {
+        this.stopWakeRecovery();
+        this.lastWakeCheckAt = Date.now();
+        this.lastWakeRecoveryAt = undefined;
+        this.wakeCheckInterval = setInterval(() => {
+            this.checkForWake();
+        }, TERMINAL_WAKE_CHECK_INTERVAL_MS);
+        this.wakeCheckInterval.unref?.();
+        if (process.platform !== "win32")
+            process.on("SIGCONT", this.handleContinue);
+    }
+    checkForWake(now = Date.now()) {
+        const elapsed = now - this.lastWakeCheckAt;
+        this.lastWakeCheckAt = now;
+        if (isTerminalWakeGap(elapsed))
+            this.requestWakeRecovery(now);
+    }
+    /**
+     * SIGCONT and the overdue watchdog timer are commonly delivered together
+     * after a long process suspension. Collapse them into one atomic recovery so
+     * the freshly rebuilt stdin parser cannot be torn down a second time while
+     * the user is already typing or pasting.
+     */
+    requestWakeRecovery(now = Date.now()) {
+        this.lastWakeCheckAt = now;
+        if (this.lastWakeRecoveryAt !== undefined) {
+            const elapsedSinceRecovery = now - this.lastWakeRecoveryAt;
+            if (elapsedSinceRecovery >= 0 && elapsedSinceRecovery < TERMINAL_WAKE_RECOVERY_COOLDOWN_MS) {
+                return;
+            }
+        }
+        this.lastWakeRecoveryAt = now;
+        this.recoverAfterWake();
+    }
+    stopWakeRecovery() {
+        if (this.wakeCheckInterval) {
+            clearInterval(this.wakeCheckInterval);
+            this.wakeCheckInterval = undefined;
+        }
+        if (process.platform !== "win32")
+            process.removeListener("SIGCONT", this.handleContinue);
+        this.lastWakeRecoveryAt = undefined;
+    }
+    resetKeyboardInputPipeline() {
+        const shouldPopKittyProtocol = this.keyboardProtocolPushed || this._kittyProtocolActive;
+        this.clearKeyboardProtocolNegotiationBuffer();
+        if (shouldPopKittyProtocol)
+            process.stdout.write("\x1b[<u");
+        this.keyboardProtocolPushed = false;
+        this._kittyProtocolActive = false;
+        setKittyProtocolActive(false);
+        this.disableModifyOtherKeys();
+        if (this.stdinBuffer) {
+            this.stdinBuffer.destroy();
+            this.stdinBuffer = undefined;
+        }
+        if (this.stdinDataHandler) {
+            process.stdin.removeListener("data", this.stdinDataHandler);
+            this.stdinDataHandler = undefined;
+        }
+    }
+    /**
+     * Set up StdinBuffer to split batched input into individual sequences.
+     * This ensures components receive single events, making matchesKey/isKeyRelease work correctly.
+     *
+     * Also watches for Kitty protocol response and enables it when detected.
+     * This is done here (after stdinBuffer parsing) rather than on raw stdin
+     * to handle the case where the response arrives split across multiple events.
+     */
+    setupStdinBuffer() {
+        this.stdinBuffer = new StdinBuffer({ escapeTimeout: resolveEscapeTimeoutMs() });
+        // Forward individual sequences to the input handler
+        this.stdinBuffer.on("data", (sequence) => {
+            const negotiationSequence = this.readKeyboardProtocolNegotiationSequence(sequence);
+            if (negotiationSequence === "pending") {
+                this.scheduleKeyboardProtocolNegotiationBufferFlush();
+                return; // Wait briefly for the rest of a split Kitty response.
+            }
+            if (this.handleKeyboardProtocolNegotiationSequence(negotiationSequence)) {
+                return;
+            }
+            this.forwardInputSequence(sequence);
+        });
+        // Re-wrap paste content with bracketed paste markers for existing editor handling
+        this.stdinBuffer.on("paste", (content) => {
+            if (this.inputHandler) {
+                this.inputHandler(`\x1b[200~${content}\x1b[201~`);
+            }
+        });
+        // Handler that pipes stdin data through the buffer
+        this.stdinDataHandler = (data) => {
+            this.stdinBuffer.process(data);
+        };
+    }
+    /**
+     * Query terminal for Kitty keyboard protocol support and enable it if available.
+     *
+     * Kitty's progressive enhancement detection requires requesting the desired
+     * flags before querying them. The trailing DA query is a sentinel supported by
+     * terminals that do not know Kitty keyboard protocol; receiving DA before a
+     * Kitty response enables modifyOtherKeys fallback without a startup timeout.
+     *
+     * The requested flags are:
+     * - 1 = disambiguate escape codes
+     * - 2 = report event types (press/repeat/release)
+     * - 4 = report alternate keys (shifted key, base layout key)
+     */
+    queryAndEnableKittyProtocol() {
+        this.setupStdinBuffer();
+        process.stdin.on("data", this.stdinDataHandler);
+        this.keyboardProtocolPushed = true;
+        this.clearKeyboardProtocolNegotiationBuffer();
+        process.stdout.write(KITTY_KEYBOARD_PROTOCOL_QUERY);
+    }
+    handleKeyboardProtocolNegotiationSequence(negotiationSequence) {
+        if (!negotiationSequence)
+            return false;
+        this.clearKeyboardProtocolNegotiationBuffer();
+        if (negotiationSequence.type === "kitty-flags") {
+            if (negotiationSequence.flags !== 0) {
+                this.disableModifyOtherKeys();
+                if (!this._kittyProtocolActive) {
+                    this._kittyProtocolActive = true;
+                    setKittyProtocolActive(true);
+                }
+            }
+            else {
+                this.enableModifyOtherKeys();
+            }
+            return true;
+        }
+        if (!this._kittyProtocolActive) {
+            this.enableModifyOtherKeys();
+        }
+        return true;
+    }
+    readKeyboardProtocolNegotiationSequence(sequence) {
+        if (this.keyboardProtocolNegotiationBuffer) {
+            const bufferedSequence = this.keyboardProtocolNegotiationBuffer + sequence;
+            const negotiationSequence = parseKeyboardProtocolNegotiationSequence(bufferedSequence);
+            if (negotiationSequence) {
+                this.clearKeyboardProtocolNegotiationBuffer();
+                return negotiationSequence;
+            }
+            if (isKeyboardProtocolNegotiationSequencePrefix(bufferedSequence)) {
+                this.setKeyboardProtocolNegotiationBuffer(bufferedSequence);
+                return "pending";
+            }
+            this.flushKeyboardProtocolNegotiationBufferAsInput();
+        }
+        const negotiationSequence = parseKeyboardProtocolNegotiationSequence(sequence);
+        if (negotiationSequence)
+            return negotiationSequence;
+        if (isKeyboardProtocolNegotiationSequencePrefix(sequence)) {
+            this.setKeyboardProtocolNegotiationBuffer(sequence);
+            return "pending";
+        }
+        return undefined;
+    }
+    setKeyboardProtocolNegotiationBuffer(sequence) {
+        this.clearKeyboardProtocolNegotiationBufferFlushTimer();
+        this.keyboardProtocolNegotiationBuffer = sequence;
+    }
+    clearKeyboardProtocolNegotiationBuffer() {
+        this.clearKeyboardProtocolNegotiationBufferFlushTimer();
+        this.keyboardProtocolNegotiationBuffer = "";
+    }
+    flushKeyboardProtocolNegotiationBufferAsInput() {
+        if (!this.keyboardProtocolNegotiationBuffer)
+            return;
+        const sequence = this.keyboardProtocolNegotiationBuffer;
+        this.clearKeyboardProtocolNegotiationBuffer();
+        this.forwardInputSequence(sequence);
+    }
+    scheduleKeyboardProtocolNegotiationBufferFlush() {
+        if (!this.keyboardProtocolNegotiationBuffer || this.keyboardProtocolBufferFlushTimer)
+            return;
+        this.keyboardProtocolBufferFlushTimer = setTimeout(() => {
+            this.keyboardProtocolBufferFlushTimer = undefined;
+            this.flushKeyboardProtocolNegotiationBufferAsInput();
+        }, KEYBOARD_PROTOCOL_RESPONSE_FRAGMENT_TIMEOUT_MS);
+    }
+    clearKeyboardProtocolNegotiationBufferFlushTimer() {
+        if (!this.keyboardProtocolBufferFlushTimer)
+            return;
+        clearTimeout(this.keyboardProtocolBufferFlushTimer);
+        this.keyboardProtocolBufferFlushTimer = undefined;
+    }
+    forwardInputSequence(sequence) {
+        if (!this.inputHandler)
+            return;
+        const shouldDetectNativeShiftEnter = sequence === "\r" && (isAppleTerminalSession() || process.platform === "win32");
+        const input = normalizeNativeShiftEnterInput(sequence, shouldDetectNativeShiftEnter, shouldDetectNativeShiftEnter && isNativeModifierPressed("shift"));
+        this.inputHandler(input);
+    }
+    enableModifyOtherKeys() {
+        if (this._kittyProtocolActive || this._modifyOtherKeysActive)
+            return;
+        process.stdout.write("\x1b[>4;2m");
+        this._modifyOtherKeysActive = true;
+    }
+    disableModifyOtherKeys() {
+        if (!this._modifyOtherKeysActive)
+            return;
+        process.stdout.write("\x1b[>4;0m");
+        this._modifyOtherKeysActive = false;
+    }
+    /**
+     * On Windows, add ENABLE_VIRTUAL_TERMINAL_INPUT (0x0200) to the stdin
+     * console handle so the terminal sends VT sequences for modified keys
+     * (e.g. \x1b[Z for Shift+Tab). Without this, libuv's ReadConsoleInputW
+     * discards modifier state and Shift+Tab arrives as plain \t.
+     */
+    enableWindowsVTInput() {
+        if (process.platform !== "win32")
+            return;
+        try {
+            const arch = process.arch;
+            if (arch !== "x64" && arch !== "arm64")
+                return;
+            // Dynamic require so non-Windows and bundled/browser paths never load the
+            // native helper. In the npm package native/ is next to dist/; in compiled
+            // binary archives native/ is copied next to the executable.
+            const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+            const nativePath = path.join("native", "win32", "prebuilds", `win32-${arch}`, "win32-console-mode.node");
+            const candidates = [
+                path.join(moduleDir, "..", nativePath),
+                path.join(moduleDir, nativePath),
+                path.join(path.dirname(process.execPath), nativePath),
+            ];
+            for (const modulePath of candidates) {
+                try {
+                    const helper = cjsRequire(modulePath);
+                    helper.enableVirtualTerminalInput?.();
+                    return;
+                }
+                catch {
+                    // Try the next possible packaging location.
+                }
+            }
+        }
+        catch {
+            // Native helper not available — Shift+Tab won't be distinguishable from Tab.
+        }
+    }
+    async drainInput(maxMs = 1000, idleMs = 50) {
+        const shouldDisableKittyProtocol = this.keyboardProtocolPushed || this._kittyProtocolActive;
+        this.clearKeyboardProtocolNegotiationBuffer();
+        if (shouldDisableKittyProtocol) {
+            // Disable Kitty keyboard protocol first so any late key releases
+            // do not generate new Kitty escape sequences.
+            process.stdout.write("\x1b[<u");
+            this.keyboardProtocolPushed = false;
+            this._kittyProtocolActive = false;
+            setKittyProtocolActive(false);
+        }
+        this.disableModifyOtherKeys();
+        const previousHandler = this.inputHandler;
+        this.inputHandler = undefined;
+        let lastDataTime = Date.now();
+        const onData = () => {
+            lastDataTime = Date.now();
+        };
+        process.stdin.on("data", onData);
+        const endTime = Date.now() + maxMs;
+        try {
+            while (true) {
+                const now = Date.now();
+                const timeLeft = endTime - now;
+                if (timeLeft <= 0)
+                    break;
+                if (now - lastDataTime >= idleMs)
+                    break;
+                await new Promise((resolve) => setTimeout(resolve, Math.min(idleMs, timeLeft)));
+            }
+        }
+        finally {
+            process.stdin.removeListener("data", onData);
+            this.inputHandler = previousHandler;
+        }
+    }
+    stop() {
+        this.stopWakeRecovery();
+        if (this.clearProgressInterval()) {
+            process.stdout.write(TERMINAL_PROGRESS_CLEAR_SEQUENCE);
+        }
+        // Disable bracketed paste mode
+        process.stdout.write("\x1b[?2004l");
+        const shouldDisableKittyProtocol = this.keyboardProtocolPushed || this._kittyProtocolActive;
+        this.clearKeyboardProtocolNegotiationBuffer();
+        // Disable Kitty keyboard protocol if not already done by drainInput()
+        if (shouldDisableKittyProtocol) {
+            process.stdout.write("\x1b[<u");
+            this.keyboardProtocolPushed = false;
+            this._kittyProtocolActive = false;
+            setKittyProtocolActive(false);
+        }
+        this.disableModifyOtherKeys();
+        // Clean up StdinBuffer
+        if (this.stdinBuffer) {
+            this.stdinBuffer.destroy();
+            this.stdinBuffer = undefined;
+        }
+        // Remove event handlers
+        if (this.stdinDataHandler) {
+            process.stdin.removeListener("data", this.stdinDataHandler);
+            this.stdinDataHandler = undefined;
+        }
+        this.inputHandler = undefined;
+        if (this.resizeHandler) {
+            process.stdout.removeListener("resize", this.resizeHandler);
+            this.resizeHandler = undefined;
+        }
+        this.resumeHandler = undefined;
+        // 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
+        // where Ctrl+D could close the parent shell over SSH.
+        process.stdin.pause();
+        // Restore raw mode state
+        if (process.stdin.setRawMode) {
+            process.stdin.setRawMode(this.wasRaw);
+        }
+    }
+    write(data) {
+        process.stdout.write(data);
+        if (this.writeLogPath) {
+            try {
+                fs.appendFileSync(this.writeLogPath, data, { encoding: "utf8" });
+            }
+            catch {
+                // Ignore logging errors
+            }
+        }
+    }
+    get columns() {
+        return process.stdout.columns || Number(process.env.COLUMNS) || 80;
+    }
+    get rows() {
+        return process.stdout.rows || Number(process.env.LINES) || 24;
+    }
+    moveBy(lines) {
+        if (lines > 0) {
+            // Move down
+            process.stdout.write(`\x1b[${lines}B`);
+        }
+        else if (lines < 0) {
+            // Move up
+            process.stdout.write(`\x1b[${-lines}A`);
+        }
+        // lines === 0: no movement
+    }
+    hideCursor() {
+        process.stdout.write("\x1b[?25l");
+    }
+    showCursor() {
+        process.stdout.write("\x1b[?25h");
+    }
+    clearLine() {
+        process.stdout.write("\x1b[K");
+    }
+    clearFromCursor() {
+        process.stdout.write("\x1b[J");
+    }
+    clearScreen() {
+        process.stdout.write("\x1b[2J\x1b[H"); // Clear screen and move to home (1,1)
+    }
+    setTitle(title) {
+        // OSC 0;title BEL - set terminal window title
+        process.stdout.write(`\x1b]0;${title}\x07`);
+    }
+    setProgress(active) {
+        if (active) {
+            // OSC 9;4;3 - indeterminate progress
+            process.stdout.write(TERMINAL_PROGRESS_ACTIVE_SEQUENCE);
+            if (!this.progressInterval) {
+                this.progressInterval = setInterval(() => {
+                    process.stdout.write(TERMINAL_PROGRESS_ACTIVE_SEQUENCE);
+                }, TERMINAL_PROGRESS_KEEPALIVE_MS);
+            }
+        }
+        else {
+            this.clearProgressInterval();
+            // OSC 9;4;0 - clear progress
+            process.stdout.write(TERMINAL_PROGRESS_CLEAR_SEQUENCE);
+        }
+    }
+    clearProgressInterval() {
+        if (!this.progressInterval)
+            return false;
+        clearInterval(this.progressInterval);
+        this.progressInterval = undefined;
+        return true;
+    }
+}
+//# sourceMappingURL=terminal.js.map