@boxes-dev/dvb 1.0.95 → 1.0.96

package/dist/devbox/terminal/sessionProtocol.js

@@ -0,0 +1,908 @@
+import { logger } from "../logger.js";
+import { BROWSER_OPEN_OSC_PREFIX, createOscMonitor } from "./osc.js";
+const HEARTBEAT_INTERVAL_MS = 4000;
+const INPUT_PROBE_TIMEOUT_MS = 1000;
+const STREAM_STALL_PROBE_MISS_THRESHOLD = 2;
+const CONNECT_OPEN_TIMEOUT_MS = 20_000;
+const WS_OPEN_STATE = 1;
+const MODAL_DISCONNECT_FILTER_CHUNKS = 8;
+export const createScrollbackEraseFilter = () => {
+    // Strip only scrollback-erase control sequences:
+    //   ESC [ 3 J
+    //   CSI 3 J (C1 single-byte CSI = 0x9b)
+    let state = 0;
+    const flushPending = (output) => {
+        if (state === 1) {
+            output.push(0x1b);
+        }
+        else if (state === 2) {
+            output.push(0x1b, 0x5b);
+        }
+        else if (state === 3) {
+            output.push(0x1b, 0x5b, 0x33);
+        }
+        else if (state === 10) {
+            output.push(0x9b);
+        }
+        else if (state === 11) {
+            output.push(0x9b, 0x33);
+        }
+        state = 0;
+    };
+    const pushByte = (output, byte) => {
+        if (state === 0) {
+            if (byte === 0x1b) {
+                state = 1;
+                return;
+            }
+            if (byte === 0x9b) {
+                state = 10;
+                return;
+            }
+            output.push(byte);
+            return;
+        }
+        if (state === 1) {
+            if (byte === 0x5b) {
+                state = 2;
+                return;
+            }
+            output.push(0x1b);
+            state = 0;
+            pushByte(output, byte);
+            return;
+        }
+        if (state === 2) {
+            if (byte === 0x33) {
+                state = 3;
+                return;
+            }
+            output.push(0x1b, 0x5b);
+            state = 0;
+            pushByte(output, byte);
+            return;
+        }
+        if (state === 3) {
+            if (byte === 0x4a) {
+                state = 0;
+                return;
+            }
+            output.push(0x1b, 0x5b, 0x33);
+            state = 0;
+            pushByte(output, byte);
+            return;
+        }
+        if (state === 10) {
+            if (byte === 0x33) {
+                state = 11;
+                return;
+            }
+            output.push(0x9b);
+            state = 0;
+            pushByte(output, byte);
+            return;
+        }
+        if (state === 11) {
+            if (byte === 0x4a) {
+                state = 0;
+                return;
+            }
+            output.push(0x9b, 0x33);
+            state = 0;
+            pushByte(output, byte);
+        }
+    };
+    return {
+        reset() {
+            state = 0;
+        },
+        transform(chunk) {
+            const bytes = Buffer.from(chunk ?? Buffer.alloc(0));
+            if (bytes.length === 0) {
+                return bytes;
+            }
+            const output = [];
+            for (const byte of bytes) {
+                pushByte(output, byte);
+            }
+            return output.length === 0 ? Buffer.alloc(0) : Buffer.from(output);
+        },
+        flush() {
+            const output = [];
+            flushPending(output);
+            return output.length === 0 ? Buffer.alloc(0) : Buffer.from(output);
+        },
+    };
+};
+export const createInitialAttachClearFilter = () => {
+    const patterns = [
+        Buffer.from("\u001b[H\u001b[J", "latin1"),
+        Buffer.from("\u001b[H\u001b[2J", "latin1"),
+        Buffer.from("\u001b[2J\u001b[H", "latin1"),
+        Buffer.from("\u001b[H", "latin1"),
+        Buffer.from("\u001b[2J", "latin1"),
+        Buffer.from("\u001b[J", "latin1"),
+        Buffer.from("\u001b[?1049h", "latin1"),
+        Buffer.from("\u001b[?1048h", "latin1"),
+        Buffer.from("\u001b[?1047h", "latin1"),
+        Buffer.from("\u001b[?47h", "latin1"),
+        Buffer.from("\u001b[?1h", "latin1"),
+        Buffer.from("\u001b=", "latin1"),
+        Buffer.from("\x9bH", "latin1"),
+        Buffer.from("\x9b2J", "latin1"),
+        Buffer.from("\x9bJ", "latin1"),
+        Buffer.from("\x9b?1049h", "latin1"),
+        Buffer.from("\x9b?1048h", "latin1"),
+        Buffer.from("\x9b?1047h", "latin1"),
+        Buffer.from("\x9b?47h", "latin1"),
+        Buffer.from("\x9b?1h", "latin1"),
+    ];
+    const maxPatternLength = patterns.reduce((max, pattern) => Math.max(max, pattern.length), 0);
+    const STARTUP_FILTER_CHUNKS = 6;
+    let enabled = true;
+    let pending = Buffer.alloc(0);
+    let chunksRemaining = STARTUP_FILTER_CHUNKS;
+    const startsWithPatternPrefix = (bytes) => patterns.some((pattern) => {
+        if (bytes.length > pattern.length) {
+            return false;
+        }
+        return pattern.subarray(0, bytes.length).equals(bytes);
+    });
+    const stripLeadingPatterns = (bytes) => {
+        let remaining = bytes;
+        let removed = true;
+        while (removed && remaining.length > 0) {
+            removed = false;
+            for (const pattern of patterns) {
+                if (remaining.length >= pattern.length) {
+                    const candidate = remaining.subarray(0, pattern.length);
+                    if (candidate.equals(pattern)) {
+                        remaining = remaining.subarray(pattern.length);
+                        removed = true;
+                        break;
+                    }
+                }
+            }
+        }
+        return remaining;
+    };
+    const stripInlineArtifacts = (bytes) => {
+        if (bytes.length === 0)
+            return bytes;
+        let text = bytes.toString("latin1");
+        // Keep prompt redraw semantics without full-screen jumps by converting
+        // cursor-home moves into CR, then dropping destructive clear sequences.
+        text = text.replace(/\x1b\[[0-9;]*H/g, "\r");
+        text = text.replace(/\x9b[0-9;]*H/g, "\r");
+        text = text.replace(/\x1b\]([^\x07\x1b]*)(\x07|\x1b\\)/g, (match, payload) => payload.startsWith(BROWSER_OPEN_OSC_PREFIX) ? match : "");
+        const artifactPatterns = [
+            /\x01/g,
+            /\x1b\[\?1049h/g,
+            /\x1b\[\?1048h/g,
+            /\x1b\[\?1047h/g,
+            /\x1b\[\?47h/g,
+            /\x1b\[\?1h/g,
+            /\x1b\[\?2004h/g,
+            /\x1b=/g,
+            /\x9b\?1049h/g,
+            /\x9b\?1048h/g,
+            /\x9b\?1047h/g,
+            /\x9b\?47h/g,
+            /\x9b\?1h/g,
+            /\x9b\?2004h/g,
+            /\x1b\[[0-9;?]*J/g,
+            /\x9b[0-9;?]*J/g,
+        ];
+        for (const pattern of artifactPatterns) {
+            text = text.replace(pattern, "");
+        }
+        text = text.replace(/\r{2,}/g, "\r");
+        if (/^\r+$/.test(text)) {
+            return Buffer.alloc(0);
+        }
+        return Buffer.from(text, "latin1");
+    };
+    return {
+        reset() {
+            enabled = true;
+            pending = Buffer.alloc(0);
+            chunksRemaining = STARTUP_FILTER_CHUNKS;
+        },
+        transform(chunk) {
+            const bytes = Buffer.from(chunk ?? Buffer.alloc(0));
+            if (bytes.length === 0) {
+                return bytes;
+            }
+            if (!enabled) {
+                return bytes;
+            }
+            let work = pending.length > 0
+                ? Buffer.concat([pending, bytes])
+                : Buffer.from(bytes);
+            pending = Buffer.alloc(0);
+            work = stripLeadingPatterns(work);
+            work = stripInlineArtifacts(work);
+            chunksRemaining = Math.max(0, chunksRemaining - 1);
+            if (work.length === 0) {
+                if (chunksRemaining === 0) {
+                    enabled = false;
+                }
+                return Buffer.alloc(0);
+            }
+            const holdBytes = Math.min(work.length, Math.max(1, maxPatternLength - 1));
+            if (holdBytes > 0) {
+                const prefix = work.subarray(0, holdBytes);
+                if (prefix.length === work.length && startsWithPatternPrefix(prefix)) {
+                    pending = Buffer.from(prefix);
+                    return Buffer.alloc(0);
+                }
+            }
+            if (chunksRemaining === 0) {
+                enabled = false;
+            }
+            return work;
+        },
+        flush() {
+            const out = pending;
+            pending = Buffer.alloc(0);
+            enabled = false;
+            chunksRemaining = 0;
+            return out;
+        },
+    };
+};
+export const createModalTtyOutputFilter = () => {
+    const initialAttachClearFilter = createInitialAttachClearFilter();
+    const scrollbackEraseFilter = createScrollbackEraseFilter();
+    return {
+        reset() {
+            initialAttachClearFilter.reset?.();
+            scrollbackEraseFilter.reset?.();
+        },
+        transform(chunk) {
+            const initialFiltered = initialAttachClearFilter.transform(chunk);
+            if (initialFiltered.length === 0) {
+                return Buffer.alloc(0);
+            }
+            return scrollbackEraseFilter.transform(initialFiltered);
+        },
+        flush() {
+            const pendingInitial = initialAttachClearFilter.flush();
+            const pendingFiltered = pendingInitial.length > 0
+                ? scrollbackEraseFilter.transform(pendingInitial)
+                : Buffer.alloc(0);
+            const pendingScrollback = scrollbackEraseFilter.flush();
+            if (pendingFiltered.length === 0) {
+                return pendingScrollback;
+            }
+            if (pendingScrollback.length === 0) {
+                return pendingFiltered;
+            }
+            return Buffer.concat([pendingFiltered, pendingScrollback]);
+        },
+    };
+};
+export const stripModalDisconnectArtifacts = (chunk) => {
+    if (chunk.length === 0)
+        return chunk;
+    let text = chunk.toString("latin1");
+    const artifactPatterns = [
+        /\x01/g,
+        /\x03\x00/g,
+        /\x1b\[\?1000l/g,
+        /\x1b\[\?1002l/g,
+        /\x1b\[\?1003l/g,
+        /\x1b\[\?1004l/g,
+        /\x1b\[\?1005l/g,
+        /\x1b\[\?1006l/g,
+        /\x1b\[\?2004l/g,
+        /\x1b\[\?1049l/g,
+        /\x1b\[\?1048l/g,
+        /\x1b\[\?1047l/g,
+        /\x1b\[\?47l/g,
+        /\x1b\[\?25h/g,
+        /\x1b\[<u/g,
+        /\x1b\[>4;0m/g,
+        /\x1b\[\?1l/g,
+        /\x1b>/g,
+    ];
+    for (const pattern of artifactPatterns) {
+        text = text.replace(pattern, "");
+    }
+    return Buffer.from(text, "latin1");
+};
+export const streamExecSession = async (ws, options) => new Promise((resolve, reject) => {
+    let exitCode = null;
+    let resolved = false;
+    let opened = false;
+    let closeCode;
+    let pendingResize = null;
+    let lastResize = null;
+    const pendingInput = [];
+    let lastSeenAt = Date.now();
+    let lastStreamActivityAt = Date.now();
+    let heartbeatTimer = null;
+    let inputProbeTimer = null;
+    let openTimer = null;
+    let inputProbeStamp = 0;
+    let inputProbeStreamStamp = 0;
+    let streamProbeMisses = 0;
+    let disconnectNoted = false;
+    let errorMessage;
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    const stderr = process.stderr;
+    const latency = options.latency;
+    const oscMonitor = createOscMonitor();
+    const ttyOutputFilter = options.ttyOutputFilter;
+    let disconnectFilterChunksRemaining = 0;
+    const armDisconnectFilter = () => {
+        if (!options.stripDisconnectArtifacts)
+            return;
+        disconnectFilterChunksRemaining = Math.max(disconnectFilterChunksRemaining, MODAL_DISCONNECT_FILTER_CHUNKS);
+    };
+    const applyDisconnectFilter = (chunk) => {
+        if (!options.stripDisconnectArtifacts)
+            return chunk;
+        if (disconnectFilterChunksRemaining <= 0)
+            return chunk;
+        disconnectFilterChunksRemaining -= 1;
+        return stripModalDisconnectArtifacts(chunk);
+    };
+    const initialInput = typeof options.initialInput === "string"
+        ? Buffer.from(options.initialInput, "utf8")
+        : options.initialInput;
+    const supportsResizeControlMessages = options.supportsResizeControlMessages ?? true;
+    if (options.stdin && initialInput && initialInput.length > 0) {
+        pendingInput.push(initialInput);
+    }
+    const markAlive = () => {
+        lastSeenAt = Date.now();
+    };
+    const markStreamAlive = () => {
+        const now = Date.now();
+        lastSeenAt = now;
+        lastStreamActivityAt = now;
+        streamProbeMisses = 0;
+    };
+    const noteDisconnect = () => {
+        options.onDisconnectNotice?.();
+    };
+    const recordDisconnect = (kind) => {
+        if (disconnectNoted)
+            return;
+        disconnectNoted = true;
+        const details = { kind, opened };
+        if (typeof closeCode === "number") {
+            details.closeCode = closeCode;
+        }
+        latency?.noteDisconnect(details);
+    };
+    const finish = (code) => {
+        if (resolved)
+            return;
+        resolved = true;
+        cleanup();
+        resolve({ kind: "exit", code });
+    };
+    const finishDetach = () => {
+        if (resolved)
+            return;
+        resolved = true;
+        cleanup();
+        try {
+            ws.close();
+        }
+        catch {
+            // ignore close failures
+        }
+        resolve({ kind: "detach" });
+    };
+    const writeTtyOutput = (chunk) => {
+        if (chunk.length === 0)
+            return;
+        const { output, browserUrls } = oscMonitor.write(chunk);
+        if (output.length > 0) {
+            stdout.write(output);
+        }
+        for (const url of browserUrls) {
+            if (!options.openBrowser(url)) {
+                stderr.write(`Failed to open browser. Visit: ${url}\r\n`);
+            }
+        }
+    };
+    const handleBinary = (buffer) => {
+        if (buffer.length === 0)
+            return;
+        if (options.tty) {
+            const rawBuffer = Buffer.from(buffer);
+            options.onOutputChunk?.(rawBuffer);
+            options.onOutput?.();
+            const filteredBuffer = ttyOutputFilter
+                ? ttyOutputFilter.transform(rawBuffer)
+                : rawBuffer;
+            writeTtyOutput(applyDisconnectFilter(filteredBuffer));
+            return;
+        }
+        const streamId = buffer[0];
+        const payload = buffer.subarray(1);
+        if (streamId === 1) {
+            if (payload.length > 0) {
+                options.onOutputChunk?.(payload);
+            }
+            if (payload.length > 0)
+                options.onOutput?.();
+            stdout.write(Buffer.from(payload));
+        }
+        if (streamId === 2) {
+            if (payload.length > 0) {
+                options.onOutputChunk?.(payload);
+            }
+            if (payload.length > 0)
+                options.onOutput?.();
+            stderr.write(Buffer.from(payload));
+        }
+        if (streamId === 3 && payload.length > 0) {
+            armDisconnectFilter();
+            exitCode = payload[0] ?? 0;
+            ws.close();
+        }
+    };
+    const handleText = (data) => {
+        try {
+            const payload = JSON.parse(data);
+            if (payload.type === "session_info") {
+                const rawId = payload.session_id ?? payload.id ?? payload.sessionId;
+                if (rawId !== undefined) {
+                    options.onSessionInfo?.(String(rawId));
+                }
+                return;
+            }
+            if (payload.type === "exit" && typeof payload.exit_code === "number") {
+                exitCode = payload.exit_code;
+                ws.close();
+                return;
+            }
+            if (payload.type === "port_opened" || payload.type === "port_closed") {
+                const port = Number(payload.port);
+                if (Number.isFinite(port)) {
+                    const event = { type: payload.type, port };
+                    if (typeof payload.pid === "number")
+                        event.pid = payload.pid;
+                    if (typeof payload.address === "string") {
+                        event.address = payload.address;
+                    }
+                    options.onPortEvent?.(event);
+                }
+                return;
+            }
+            if (payload.type === "tty_replay_start") {
+                options.onReplayStart?.();
+                return;
+            }
+            if (payload.type === "tty_replay_done") {
+                if (options.tty && ttyOutputFilter) {
+                    writeTtyOutput(applyDisconnectFilter(ttyOutputFilter.flush()));
+                }
+                options.onReplayDone?.();
+                return;
+            }
+        }
+        catch {
+            // fall through
+        }
+        if (data.length > 0) {
+            options.onOutputChunk?.(Buffer.from(data, "utf8"));
+        }
+        options.onOutput?.();
+        if (options.tty) {
+            if (data.includes("logout")) {
+                armDisconnectFilter();
+            }
+            const dataBuffer = Buffer.from(data, "utf8");
+            const filtered = ttyOutputFilter
+                ? ttyOutputFilter.transform(dataBuffer)
+                : dataBuffer;
+            writeTtyOutput(applyDisconnectFilter(filtered));
+        }
+        else {
+            stdout.write(data);
+        }
+    };
+    const onMessage = (event) => {
+        markStreamAlive();
+        const data = event.data;
+        if (typeof data === "string") {
+            handleText(data);
+            return;
+        }
+        if (data instanceof ArrayBuffer) {
+            handleBinary(new Uint8Array(data));
+            return;
+        }
+        if (data instanceof Uint8Array) {
+            handleBinary(data);
+            return;
+        }
+        if (typeof Blob !== "undefined" && data instanceof Blob) {
+            data
+                .arrayBuffer()
+                .then((buffer) => handleBinary(new Uint8Array(buffer)))
+                .catch(() => {
+                // ignore blob decode failure
+            });
+        }
+    };
+    const sendResize = () => {
+        if (!options.tty)
+            return;
+        if (!supportsResizeControlMessages)
+            return;
+        const { cols, rows } = options.resolveTtySize();
+        if (lastResize && lastResize.cols === cols && lastResize.rows === rows) {
+            return;
+        }
+        if (!opened) {
+            pendingResize = { cols, rows };
+            return;
+        }
+        ws.send(JSON.stringify({ type: "resize", cols, rows }));
+        lastResize = { cols, rows };
+    };
+    const sendInput = (chunk) => {
+        if (chunk.length > 0) {
+            options.onInputChunk?.(chunk);
+        }
+        if (!latency) {
+            ws.send(chunk);
+            return;
+        }
+        const bufferedAmount = typeof ws.bufferedAmount === "number" ? ws.bufferedAmount : undefined;
+        const onSent = latency.noteSend(chunk.byteLength, bufferedAmount);
+        try {
+            ws.send(chunk, onSent);
+        }
+        catch (error) {
+            onSent(error instanceof Error ? error : new Error(String(error)));
+            throw error;
+        }
+    };
+    const summarizeInputChunk = (chunk) => ({
+        length: chunk.length,
+        hasCtrlC: chunk.includes(0x03),
+        hasCtrlD: chunk.includes(0x04),
+        hasCr: chunk.includes(0x0d),
+        hasLf: chunk.includes(0x0a),
+    });
+    const onStdin = (chunk) => {
+        if (options.tty && options.isRawCtrlCChunk(chunk)) {
+            const handled = options.onRawCtrlC?.() ?? false;
+            if (handled) {
+                return;
+            }
+        }
+        if (!opened) {
+            pendingInput.push(chunk);
+            logger.debug("connect_stdin_buffered_preopen", {
+                ...summarizeInputChunk(chunk),
+                pendingInputCount: pendingInput.length,
+            });
+            return;
+        }
+        if (options.tty && chunk.length === 1 && chunk[0] === 0x1c) {
+            stderr.write("\r\nDetached.\r\n");
+            logger.info("connect_stdin_detach_key", {
+                opened,
+                readyState: ws.readyState,
+            });
+            finishDetach();
+            return;
+        }
+        if (options.tty && chunk.length === 1 && chunk[0] === 0x04) {
+            armDisconnectFilter();
+        }
+        if (typeof ws.readyState === "number" &&
+            ws.readyState !== WS_OPEN_STATE) {
+            logger.warn("connect_stdin_socket_not_open", {
+                readyState: ws.readyState,
+                opened,
+                ...summarizeInputChunk(chunk),
+            });
+            noteDisconnect();
+            forceClose();
+            onError();
+            return;
+        }
+        const ageMs = Date.now() - lastSeenAt;
+        const hasRecoveryKey = chunk.includes(0x03) || // Ctrl+C
+            chunk.includes(0x04) || // Ctrl+D
+            chunk.includes(0x0d) || // Enter (CR)
+            chunk.includes(0x0a); // Enter (LF)
+        if (ageMs > HEARTBEAT_INTERVAL_MS ||
+            (streamProbeMisses > 0 && hasRecoveryKey)) {
+            startInputProbe();
+        }
+        if (hasRecoveryKey) {
+            logger.info("connect_stdin_recovery_key", {
+                ...summarizeInputChunk(chunk),
+                ageMs,
+                streamProbeMisses,
+                readyState: ws.readyState,
+            });
+        }
+        try {
+            sendInput(chunk);
+        }
+        catch {
+            logger.warn("connect_stdin_send_failed", {
+                ...summarizeInputChunk(chunk),
+                ageMs,
+                readyState: ws.readyState,
+            });
+            noteDisconnect();
+            forceClose();
+            onError();
+        }
+    };
+    const startInputProbe = () => {
+        if (inputProbeTimer || typeof ws.ping !== "function")
+            return;
+        inputProbeStamp = lastSeenAt;
+        inputProbeStreamStamp = lastStreamActivityAt;
+        try {
+            ws.ping?.();
+            latency?.notePingSent("input_probe");
+        }
+        catch {
+            // ignore ping failures
+        }
+        inputProbeTimer = setTimeout(() => {
+            inputProbeTimer = null;
+            if (resolved)
+                return;
+            if (lastSeenAt === inputProbeStamp) {
+                streamProbeMisses = 0;
+                latency?.noteInputProbeTimeout();
+                noteDisconnect();
+                forceClose();
+                onError();
+                return;
+            }
+            if (lastStreamActivityAt === inputProbeStreamStamp) {
+                streamProbeMisses += 1;
+                if (streamProbeMisses >= STREAM_STALL_PROBE_MISS_THRESHOLD) {
+                    latency?.noteInputProbeTimeout();
+                    noteDisconnect();
+                    forceClose();
+                    onError();
+                }
+                return;
+            }
+        }, INPUT_PROBE_TIMEOUT_MS);
+    };
+    const stopInputProbe = () => {
+        if (inputProbeTimer) {
+            clearTimeout(inputProbeTimer);
+            inputProbeTimer = null;
+        }
+    };
+    const stopOpenTimer = () => {
+        if (openTimer) {
+            clearTimeout(openTimer);
+            openTimer = null;
+        }
+    };
+    const onPong = () => {
+        markAlive();
+        latency?.notePong();
+    };
+    const forceClose = () => {
+        if (typeof ws.terminate === "function") {
+            ws.terminate();
+            return;
+        }
+        ws.close();
+    };
+    const startHeartbeat = () => {
+        if (typeof ws.ping !== "function")
+            return;
+        markAlive();
+        if (typeof ws.on === "function") {
+            ws.on("pong", onPong);
+        }
+        heartbeatTimer = setInterval(() => {
+            if (resolved)
+                return;
+            try {
+                ws.ping?.();
+                latency?.notePingSent("heartbeat");
+            }
+            catch {
+                // ignore ping failures
+            }
+        }, HEARTBEAT_INTERVAL_MS);
+    };
+    const stopHeartbeat = () => {
+        if (heartbeatTimer) {
+            clearInterval(heartbeatTimer);
+            heartbeatTimer = null;
+        }
+        if (typeof ws.off === "function") {
+            ws.off("pong", onPong);
+        }
+        else if (typeof ws.removeListener === "function") {
+            ws.removeListener("pong", onPong);
+        }
+    };
+    const startInput = () => {
+        if (!options.stdin)
+            return;
+        let rawModeEnabled = false;
+        if (options.tty && stdin.isTTY) {
+            try {
+                stdin.setRawMode(true);
+                rawModeEnabled = true;
+            }
+            catch {
+                logger.warn("connect_stdin_rawmode_enable_failed");
+                // ignore raw mode failure
+            }
+        }
+        logger.info("connect_stdin_start", {
+            tty: options.tty,
+            stdinIsTty: stdin.isTTY,
+            rawModeEnabled,
+        });
+        stdin.resume();
+        stdin.on("data", onStdin);
+        process.on("SIGWINCH", sendResize);
+    };
+    const stopInput = () => {
+        if (!options.stdin)
+            return;
+        stdin.removeListener("data", onStdin);
+        process.removeListener("SIGWINCH", sendResize);
+        stdin.pause();
+        let rawModeRestored = false;
+        if (options.tty && stdin.isTTY) {
+            try {
+                stdin.setRawMode(false);
+                rawModeRestored = true;
+            }
+            catch {
+                logger.warn("connect_stdin_rawmode_restore_failed");
+                // ignore restore errors
+            }
+        }
+        logger.info("connect_stdin_stop", {
+            tty: options.tty,
+            stdinIsTty: stdin.isTTY,
+            rawModeRestored,
+        });
+    };
+    const flushPending = () => {
+        if (!opened)
+            return;
+        if (pendingResize) {
+            ws.send(JSON.stringify({
+                type: "resize",
+                cols: pendingResize.cols,
+                rows: pendingResize.rows,
+            }));
+            lastResize = pendingResize;
+            pendingResize = null;
+        }
+        if (pendingInput.length > 0) {
+            for (const chunk of pendingInput) {
+                sendInput(chunk);
+            }
+            pendingInput.length = 0;
+        }
+    };
+    const cleanup = () => {
+        if (options.tty && ttyOutputFilter) {
+            writeTtyOutput(ttyOutputFilter.flush());
+        }
+        ws.removeEventListener("message", onMessage);
+        ws.removeEventListener("close", onClose);
+        ws.removeEventListener("error", onError);
+        ws.removeEventListener("open", onOpen);
+        stopInputProbe();
+        stopOpenTimer();
+        stopHeartbeat();
+        stopInput();
+    };
+    const onClose = (event) => {
+        closeCode = typeof event?.code === "number" ? event.code : closeCode;
+        logger.info("connect_ws_close", {
+            opened,
+            closeCode,
+            exitCode,
+        });
+        recordDisconnect("close");
+        if (exitCode !== null) {
+            finish(exitCode);
+            return;
+        }
+        if (closeCode === 1000) {
+            finish(0);
+            return;
+        }
+        const result = {
+            kind: "disconnect",
+            opened,
+        };
+        if (closeCode !== undefined)
+            result.closeCode = closeCode;
+        cleanup();
+        resolve(result);
+    };
+    const onError = (event) => {
+        if (resolved)
+            return;
+        const raw = event?.data;
+        if (raw instanceof Error && raw.message.trim()) {
+            errorMessage = raw.message.trim();
+        }
+        else if (typeof raw === "string" && raw.trim()) {
+            errorMessage = raw.trim();
+        }
+        else if (raw &&
+            typeof raw === "object" &&
+            "message" in raw &&
+            typeof raw.message === "string" &&
+            raw.message.trim()) {
+            errorMessage = raw.message.trim();
+        }
+        recordDisconnect("error");
+        const result = {
+            kind: "disconnect",
+            opened,
+        };
+        if (closeCode !== undefined)
+            result.closeCode = closeCode;
+        if (errorMessage)
+            result.errorMessage = errorMessage;
+        logger.warn("connect_ws_error", {
+            opened,
+            closeCode,
+            errorMessage,
+        });
+        cleanup();
+        resolve(result);
+    };
+    const onOpen = () => {
+        stopOpenTimer();
+        opened = true;
+        markAlive();
+        latency?.noteConnectOpen();
+        logger.info("connect_ws_open", {
+            tty: options.tty,
+            stdin: options.stdin,
+        });
+        flushPending();
+        startInput();
+        startHeartbeat();
+        options.onOpen?.();
+    };
+    ws.binaryType = "arraybuffer";
+    ws.addEventListener("message", onMessage);
+    ws.addEventListener("close", onClose);
+    ws.addEventListener("error", onError);
+    ws.addEventListener("open", onOpen);
+    sendResize();
+    const openTimeoutMs = options.openTimeoutMs ?? CONNECT_OPEN_TIMEOUT_MS;
+    if (openTimeoutMs > 0) {
+        openTimer = setTimeout(() => {
+            if (resolved || opened)
+                return;
+            noteDisconnect();
+            forceClose();
+            onError({
+                data: new Error(`Timed out waiting for session connection after ${openTimeoutMs}ms.`),
+            });
+        }, openTimeoutMs);
+        openTimer.unref();
+    }
+});
+//# sourceMappingURL=sessionProtocol.js.map