Add OSC 4/10/11 color query responses (fixes #75)

libghostty parses OSC 4/10/11 sets but silently drops the query form
(`?` value) and does not expose a callback for them, so programs like
duf that auto-detect the theme via termenv get no reply.

Scan raw input in `fnWriteInput` for OSC 4/10/11 query payloads and
reply via the existing `ghostel--flush-output` path, using the
effective colors from libghostty.  The extractor runs before `vtWrite`
so the color reply is on the wire before any response libghostty
generates (e.g. the CSI 6n cursor-position reply duf sends in the
same write) — termenv reads the first chunk off stdin, so ordering
matters.

A single-pass scanner walks ESC `]` introducers in source order so
replies to multiple different-type queries in one write come back in
the same order the client wrote them.  Only fully-terminated OSC
sequences produce a reply — a query split across process-output
chunks is left for a later call.  `parseDecimal` uses
`std.fmt.parseInt` so numeric overflow is rejected instead of wrapping
into the valid palette range.

The process filter previously batched all output for the redraw timer,
which delayed the reply past duf's read timeout.  Detect color queries
in `ghostel--filter` and flush the pending buffer synchronously so the
reply is written back through the PTY before the filter returns.

Author: dakra

README.md

@@ -219,6 +219,7 @@ loaded scrollback.
 ### Terminal Emulation
 - Full VT terminal emulation via libghostty-vt
 - 256-color and RGB (24-bit true color) support
+- **OSC 4 / 10 / 11 color queries** — TUI programs can query the current palette, foreground, and background colors, so tools like `duf`, `btop`, `delta`, and anything else using `termenv` auto-detect the right light/dark theme from the Emacs face colors
 - Text attributes: bold, italic, faint, underline (single/double/curly/dotted/dashed with color), strikethrough, inverse
 - Cursor styles: block, bar, underline, hollow block
 - Alternate screen buffer (for TUI apps like htop, vim, etc.)
@@ -546,6 +547,7 @@ powering Neovim's built-in terminal.
 | Feature                       | ghostel   | vterm   |
 |-------------------------------|-----------|---------|
 | True color (24-bit)           | Yes       | Yes     |
+| OSC 4/10/11 color queries     | Yes       | No      |
 | Bold / italic / faint         | Yes       | Yes     |
 | Underline styles (5 types)    | Yes       | No      |
 | Underline color               | Yes       | No      |

ghostel.el

@@ -1882,6 +1882,14 @@ the redraw is performed immediately to minimize typing latency."
       (when ghostel--term
         ;; Accumulate output for batched write-input at redraw time.
         (push output ghostel--pending-output)
+        ;; Respond to OSC 4/10/11 color queries immediately: programs like
+        ;; `duf' read stdin with a tight timeout and give up if the reply
+        ;; waits for the redraw timer.  Flushing runs the extractor in the
+        ;; native module, which writes the reply back through the PTY
+        ;; before this filter returns.
+        (when (string-match-p
+               "\e\\]\\(?:4;[0-9]+;\\?\\|10;\\?\\|11;\\?\\)" output)
+          (ghostel--flush-pending-output))
         ;; Immediate redraw for interactive echo: small output arriving
         ;; within `ghostel-immediate-redraw-interval' of last keystroke.
         (if (and (> ghostel-immediate-redraw-threshold 0)

src/ghostty.zig

@@ -61,6 +61,8 @@ pub const OPT_COLOR_FOREGROUND = c.GHOSTTY_TERMINAL_OPT_COLOR_FOREGROUND;
 pub const OPT_COLOR_BACKGROUND = c.GHOSTTY_TERMINAL_OPT_COLOR_BACKGROUND;
 pub const OPT_COLOR_PALETTE = c.GHOSTTY_TERMINAL_OPT_COLOR_PALETTE;
 pub const DATA_COLOR_PALETTE = c.GHOSTTY_TERMINAL_DATA_COLOR_PALETTE;
+pub const DATA_COLOR_FOREGROUND = c.GHOSTTY_TERMINAL_DATA_COLOR_FOREGROUND;
+pub const DATA_COLOR_BACKGROUND = c.GHOSTTY_TERMINAL_DATA_COLOR_BACKGROUND;
 
 // Terminal data constants
 pub const DATA_COLS = c.GHOSTTY_TERMINAL_DATA_COLS;

src/module.zig

@@ -143,6 +143,14 @@ fn fnWriteInput(raw_env: ?*c.emacs_env, _: isize, args: [*c]c.emacs_value, _: ?*
     // Done here in Zig to avoid Elisp unibyte→multibyte corruption.
     const raw = data.?;
 
+    // Respond to OSC 4/10/11 color queries BEFORE feeding libghostty.
+    // libghostty will synchronously emit responses for other queries in
+    // the same write (e.g. CSI 6n cursor-position report) via the
+    // write_pty callback, and termenv-based programs read only the first
+    // response chunk — so the color reply must be on the wire first or
+    // the program discards our reply as noise.
+    extractOscColorQueries(env, term, raw);
+
     // Count bare \n to determine output size.
     var extra_cr: usize = 0;
     for (0..raw.len) |i| {
@@ -320,6 +328,150 @@ fn extractOsc133(env: emacs.Env, data: []const u8) void {
     }
 }
 
+/// Send `OSC N;rgb:RRRR/GGGG/BBBB <term>` for a dynamic color (OSC 10/11).
+fn sendDynamicColorReply(
+    env: emacs.Env,
+    osc_num: u8,
+    color: gt.ColorRgb,
+    term_bytes: []const u8,
+) void {
+    var buf: [64]u8 = undefined;
+    const written = std.fmt.bufPrint(
+        &buf,
+        "\x1b]{d};rgb:{x:0>2}{x:0>2}/{x:0>2}{x:0>2}/{x:0>2}{x:0>2}{s}",
+        .{
+            osc_num,
+            color.r, color.r,
+            color.g, color.g,
+            color.b, color.b,
+            term_bytes,
+        },
+    ) catch return;
+    _ = env.call1(emacs.sym.@"ghostel--flush-output", env.makeString(written));
+}
+
+/// Send `OSC 4;INDEX;rgb:RRRR/GGGG/BBBB <term>` for a palette entry.
+fn sendPaletteColorReply(
+    env: emacs.Env,
+    index: u16,
+    color: gt.ColorRgb,
+    term_bytes: []const u8,
+) void {
+    var buf: [64]u8 = undefined;
+    const written = std.fmt.bufPrint(
+        &buf,
+        "\x1b]4;{d};rgb:{x:0>2}{x:0>2}/{x:0>2}{x:0>2}/{x:0>2}{x:0>2}{s}",
+        .{
+            index,
+            color.r, color.r,
+            color.g, color.g,
+            color.b, color.b,
+            term_bytes,
+        },
+    ) catch return;
+    _ = env.call1(emacs.sym.@"ghostel--flush-output", env.makeString(written));
+}
+
+/// Parse a non-negative decimal integer.  Returns null on empty input,
+/// any non-digit byte, or numeric overflow of `u32`.
+fn parseDecimal(s: []const u8) ?u32 {
+    if (s.len == 0) return null;
+    return std.fmt.parseInt(u32, s, 10) catch null;
+}
+
+/// Scan data for OSC 4/10/11 color queries and emit responses in source
+/// order.  libghostty applies OSC 4/10/11 **sets** internally but silently
+/// drops the query form (`?` value), so ghostel scans the raw input and
+/// replies itself.
+///
+/// Colors come from the terminal's currently effective state, which reflects
+/// sets applied by earlier write-input calls — but NOT sets that appear
+/// earlier in *this* input buffer, because this extractor runs before
+/// `vtWrite` so the color reply is on the wire before any reply libghostty
+/// generates itself (e.g. the CSI 6n cursor-position reply some programs
+/// send in the same write).  Termenv-based readers consume the first chunk
+/// off stdin, so ordering matters more than same-chunk freshness.
+///
+/// Only fully-terminated OSC sequences produce a reply: a query split
+/// across two process-output chunks is ignored until a later call carries
+/// the terminator.
+fn extractOscColorQueries(env: emacs.Env, term: *Terminal, data: []const u8) void {
+    var palette: [256]gt.ColorRgb = undefined;
+    var palette_loaded = false;
+
+    var pos: usize = 0;
+    while (pos + 1 < data.len) {
+        // Find next OSC introducer "ESC ]".
+        const osc_rel = std.mem.indexOfPos(u8, data, pos, "\x1b]") orelse break;
+        const code_start = osc_rel + 2;
+
+        // Read the decimal OSC code up to the first ';'.
+        var code_end = code_start;
+        while (code_end < data.len and data[code_end] >= '0' and data[code_end] <= '9') {
+            code_end += 1;
+        }
+        if (code_end == code_start or code_end >= data.len or data[code_end] != ';') {
+            pos = code_start;
+            continue;
+        }
+        const payload_start = code_end + 1;
+
+        // Find the terminator (BEL or ST).  Require a real one — partial OSCs
+        // split across chunks are left for the next call so we don't reply
+        // before the client has finished writing its query.
+        var end = payload_start;
+        var term_len: usize = 0;
+        while (end < data.len) : (end += 1) {
+            if (data[end] == 0x07) {
+                term_len = 1;
+                break;
+            }
+            if (data[end] == 0x1b and end + 1 < data.len and data[end + 1] == '\\') {
+                term_len = 2;
+                break;
+            }
+        }
+        if (term_len == 0) break;
+
+        const payload = data[payload_start..end];
+        const term_bytes = data[end .. end + term_len];
+        pos = end + term_len;
+
+        const code = parseDecimal(data[code_start..code_end]) orelse continue;
+        switch (code) {
+            10 => {
+                if (!std.mem.eql(u8, payload, "?")) continue;
+                var fg: gt.ColorRgb = undefined;
+                if (!term.getColorForeground(&fg)) continue;
+                sendDynamicColorReply(env, 10, fg, term_bytes);
+            },
+            11 => {
+                if (!std.mem.eql(u8, payload, "?")) continue;
+                var bg: gt.ColorRgb = undefined;
+                if (!term.getColorBackground(&bg)) continue;
+                sendDynamicColorReply(env, 11, bg, term_bytes);
+            },
+            4 => {
+                // Payload is a ';'-separated list of `index;value` pairs.
+                // Reply only to pairs whose value is literally "?".
+                var it = std.mem.splitScalar(u8, payload, ';');
+                while (it.next()) |index_tok| {
+                    const value_tok = it.next() orelse break;
+                    if (!std.mem.eql(u8, value_tok, "?")) continue;
+                    const idx = parseDecimal(index_tok) orelse continue;
+                    if (idx >= 256) continue;
+                    if (!palette_loaded) {
+                        if (!term.getColorPalette(&palette)) break;
+                        palette_loaded = true;
+                    }
+                    sendPaletteColorReply(env, @intCast(idx), palette[idx], term_bytes);
+                }
+            },
+            else => {},
+        }
+    }
+}
+
 /// (ghostel--set-size TERM ROWS COLS)
 fn fnSetSize(raw_env: ?*c.emacs_env, _: isize, args: [*c]c.emacs_value, _: ?*anyopaque) callconv(.c) c.emacs_value {
     const env = emacs.Env.init(raw_env.?);

src/terminal.zig

@@ -160,6 +160,24 @@ pub fn getColorPalette(self: *Self, palette: *[256]gt.ColorRgb) bool {
     ) == gt.SUCCESS;
 }
 
+/// Get the effective foreground color (honouring any OSC 10 override).
+pub fn getColorForeground(self: *Self, out: *gt.ColorRgb) bool {
+    return gt.c.ghostty_terminal_get(
+        self.terminal,
+        gt.DATA_COLOR_FOREGROUND,
+        @ptrCast(out),
+    ) == gt.SUCCESS;
+}
+
+/// Get the effective background color (honouring any OSC 11 override).
+pub fn getColorBackground(self: *Self, out: *gt.ColorRgb) bool {
+    return gt.c.ghostty_terminal_get(
+        self.terminal,
+        gt.DATA_COLOR_BACKGROUND,
+        @ptrCast(out),
+    ) == gt.SUCCESS;
+}
+
 /// Feed VT data from the PTY into the terminal.
 pub fn vtWrite(self: *Self, data: []const u8) void {
     gt.c.ghostty_terminal_vt_write(self.terminal, data.ptr, data.len);

test/ghostel-test.el

@@ -717,6 +717,115 @@ Mirrors the real zsh case where the directory still contains a
       (ghostel--write-input term "\e]52;c;?\e\\")
       (should (equal nil kill-ring)))))                     ; osc52 query ignored
 
+;; -----------------------------------------------------------------------
+;; Test: OSC 4/10/11 color query responses
+;; -----------------------------------------------------------------------
+
+(ert-deftest ghostel-test-osc-color-query ()
+  "Test that OSC 4/10/11 color queries get responses."
+  (let* ((term (ghostel--new 25 80 1000))
+         (sent-bytes nil))
+    (cl-letf (((symbol-function 'ghostel--flush-output)
+               (lambda (data)
+                 (setq sent-bytes (concat sent-bytes data)))))
+
+      ;; OSC 11 background query with ST terminator.
+      (setq sent-bytes nil)
+      (ghostel--write-input term "\e]11;?\e\\")
+      (should sent-bytes)
+      (should (string-match-p "\\`\e\\]11;rgb:[0-9a-f]\\{4\\}/[0-9a-f]\\{4\\}/[0-9a-f]\\{4\\}\e\\\\\\'"
+                              sent-bytes))
+
+      ;; OSC 10 foreground query with BEL terminator.
+      (setq sent-bytes nil)
+      (ghostel--write-input term "\e]10;?\a")
+      (should sent-bytes)
+      (should (string-match-p "\\`\e\\]10;rgb:[0-9a-f]\\{4\\}/[0-9a-f]\\{4\\}/[0-9a-f]\\{4\\}\a\\'"
+                              sent-bytes))
+
+      ;; OSC 4 palette query for index 1, after a prior set.  The extractor
+      ;; runs before vtWrite inside a single write-input, so the set must
+      ;; land in a previous call for the new value to be visible.
+      (setq sent-bytes nil)
+      (ghostel--write-input term "\e]4;1;rgb:11/22/33\e\\")
+      (should (equal nil sent-bytes))                   ; set: no reply
+      (ghostel--write-input term "\e]4;1;?\e\\")
+      (should (equal "\e]4;1;rgb:1111/2222/3333\e\\" sent-bytes))
+
+      ;; OSC 10 with a set value (not a query) — no response.
+      (setq sent-bytes nil)
+      (ghostel--write-input term "\e]10;rgb:aa/bb/cc\e\\")
+      (should (equal nil sent-bytes))
+
+      ;; OSC 4 set (not a query) — no response.
+      (setq sent-bytes nil)
+      (ghostel--write-input term "\e]4;2;rgb:44/55/66\e\\")
+      (should (equal nil sent-bytes))
+
+      ;; Malformed OSC 4 payloads — don't crash, don't reply.
+      (setq sent-bytes nil)
+      (ghostel--write-input term "\e]4;\e\\")           ; empty
+      (ghostel--write-input term "\e]4;xyz;?\e\\")     ; non-numeric index
+      (ghostel--write-input term "\e]4;999;?\e\\")     ; index out of range
+      (ghostel--write-input term "\e]4;0\e\\")         ; index without value
+      (ghostel--write-input term "\e]4;99999999999999999999;?\e\\") ; overflow
+      (should (equal nil sent-bytes))
+
+      ;; Multiple different-type queries in one write must reply in source
+      ;; order so termenv-style readers can match by position.
+      (setq sent-bytes nil)
+      (ghostel--write-input term "\e]11;?\e\\\e]10;?\e\\")
+      (should (string-match-p "\\`\e\\]11;rgb:.*?\e\\\\\e\\]10;rgb:.*?\e\\\\\\'"
+                              sent-bytes))
+
+      ;; Multi-pair OSC 4 with mixed set+query: the extractor runs before
+      ;; vtWrite, so the set is not yet visible to the query in the same
+      ;; payload — but the index=1 value seeded in the earlier write
+      ;; above is still there, and both indices get replied to in order.
+      (setq sent-bytes nil)
+      (ghostel--write-input term "\e]4;1;?;3;?\e\\")
+      (should (string-match-p
+               "\\`\e\\]4;1;rgb:1111/2222/3333\e\\\\\e\\]4;3;rgb:.*?\e\\\\\\'"
+               sent-bytes))
+
+      ;; Unterminated OSC query — reply is withheld until the terminator
+      ;; arrives.  (We don't buffer across write-input calls, so the
+      ;; terminator must be in the same call to get a reply.)
+      (setq sent-bytes nil)
+      (ghostel--write-input term "\e]11;?")
+      (should (equal nil sent-bytes)))))
+
+(ert-deftest ghostel-test-osc-color-query-filter-flush ()
+  "The process filter must flush synchronously on a color query.
+Programs like `duf' read stdin with a short timeout and give up if
+the reply waits for the redraw timer."
+  (let ((buf (generate-new-buffer " *ghostel-osc-flush*"))
+        (fake-proc (make-symbol "fake-proc"))
+        (sent nil))
+    (unwind-protect
+        (with-current-buffer buf
+          (setq ghostel--term (ghostel--new 25 80 1000))
+          (setq ghostel--process fake-proc)
+          (cl-letf (((symbol-function 'process-buffer) (lambda (_) buf))
+                    ((symbol-function 'process-live-p) (lambda (_) t))
+                    ((symbol-function 'ghostel--flush-output)
+                     (lambda (data) (setq sent (concat sent data))))
+                    ((symbol-function 'ghostel--invalidate) #'ignore))
+            ;; OSC 11 query arrives — reply must be produced before
+            ;; `ghostel--filter' returns, not on a later timer tick.
+            (ghostel--filter fake-proc "\e]11;?\e\\")
+            (should sent)
+            (should (string-match-p "\\`\e\\]11;rgb:" sent))
+            (should (equal nil ghostel--pending-output))
+
+            ;; A non-query OSC 11 set must NOT trigger the sync flush,
+            ;; so the data stays pending for the redraw timer.
+            (setq sent nil)
+            (ghostel--filter fake-proc "\e]11;rgb:11/22/33\e\\")
+            (should (equal nil sent))
+            (should ghostel--pending-output)))
+      (kill-buffer buf))))
+
 ;; -----------------------------------------------------------------------
 ;; Test: focus events gated by mode 1004
 ;; -----------------------------------------------------------------------