@draht/tui 2026.6.11 → 2026.7.7

package/dist/tui.js

@@ -6,28 +6,42 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { performance } from "node:perf_hooks";
 import { isKeyRelease, matchesKey } from "./keys.js";
+import { isOsc11BackgroundColorResponse, parseOsc11BackgroundColor, parseTerminalColorSchemeReport, } from "./terminal-colors.js";
 import { deleteKittyImage, getCapabilities, isImageLine, setCellDimensions } from "./terminal-image.js";
 import { extractSegments, normalizeTerminalOutput, sliceByColumn, sliceWithWidth, visibleWidth } from "./utils.js";
 const KITTY_SEQUENCE_PREFIX = "\x1b_G";
-function extractKittyImageIds(line) {
+function parseKittyImageHeader(line) {
     const sequenceStart = line.indexOf(KITTY_SEQUENCE_PREFIX);
     if (sequenceStart === -1)
-        return [];
+        return undefined;
     const paramsStart = sequenceStart + KITTY_SEQUENCE_PREFIX.length;
     const paramsEnd = line.indexOf(";", paramsStart);
     if (paramsEnd === -1)
-        return [];
+        return undefined;
+    const ids = [];
+    let rows = 1;
     const params = line.slice(paramsStart, paramsEnd);
     for (const param of params.split(",")) {
         const [key, value] = param.split("=", 2);
-        if (key !== "i" || value === undefined)
+        if (value === undefined)
+            continue;
+        const numberValue = Number(value);
+        if (!Number.isInteger(numberValue) || numberValue <= 0 || numberValue > 0xffffffff)
             continue;
-        const id = Number(value);
-        if (Number.isInteger(id) && id > 0 && id <= 0xffffffff) {
-            return [id];
+        if (key === "i") {
+            ids.push(numberValue);
+        }
+        else if (key === "r") {
+            rows = numberValue;
         }
     }
-    return [];
+    return { ids, rows };
+}
+function extractKittyImageIds(line) {
+    return parseKittyImageHeader(line)?.ids ?? [];
+}
+function extractKittyImageRows(line) {
+    return parseKittyImageHeader(line)?.rows ?? 1;
 }
 /** Type guard to check if a component implements Focusable */
 export function isFocusable(component) {
@@ -115,6 +129,10 @@ export class TUI extends Container {
     previousViewportTop = 0; // Track previous viewport top for resize-aware cursor moves
     fullRedrawCount = 0;
     stopped = false;
+    pendingOsc11BackgroundReplies = 0;
+    pendingOsc11BackgroundQueries = [];
+    terminalColorSchemeListeners = new Set();
+    terminalColorSchemeNotificationsEnabled = false;
     // Overlay stack for modal components rendered on top of base content
     focusOrderCounter = 0;
     overlayStack = [];
@@ -414,6 +432,9 @@ export class TUI extends Container {
         this.stopped = false;
         this.terminal.start((data) => this.handleInput(data), () => this.requestRender());
         this.terminal.hideCursor();
+        if (this.terminalColorSchemeNotificationsEnabled) {
+            this.terminal.write("\x1b[?2031h");
+        }
         this.queryCellSize();
         this.requestRender();
     }
@@ -426,6 +447,21 @@ export class TUI extends Container {
     removeInputListener(listener) {
         this.inputListeners.delete(listener);
     }
+    onTerminalColorSchemeChange(listener) {
+        this.terminalColorSchemeListeners.add(listener);
+        return () => {
+            this.terminalColorSchemeListeners.delete(listener);
+        };
+    }
+    setTerminalColorSchemeNotifications(enabled) {
+        if (this.terminalColorSchemeNotificationsEnabled === enabled) {
+            return;
+        }
+        this.terminalColorSchemeNotificationsEnabled = enabled;
+        if (!this.stopped) {
+            this.terminal.write(enabled ? "\x1b[?2031h" : "\x1b[?2031l");
+        }
+    }
     queryCellSize() {
         // Only query if terminal supports images (cell size is only used for image rendering)
         if (!getCapabilities().images) {
@@ -441,6 +477,9 @@ export class TUI extends Container {
             clearTimeout(this.renderTimer);
             this.renderTimer = undefined;
         }
+        if (this.terminalColorSchemeNotificationsEnabled) {
+            this.terminal.write("\x1b[?2031l");
+        }
         // Move cursor to the end of the content to prevent overwriting/artifacts on exit
         if (this.previousLines.length > 0) {
             const targetRow = this.previousLines.length; // Line after the last content
@@ -505,6 +544,12 @@ export class TUI extends Container {
         }, delay);
     }
     handleInput(data) {
+        if (this.consumeOsc11BackgroundResponse(data)) {
+            return;
+        }
+        if (this.consumeTerminalColorSchemeReport(data)) {
+            return;
+        }
         if (this.inputListeners.size > 0) {
             let current = data;
             for (const listener of this.inputListeners) {
@@ -570,6 +615,37 @@ export class TUI extends Container {
             this.requestRender();
         }
     }
+    consumeOsc11BackgroundResponse(data) {
+        if (this.pendingOsc11BackgroundReplies <= 0) {
+            return false;
+        }
+        if (!isOsc11BackgroundColorResponse(data)) {
+            return false;
+        }
+        const rgb = parseOsc11BackgroundColor(data);
+        this.pendingOsc11BackgroundReplies -= 1;
+        const query = this.pendingOsc11BackgroundQueries.shift();
+        if (query && !query.settled) {
+            query.settled = true;
+            if (query.timer) {
+                clearTimeout(query.timer);
+                query.timer = undefined;
+            }
+            query.resolve?.(rgb);
+            query.resolve = undefined;
+        }
+        return true;
+    }
+    consumeTerminalColorSchemeReport(data) {
+        const scheme = parseTerminalColorSchemeReport(data);
+        if (!scheme) {
+            return false;
+        }
+        for (const listener of this.terminalColorSchemeListeners) {
+            listener(scheme);
+        }
+        return true;
+    }
     consumeCellSizeResponse(data) {
         // Response format: ESC [ 6 ; height ; width t
         const match = data.match(/^\x1b\[6;(\d+);(\d+)t$/);
@@ -789,14 +865,37 @@ export class TUI extends Container {
         }
         return buffer;
     }
-    expandLastChangedForKittyImages(firstChanged, lastChanged) {
+    getKittyImageReservedRows(lines, index, maxIndex = lines.length - 1) {
+        const rows = extractKittyImageRows(lines[index] ?? "");
+        if (rows <= 1)
+            return 1;
+        const maxRows = Math.min(rows, maxIndex - index + 1, lines.length - index);
+        let reservedRows = 1;
+        while (reservedRows < maxRows) {
+            const line = lines[index + reservedRows] ?? "";
+            if (isImageLine(line) || visibleWidth(line) > 0)
+                break;
+            reservedRows++;
+        }
+        return reservedRows;
+    }
+    expandChangedRangeForKittyImages(firstChanged, lastChanged, newLines) {
+        let expandedFirstChanged = firstChanged;
         let expandedLastChanged = lastChanged;
-        for (let i = firstChanged; i < this.previousLines.length; i++) {
-            if (extractKittyImageIds(this.previousLines[i]).length > 0) {
-                expandedLastChanged = Math.max(expandedLastChanged, i);
+        const expandForLines = (lines) => {
+            for (let i = 0; i < lines.length; i++) {
+                if (extractKittyImageIds(lines[i]).length === 0)
+                    continue;
+                const blockEnd = i + this.getKittyImageReservedRows(lines, i) - 1;
+                if (i >= firstChanged || (i <= lastChanged && blockEnd >= firstChanged)) {
+                    expandedFirstChanged = Math.min(expandedFirstChanged, i);
+                    expandedLastChanged = Math.max(expandedLastChanged, blockEnd);
+                }
             }
-        }
-        return expandedLastChanged;
+        };
+        expandForLines(this.previousLines);
+        expandForLines(newLines);
+        return { firstChanged: expandedFirstChanged, lastChanged: expandedLastChanged };
     }
     deleteChangedKittyImages(firstChanged, lastChanged) {
         if (firstChanged < 0 || lastChanged < firstChanged)
@@ -910,7 +1009,20 @@ export class TUI extends Container {
             for (let i = 0; i < newLines.length; i++) {
                 if (i > 0)
                     buffer += "\r\n";
-                buffer += newLines[i];
+                const line = newLines[i];
+                const isImage = isImageLine(line);
+                const imageReservedRows = isImage ? this.getKittyImageReservedRows(newLines, i) : 1;
+                if (imageReservedRows > 1 && imageReservedRows <= height) {
+                    for (let row = 1; row < imageReservedRows; row++) {
+                        buffer += "\r\n";
+                    }
+                    buffer += `\x1b[${imageReservedRows - 1}A`;
+                    buffer += line;
+                    buffer += `\x1b[${imageReservedRows - 1}B`;
+                    i += imageReservedRows - 1;
+                    continue;
+                }
+                buffer += line;
             }
             buffer += "\x1b[?2026l"; // End synchronized output
             this.terminal.write(buffer);
@@ -989,7 +1101,9 @@ export class TUI extends Container {
             lastChanged = newLines.length - 1;
         }
         if (firstChanged !== -1) {
-            lastChanged = this.expandLastChangedForKittyImages(firstChanged, lastChanged);
+            const expandedRange = this.expandChangedRangeForKittyImages(firstChanged, lastChanged, newLines);
+            firstChanged = expandedRange.firstChanged;
+            lastChanged = expandedRange.lastChanged;
         }
         const appendStart = appendedLines && firstChanged === this.previousLines.length && firstChanged > 0;
         // No changes - but still need to update hardware cursor position if it moved
@@ -1090,9 +1204,27 @@ export class TUI extends Container {
         for (let i = firstChanged; i <= renderEnd; i++) {
             if (i > firstChanged)
                 buffer += "\r\n";
-            buffer += "\x1b[2K"; // Clear current line
             const line = newLines[i];
             const isImage = isImageLine(line);
+            const imageReservedRows = isImage ? this.getKittyImageReservedRows(newLines, i, renderEnd) : 1;
+            if (imageReservedRows > 1) {
+                const imageStartScreenRow = i - viewportTop;
+                if (imageStartScreenRow < 0 || imageStartScreenRow + imageReservedRows > height) {
+                    logRedraw(`kitty image pre-clear would scroll (${imageStartScreenRow} + ${imageReservedRows} > ${height})`);
+                    fullRender(true);
+                    return;
+                }
+                buffer += "\x1b[2K";
+                for (let row = 1; row < imageReservedRows; row++) {
+                    buffer += "\r\n\x1b[2K";
+                }
+                buffer += `\x1b[${imageReservedRows - 1}A`;
+                buffer += line;
+                buffer += `\x1b[${imageReservedRows - 1}B`;
+                i += imageReservedRows - 1;
+                continue;
+            }
+            buffer += "\x1b[2K"; // Clear current line
             if (!isImage && visibleWidth(line) > width) {
                 // Log all lines to crash file for debugging
                 const crashLogPath = path.join(os.homedir(), ".pi", "agent", "pi-crash.log");
@@ -1219,5 +1351,57 @@ export class TUI extends Container {
             this.terminal.hideCursor();
         }
     }
+    /**
+     * Query the terminal's default background color with OSC 11 (`ESC ] 11 ; ? BEL`).
+     * @param timeoutMs Query timeout in milliseconds.
+     * @returns Promise containing the parsed RGB color, or undefined if it times out or fails to parse.
+     */
+    queryTerminalBackgroundColor({ timeoutMs }) {
+        return new Promise((resolve) => {
+            const query = {
+                settled: false,
+                resolve,
+                timer: undefined,
+            };
+            query.timer = setTimeout(() => {
+                if (query.settled) {
+                    return;
+                }
+                query.settled = true;
+                query.timer = undefined;
+                query.resolve?.(undefined);
+                query.resolve = undefined;
+            }, timeoutMs);
+            this.pendingOsc11BackgroundQueries.push(query);
+            this.pendingOsc11BackgroundReplies += 1;
+            this.terminal.write("\x1b]11;?\x07");
+        });
+    }
+    /**
+     * Query the terminal's color-scheme preference with DSR (`CSI ? 996 n`).
+     * Terminals that support the color palette notification protocol reply with
+     * `CSI ? 997 ; 1 n` for dark or `CSI ? 997 ; 2 n` for light.
+     */
+    queryTerminalColorScheme({ timeoutMs }) {
+        return new Promise((resolve) => {
+            let settled = false;
+            let timer;
+            let unsubscribe = () => { };
+            const settle = (scheme) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timer) {
+                    clearTimeout(timer);
+                    timer = undefined;
+                }
+                unsubscribe();
+                resolve(scheme);
+            };
+            unsubscribe = this.onTerminalColorSchemeChange(settle);
+            timer = setTimeout(() => settle(undefined), timeoutMs);
+            this.terminal.write("\x1b[?996n");
+        });
+    }
 }
 //# sourceMappingURL=tui.js.map