@tuidom/terminal-backend 0.6.1 → 0.7.0

package/dist/nodeTerminalBackend.d.ts

@@ -1,4 +1,4 @@
-import type { ITerminalBackend } from "@tuidom/core/backend/iTerminalBackend";
+import type { HostTerminalColors, ITerminalBackend } from "@tuidom/core/backend/iTerminalBackend";
 import { Point, Size } from "@tuidom/core/common/geometryPromitives";
 import type { KeyPressEvent } from "@tuidom/core/input/keyEvent";
 import type { MouseToken } from "@tuidom/core/input/rawTerminalToken";
@@ -30,6 +30,7 @@ export declare class NodeTerminalBackend implements ITerminalBackend {
     private resizePending;
     private cleanupHandlers;
     private readonly isTmux;
+    private readonly isGnuScreen;
     private readonly inputParser;
     private readonly renderer;
     /**
@@ -73,11 +74,13 @@ export declare class NodeTerminalBackend implements ITerminalBackend {
     onOscResponse(callback: (code: number, data: string) => void): void;
     probeKeyboardProtocol(onResult: (supported: boolean) => void): void;
     probeTerminalVersion(onResult: (nameAndVersion: string | undefined) => void): void;
+    probeHostColors(onResult: (colors: HostTerminalColors) => void): void;
     /**
      * Send `query` followed by DA1 and collect device reports until *our* DA1 reply
      * arrives (or the timeout fires), then call `finish` exactly once. Replies come back
      * in request order, so the n-th DA1 reply closes the n-th probe — two probes in
-     * flight don't settle each other early.
+     * flight don't settle each other early. `untilDa1: false` leaves only the timeout
+     * (and the returned early-settle function) to close the probe.
      */
     private probe;
     /** Fan a parsed input batch out to the registered callbacks. */

package/dist/nodeTerminalBackend.js

@@ -1,9 +1,10 @@
+import { parseXColor } from "@tuidom/core/common/colorUtils";
 import { Point, Size } from "@tuidom/core/common/geometryPromitives";
 import { KeyInputParser } from "@tuidom/core/input/keyInputParser";
 import { MOUSE_TRACKING_ALL_ENABLE, MOUSE_TRACKING_DISABLE } from "@tuidom/core/input/mouseTracking";
 import { Grid } from "@tuidom/core/rendering/grid";
 import { TerminalRenderer } from "@tuidom/core/rendering/terminalRenderer";
-import { isInsideTmux } from "./terminalEnv.js";
+import { isInsideGnuScreen, isInsideTmux } from "./terminalEnv.js";
 /**
  * Kitty Keyboard Protocol escape sequences.
  *
@@ -52,6 +53,23 @@ const PROBE_TIMEOUT_MS = 200;
  * silent on the first query but always answer DA1.
  */
 const XTVERSION_QUERY = "\x1b[>0q";
+/** How many ANSI palette entries the host-colors probe asks for (0..15). */
+const ANSI_COLOR_COUNT = 16;
+/**
+ * Host-colors probe: default fg/bg (OSC 10/11) and the 16 ANSI entries (OSC 4), each
+ * entry its own query — Konsole answers only the first index of a multi-index OSC 4,
+ * and tmux drops a palette reply for an index it didn't expect. ST-terminated; replies
+ * may end with BEL or ST either way (the tokenizer takes both).
+ */
+const HOST_COLORS_QUERY = "\x1b]10;?\x1b\\\x1b]11;?\x1b\\" +
+    Array.from({ length: ANSI_COLOR_COUNT }, (_, index) => `\x1b]4;${String(index)};?\x1b\\`).join("");
+/**
+ * Inside tmux DA1 is no sentinel for the host-colors probe: tmux answers DA1 at once,
+ * but a palette entry it hasn't set itself it forwards to the outer terminal and relays
+ * the reply later (tmux ≥ 3.6; its own wait is 500 ms). There we settle on the last
+ * expected reply or on this timeout.
+ */
+const TMUX_HOST_COLORS_TIMEOUT_MS = 600;
 /**
  * How long to hold a partial escape sequence that arrived at the end of a stdin read,
  * waiting for the rest to follow (it does, on a split keypress over SSH/tmux). If nothing
@@ -75,6 +93,25 @@ function wrapForTmux(sequence) {
     const escaped = sequence.replace(/\x1b/g, "\x1b\x1b");
     return `\x1bPtmux;${escaped}\x1b\\`;
 }
+/**
+ * A reply to the host-colors probe: `OSC 10;<color>` / `OSC 11;<color>` (fg/bg) or
+ * `OSC 4;<index>;<color>` for one of the 16 ANSI entries. Anything else (OSC 52, a
+ * palette index past 15, an unparsable color) is `undefined` — not ours to count.
+ */
+function parseHostColorReply(code, data) {
+    if (code === 10 || code === 11) {
+        const color = parseXColor(data);
+        return color === undefined ? undefined : { slot: code === 10 ? "foreground" : "background", color };
+    }
+    if (code !== 4)
+        return undefined;
+    const match = /^(\d+);(.*)$/.exec(data);
+    if (match === null)
+        return undefined;
+    const index = Number(match[1]);
+    const color = parseXColor(match[2]);
+    return index < ANSI_COLOR_COUNT && color !== undefined ? { slot: index, color } : undefined;
+}
 /**
  * Real terminal backend: reads from process.stdin, writes to process.stdout.
  * Handles alternate screen, raw mode, cursor visibility, signal cleanup.
@@ -102,6 +139,7 @@ export class NodeTerminalBackend {
     resizePending = false;
     cleanupHandlers = [];
     isTmux;
+    isGnuScreen;
     inputParser = new KeyInputParser();
     renderer;
     /**
@@ -117,6 +155,7 @@ export class NodeTerminalBackend {
         this.stdout = stdout;
         this.resizeThrottleMs = options?.resizeThrottleMs ?? 100;
         this.isTmux = isInsideTmux();
+        this.isGnuScreen = isInsideGnuScreen();
         this.renderer = new TerminalRenderer(this.frameBuffer);
     }
     /**
@@ -183,13 +222,53 @@ export class NodeTerminalBackend {
             onResult(nameAndVersion);
         });
     }
+    probeHostColors(onResult) {
+        const ansi = new Array(ANSI_COLOR_COUNT).fill(undefined);
+        let foreground;
+        let background;
+        const finish = () => {
+            onResult({ foreground, background, ansi });
+        };
+        // GNU Screen doesn't answer color queries and doesn't pass them on — don't send them.
+        if (this.isGnuScreen) {
+            finish();
+            return;
+        }
+        let settled = false;
+        // Distinct slots: a repeated reply for the same entry doesn't bring the end closer.
+        const reported = new Set();
+        // Direct, like the other probes: inside tmux it's tmux that answers for its pane.
+        const settle = this.probe(HOST_COLORS_QUERY, () => {
+            /* only OSC replies matter here */
+        }, () => {
+            settled = true;
+            finish();
+        }, this.isTmux ? { untilDa1: false, timeoutMs: TMUX_HOST_COLORS_TIMEOUT_MS } : undefined);
+        this.oscResponseCallbacks.push((code, data) => {
+            if (settled)
+                return;
+            const reply = parseHostColorReply(code, data);
+            if (reply === undefined)
+                return;
+            if (reply.slot === "foreground")
+                foreground = reply.color;
+            else if (reply.slot === "background")
+                background = reply.color;
+            else
+                ansi[reply.slot] = reply.color;
+            reported.add(reply.slot);
+            if (reported.size === 2 + ANSI_COLOR_COUNT)
+                settle();
+        });
+    }
     /**
      * Send `query` followed by DA1 and collect device reports until *our* DA1 reply
      * arrives (or the timeout fires), then call `finish` exactly once. Replies come back
      * in request order, so the n-th DA1 reply closes the n-th probe — two probes in
-     * flight don't settle each other early.
+     * flight don't settle each other early. `untilDa1: false` leaves only the timeout
+     * (and the returned early-settle function) to close the probe.
      */
-    probe(query, onReport, finish) {
+    probe(query, onReport, finish, options = { untilDa1: true, timeoutMs: PROBE_TIMEOUT_MS }) {
         const myDa1 = ++this.da1Sent;
         let settled = false;
         let timer = null;
@@ -206,11 +285,12 @@ export class NodeTerminalBackend {
                 return;
             if (report !== "da1")
                 onReport(report, params);
-            else if (this.da1Received >= myDa1)
+            else if (options.untilDa1 && this.da1Received >= myDa1)
                 settle(); // our DA1 reply = all replies are in
         });
         this.writeDirect(query + DA1_QUERY);
-        timer = setTimeout(settle, PROBE_TIMEOUT_MS);
+        timer = setTimeout(settle, options.timeoutMs);
+        return settle;
     }
     /** Fan a parsed input batch out to the registered callbacks. */
     dispatchInput(result) {

package/dist/terminalEnv.d.ts

@@ -5,5 +5,10 @@
  */
 /** True when running inside a TMUX session. */
 export declare function isInsideTmux(env?: NodeJS.ProcessEnv): boolean;
+/**
+ * True when the nearest multiplexer is GNU Screen (`STY` set, no tmux in between):
+ * it neither answers color queries nor passes them on.
+ */
+export declare function isInsideGnuScreen(env?: NodeJS.ProcessEnv): boolean;
 /** True when the session is reached over SSH. */
 export declare function isSsh(env?: NodeJS.ProcessEnv): boolean;

package/dist/terminalEnv.js

@@ -7,6 +7,13 @@
 export function isInsideTmux(env = process.env) {
     return env.TMUX != null && env.TMUX !== "";
 }
+/**
+ * True when the nearest multiplexer is GNU Screen (`STY` set, no tmux in between):
+ * it neither answers color queries nor passes them on.
+ */
+export function isInsideGnuScreen(env = process.env) {
+    return env.STY != null && env.STY !== "" && !isInsideTmux(env);
+}
 /** True when the session is reached over SSH. */
 export function isSsh(env = process.env) {
     return (env.SSH_CONNECTION != null && env.SSH_CONNECTION !== "") || (env.SSH_TTY != null && env.SSH_TTY !== "");

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@tuidom/terminal-backend",
-    "version": "0.6.1",
+    "version": "0.7.0",
     "type": "module",
     "description": "Experimental terminal UI DOM — real terminal backend for Node (tty, ANSI diffing, Kitty protocol). API is unstable.",
     "license": "MIT",
@@ -28,6 +28,6 @@
         "./*": "./dist/*.js"
     },
     "dependencies": {
-        "@tuidom/core": "0.6.1"
+        "@tuidom/core": "0.7.0"
     }
 }