tinky-termcap 0.1.0

package/lib/utils/detect-termcap.js

@@ -0,0 +1,365 @@
+"use strict";
+/**
+ * @fileoverview Terminal capability detection utilities.
+ *
+ * This module provides functions and types for detecting terminal capabilities
+ * by sending escape sequence queries to the terminal and parsing responses.
+ * It supports detection of:
+ * - Background color (via OSC 11)
+ * - Terminal name/version (via XTVERSION)
+ * - Kitty keyboard protocol support
+ * - modifyOtherKeys mode support
+ *
+ * @example Basic usage with tinky
+ * ```tsx
+ * import { TermcapProvider, useTermcap } from "tinky-termcap";
+ *
+ * function App() {
+ *   const { isReady, backgroundColor, kittyProtocol } = useTermcap();
+ *
+ *   if (!isReady) return <Text>Detecting...</Text>;
+ *
+ *   return (
+ *     <Box>
+ *       <Text>Background: {backgroundColor ?? "unknown"}</Text>
+ *       <Text>Kitty: {kittyProtocol ? "yes" : "no"}</Text>
+ *     </Box>
+ *   );
+ * }
+ *
+ * render(
+ *   <TermcapProvider>
+ *     <App />
+ *   </TermcapProvider>
+ * );
+ * ```
+ *
+ * @example Direct usage without React
+ * ```typescript
+ * import { detectTermcap } from "tinky-termcap";
+ *
+ * async function main() {
+ *   const caps = await detectTermcap(process.stdin, process.stdout, 1000);
+ *   console.log("Terminal capabilities:", caps);
+ * }
+ * ```
+ *
+ * @packageDocumentation
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_DETECTION_TIMEOUT = void 0;
+exports.detectTermcap = detectTermcap;
+exports.resetForTesting = resetForTesting;
+var term_features_js_1 = require("./term-features.js");
+/**
+ * Parse RGB color from hex components to #rrggbb format.
+ *
+ * Terminal color responses use variable-length hex values (1-4 digits per
+ * component). This function normalizes them to the standard `#rrggbb` format.
+ *
+ * @param rHex - Red component in hex (1-4 digits)
+ * @param gHex - Green component in hex (1-4 digits)
+ * @param bHex - Blue component in hex (1-4 digits)
+ * @returns Normalized color string in `#rrggbb` format
+ *
+ * @example
+ * ```typescript
+ * // 2-digit hex (most common)
+ * parseColor("1a", "1a", "1a"); // "#1a1a1a"
+ *
+ * // 4-digit hex (some terminals)
+ * parseColor("1a1a", "1a1a", "1a1a"); // "#1a1a1a"
+ *
+ * // 1-digit hex
+ * parseColor("f", "0", "0"); // "#ff0000"
+ * ```
+ *
+ * @internal
+ */
+function parseColor(rHex, gHex, bHex) {
+    var parseComponent = function (hex) {
+        var val = parseInt(hex, 16);
+        if (hex.length === 1)
+            return (val / 15) * 255;
+        if (hex.length === 2)
+            return val;
+        if (hex.length === 3)
+            return (val / 4095) * 255;
+        if (hex.length === 4)
+            return (val / 65535) * 255;
+        return val;
+    };
+    var r = parseComponent(rHex);
+    var g = parseComponent(gHex);
+    var b = parseComponent(bHex);
+    var toHex = function (c) { return Math.round(c).toString(16).padStart(2, "0"); };
+    return "#".concat(toHex(r)).concat(toHex(g)).concat(toHex(b));
+}
+/**
+ * Default timeout for capability detection in milliseconds.
+ *
+ * This value (1000ms) provides a reasonable balance between:
+ * - Allowing enough time for slow terminals to respond
+ * - Not delaying application startup too long if terminal doesn't respond
+ *
+ * @example Custom timeout usage
+ * ```typescript
+ * import { detectTermcap, DEFAULT_DETECTION_TIMEOUT } from "tinky-termcap";
+ *
+ * // Use half the default timeout for faster startup
+ * const caps = await detectTermcap(stdin, stdout, DEFAULT_DETECTION_TIMEOUT / 2);
+ *
+ * // Or use a longer timeout for slow connections
+ * const caps = await detectTermcap(stdin, stdout, DEFAULT_DETECTION_TIMEOUT * 2);
+ * ```
+ */
+exports.DEFAULT_DETECTION_TIMEOUT = 1000;
+/**
+ * Detect terminal capabilities by querying the terminal.
+ *
+ * This function sends escape sequence queries to the terminal and parses
+ * the responses to determine supported features. It detects:
+ * - **Background color** - via OSC 11 query
+ * - **Terminal name** - via XTVERSION query
+ * - **Kitty protocol** - enhanced keyboard support
+ * - **modifyOtherKeys** - key disambiguation support
+ *
+ * The function uses Device Attributes (DA) as a "sentinel" - when the DA
+ * response is received, detection is considered complete since terminals
+ * always respond to DA queries.
+ *
+ * @param stdin - Input stream to read terminal responses from.
+ *   If not provided or not a TTY, returns default values immediately.
+ * @param stdout - Output stream to write queries to.
+ *   If not provided or not a TTY, returns default values immediately.
+ * @param timeout - Maximum time to wait for responses in milliseconds.
+ *   Defaults to {@link DEFAULT_DETECTION_TIMEOUT} (1000ms).
+ * @returns Promise resolving to detected capabilities.
+ *
+ * @remarks
+ * - This function should typically only be called once at app startup
+ * - The caller is responsible for enabling raw mode before calling
+ * - In non-TTY environments, returns immediately with default values
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { detectTermcap } from "tinky-termcap";
+ *
+ * async function main() {
+ *   // Enable raw mode first (required for reading responses)
+ *   process.stdin.setRawMode(true);
+ *
+ *   const caps = await detectTermcap(
+ *     process.stdin,
+ *     process.stdout,
+ *     1000
+ *   );
+ *
+ *   console.log("Detection complete:");
+ *   console.log("  Background:", caps.backgroundColor ?? "unknown");
+ *   console.log("  Terminal:", caps.terminalName ?? "unknown");
+ *   console.log("  Kitty:", caps.kittyProtocol ? "yes" : "no");
+ *   console.log("  modifyOtherKeys:", caps.modifyOtherKeys ? "yes" : "no");
+ * }
+ * ```
+ *
+ * @example With tinky hooks
+ * ```tsx
+ * import { useStdin, useStdout } from "tinky";
+ * import { detectTermcap } from "tinky-termcap";
+ *
+ * function DetectionComponent() {
+ *   const { stdin, setRawMode } = useStdin();
+ *   const { stdout } = useStdout();
+ *   const [caps, setCaps] = useState<TermcapInfo | null>(null);
+ *
+ *   useEffect(() => {
+ *     setRawMode(true);
+ *     detectTermcap(stdin, stdout, 1000).then(setCaps);
+ *   }, []);
+ *
+ *   if (!caps) return <Text>Detecting...</Text>;
+ *   return <Text>Ready!</Text>;
+ * }
+ * ```
+ *
+ * @example Testing with mock streams
+ * ```typescript
+ * import { EventEmitter } from "events";
+ * import { ReadStream, WriteStream } from "tinky";
+ * import { detectTermcap } from "tinky-termcap";
+ *
+ * // Create mock streams
+ * const mockStdin = new EventEmitter() as ReadStream;
+ * (mockStdin as any).isTTY = true;
+ *
+ * const mockStdout: WriteStream = {
+ *   isTTY: true,
+ *   write(data: string) {
+ *     // Simulate terminal responding to queries
+ *     setTimeout(() => {
+ *       mockStdin.emit("data", Buffer.from("\x1b[?62;c")); // DA response
+ *     }, 10);
+ *     return true;
+ *   },
+ * };
+ *
+ * const caps = await detectTermcap(mockStdin, mockStdout, 100);
+ * ```
+ */
+function detectTermcap(stdin, stdout, timeout) {
+    return __awaiter(this, void 0, void 0, function () {
+        var defaultResult;
+        return __generator(this, function (_a) {
+            defaultResult = {
+                isReady: true,
+                backgroundColor: undefined,
+                terminalName: undefined,
+                kittyProtocol: false,
+                modifyOtherKeys: false,
+            };
+            // Skip detection if not TTY
+            if ((stdin === null || stdin === void 0 ? void 0 : stdin.isTTY) === false) {
+                return [2 /*return*/, defaultResult];
+            }
+            return [2 /*return*/, new Promise(function (resolve) {
+                    // Assumption: Caller handles raw mode (e.g. via Tinky useStdin)
+                    var _a;
+                    var buffer = "";
+                    var backgroundColor;
+                    var terminalName;
+                    var kittyProtocol = false;
+                    var modifyOtherKeys = false;
+                    var bgReceived = false;
+                    var kittyReceived = false;
+                    var terminalNameReceived = false;
+                    var modifyOtherKeysReceived = false;
+                    var deviceAttributesReceived = false;
+                    var cleanup = function () {
+                        var _a;
+                        if (timeoutId) {
+                            clearTimeout(timeoutId);
+                        }
+                        (_a = stdin === null || stdin === void 0 ? void 0 : stdin.off) === null || _a === void 0 ? void 0 : _a.call(stdin, "data", onData);
+                        resolve({
+                            isReady: true,
+                            backgroundColor: backgroundColor,
+                            terminalName: terminalName,
+                            kittyProtocol: kittyProtocol,
+                            modifyOtherKeys: modifyOtherKeys,
+                        });
+                    };
+                    var timeoutId = setTimeout(cleanup, timeout);
+                    var onData = function (data) {
+                        buffer += data.toString();
+                        // Check for background color (OSC 11 response)
+                        if (!bgReceived) {
+                            var match = buffer.match(term_features_js_1.Osc11Feature.responseRegex);
+                            if (match) {
+                                bgReceived = true;
+                                backgroundColor = parseColor(match[1], match[2], match[3]);
+                            }
+                        }
+                        // Check for Kitty keyboard protocol support
+                        if (!kittyReceived && term_features_js_1.KittyFeature.responseRegex.test(buffer)) {
+                            kittyReceived = true;
+                            kittyProtocol = true;
+                        }
+                        // Check for modifyOtherKeys support
+                        if (!modifyOtherKeysReceived) {
+                            var match = buffer.match(term_features_js_1.ModifyOtherKeysFeature.responseRegex);
+                            if (match) {
+                                modifyOtherKeysReceived = true;
+                                var level = parseInt(match[1], 10);
+                                modifyOtherKeys = level >= 2;
+                            }
+                        }
+                        // Check for terminal name/version
+                        if (!terminalNameReceived) {
+                            var match = buffer.match(term_features_js_1.TerminalNameFeature.responseRegex);
+                            if (match) {
+                                terminalNameReceived = true;
+                                terminalName = match[1];
+                            }
+                        }
+                        // Device Attributes response acts as sentinel - finish when received
+                        if (!deviceAttributesReceived) {
+                            var match = buffer.match(term_features_js_1.DeviceAttributesFeature.responseRegex);
+                            if (match) {
+                                deviceAttributesReceived = true;
+                                cleanup();
+                            }
+                        }
+                    };
+                    (_a = stdin === null || stdin === void 0 ? void 0 : stdin.on) === null || _a === void 0 ? void 0 : _a.call(stdin, "data", onData);
+                    try {
+                        stdout === null || stdout === void 0 ? void 0 : stdout.write(term_features_js_1.KittyFeature.query +
+                            term_features_js_1.Osc11Feature.query +
+                            term_features_js_1.TerminalNameFeature.query +
+                            term_features_js_1.ModifyOtherKeysFeature.query +
+                            term_features_js_1.DeviceAttributesFeature.query);
+                    }
+                    catch (_b) {
+                        cleanup();
+                    }
+                })];
+        });
+    });
+}
+/**
+ * Reset module state for testing purposes.
+ *
+ * This function is provided for test isolation. In the current implementation,
+ * there is no module-level state to reset, but this function is maintained
+ * for API compatibility.
+ *
+ * @example
+ * ```typescript
+ * import { resetForTesting } from "tinky-termcap";
+ *
+ * beforeEach(() => {
+ *   resetForTesting();
+ * });
+ * ```
+ *
+ * @internal
+ */
+function resetForTesting() {
+    // No module-level state to reset in the new design
+}

package/lib/utils/detect.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Detected terminal capabilities.
+ */
+export interface TermcapInfo {
+    /** Whether detection is complete */
+    isReady: boolean;
+    /** Terminal background color in #rrggbb format, or undefined if not detected */
+    backgroundColor: string | undefined;
+    /** Terminal name/version string, or undefined if not detected */
+    terminalName: string | undefined;
+    /** Whether Kitty keyboard protocol is supported */
+    kittyProtocol: boolean;
+    /** Whether modifyOtherKeys mode is supported (level >= 2) */
+    modifyOtherKeys: boolean;
+}
+/**
+ * Default timeout for capability detection (in milliseconds).
+ */
+export declare const DEFAULT_DETECTION_TIMEOUT = 1000;
+/**
+ * Detect terminal capabilities by querying the terminal.
+ *
+ * This sends escape sequences to query terminal features and parses responses.
+ * Should only be called once at app startup.
+ *
+ * @param timeout - Maximum time to wait for responses (default: 1000ms)
+ * @returns Promise resolving to detected capabilities
+ */
+export declare function detectTerminalCapabilities(timeout?: number): Promise<TermcapInfo>;
+/**
+ * For testing purposes only - reset module state.
+ */
+export declare function resetForTesting(): void;

package/lib/utils/detect.js

@@ -0,0 +1,233 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_DETECTION_TIMEOUT = void 0;
+exports.detectTerminalCapabilities = detectTerminalCapabilities;
+exports.resetForTesting = resetForTesting;
+/* eslint-disable no-control-regex */
+var fs = __importStar(require("node:fs"));
+// ANSI escape sequence query strings
+var KITTY_QUERY = "\x1b[?u";
+var OSC_11_QUERY = "\x1b]11;?\x1b\\";
+var TERMINAL_NAME_QUERY = "\x1b[>q";
+var DEVICE_ATTRIBUTES_QUERY = "\x1b[c";
+var MODIFY_OTHER_KEYS_QUERY = "\x1b[>4;?m";
+// Response regex patterns
+var KITTY_REGEX = /\x1b\[\?(\d+)u/;
+var TERMINAL_NAME_REGEX = /\x1bP>\|(.+?)(\x1b\\|\x07)/;
+var DEVICE_ATTRIBUTES_REGEX = /\x1b\[\?(\d+)(;\d+)*c/;
+var OSC_11_REGEX = /\x1b\]11;rgb:([0-9a-fA-F]{1,4})\/([0-9a-fA-F]{1,4})\/([0-9a-fA-F]{1,4})(\x1b\\|\x07)?/;
+var MODIFY_OTHER_KEYS_REGEX = /\x1b\[>4;(\d+)m/;
+/**
+ * Parse RGB color from hex components to #rrggbb format.
+ */
+function parseColor(rHex, gHex, bHex) {
+    var parseComponent = function (hex) {
+        var val = parseInt(hex, 16);
+        if (hex.length === 1)
+            return (val / 15) * 255;
+        if (hex.length === 2)
+            return val;
+        if (hex.length === 3)
+            return (val / 4095) * 255;
+        if (hex.length === 4)
+            return (val / 65535) * 255;
+        return val;
+    };
+    var r = parseComponent(rHex);
+    var g = parseComponent(gHex);
+    var b = parseComponent(bHex);
+    var toHex = function (c) { return Math.round(c).toString(16).padStart(2, "0"); };
+    return "#".concat(toHex(r)).concat(toHex(g)).concat(toHex(b));
+}
+/**
+ * Default timeout for capability detection (in milliseconds).
+ */
+exports.DEFAULT_DETECTION_TIMEOUT = 1000;
+/**
+ * Detect terminal capabilities by querying the terminal.
+ *
+ * This sends escape sequences to query terminal features and parses responses.
+ * Should only be called once at app startup.
+ *
+ * @param timeout - Maximum time to wait for responses (default: 1000ms)
+ * @returns Promise resolving to detected capabilities
+ */
+function detectTerminalCapabilities() {
+    return __awaiter(this, arguments, void 0, function (timeout) {
+        var defaultResult;
+        if (timeout === void 0) { timeout = exports.DEFAULT_DETECTION_TIMEOUT; }
+        return __generator(this, function (_a) {
+            defaultResult = {
+                isReady: true,
+                backgroundColor: undefined,
+                terminalName: undefined,
+                kittyProtocol: false,
+                modifyOtherKeys: false,
+            };
+            // Skip detection if not TTY
+            if (!process.stdin.isTTY || !process.stdout.isTTY) {
+                return [2 /*return*/, defaultResult];
+            }
+            return [2 /*return*/, new Promise(function (resolve) {
+                    var originalRawMode = process.stdin.isRaw;
+                    if (!originalRawMode) {
+                        process.stdin.setRawMode(true);
+                    }
+                    var buffer = "";
+                    var backgroundColor;
+                    var terminalName;
+                    var kittyProtocol = false;
+                    var modifyOtherKeys = false;
+                    var bgReceived = false;
+                    var kittyReceived = false;
+                    var terminalNameReceived = false;
+                    var modifyOtherKeysReceived = false;
+                    var deviceAttributesReceived = false;
+                    var cleanup = function () {
+                        if (timeoutId) {
+                            clearTimeout(timeoutId);
+                        }
+                        process.stdin.removeListener("data", onData);
+                        if (!originalRawMode) {
+                            process.stdin.setRawMode(false);
+                        }
+                        resolve({
+                            isReady: true,
+                            backgroundColor: backgroundColor,
+                            terminalName: terminalName,
+                            kittyProtocol: kittyProtocol,
+                            modifyOtherKeys: modifyOtherKeys,
+                        });
+                    };
+                    var timeoutId = setTimeout(cleanup, timeout);
+                    var onData = function (data) {
+                        buffer += data.toString();
+                        // Check for background color (OSC 11 response)
+                        if (!bgReceived) {
+                            var match = buffer.match(OSC_11_REGEX);
+                            if (match) {
+                                bgReceived = true;
+                                backgroundColor = parseColor(match[1], match[2], match[3]);
+                            }
+                        }
+                        // Check for Kitty keyboard protocol support
+                        if (!kittyReceived && KITTY_REGEX.test(buffer)) {
+                            kittyReceived = true;
+                            kittyProtocol = true;
+                        }
+                        // Check for modifyOtherKeys support
+                        if (!modifyOtherKeysReceived) {
+                            var match = buffer.match(MODIFY_OTHER_KEYS_REGEX);
+                            if (match) {
+                                modifyOtherKeysReceived = true;
+                                var level = parseInt(match[1], 10);
+                                modifyOtherKeys = level >= 2;
+                            }
+                        }
+                        // Check for terminal name/version
+                        if (!terminalNameReceived) {
+                            var match = buffer.match(TERMINAL_NAME_REGEX);
+                            if (match) {
+                                terminalNameReceived = true;
+                                terminalName = match[1];
+                            }
+                        }
+                        // Device Attributes response acts as sentinel - finish when received
+                        if (!deviceAttributesReceived) {
+                            var match = buffer.match(DEVICE_ATTRIBUTES_REGEX);
+                            if (match) {
+                                deviceAttributesReceived = true;
+                                cleanup();
+                            }
+                        }
+                    };
+                    process.stdin.on("data", onData);
+                    try {
+                        fs.writeSync(process.stdout.fd, KITTY_QUERY +
+                            OSC_11_QUERY +
+                            TERMINAL_NAME_QUERY +
+                            MODIFY_OTHER_KEYS_QUERY +
+                            DEVICE_ATTRIBUTES_QUERY);
+                    }
+                    catch (_a) {
+                        cleanup();
+                    }
+                })];
+        });
+    });
+}
+/**
+ * For testing purposes only - reset module state.
+ */
+function resetForTesting() {
+    // No module-level state to reset in the new design
+}