fix(cli): adopt DA1 sandwich technique for robust OSC color query detection

Replace ad-hoc environment checks (CI, Warp, tmux, Docker) with a
comprehensive `is_osc_query_unsupported()` pre-screen modelled after
`terminal-colorsaurus`, and implement the DA1 sandwich technique to
detect unsupported terminals at runtime without waiting for timeouts.

Key changes:
- Centralized quirks detection covering CI, Docker, devcontainers,
  Kubernetes, Emacs, GNU Screen, Eterm, tmux, and TERM=dumb
- DA1 sentinel query appended after OSC queries; if its response
  arrives first the terminal doesn't support OSC and we bail immediately
- drain_da1() consumes the trailing DA1 response to prevent leaks
- BEL terminator instead of ST to work around urxvt response bug
- SSH-aware timeout (1000ms vs 200ms local)
- Ported regression test from terminal-colorsaurus issue #38
- Extended test coverage for parsing edge cases

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Brooooooklyn

crates/vite_shared/src/header.rs

@@ -4,6 +4,7 @@
 //! - Colorization and truecolor capability gates
 //! - Foreground color OSC query (`ESC ] 10 ; ? ESC \\`) with timeout
 //! - ANSI palette queries for blue/magenta with timeout
+//! - DA1 sandwich technique to detect unsupported terminals
 //! - Gradient/fade generation and RGB ANSI coloring
 
 use std::{
@@ -179,6 +180,79 @@ fn parse_osc4_rgb(buffer: &str, index: u8) -> Option<Rgb> {
     parse_rgb_triplet(&tail[rgb_start + 4..])
 }
 
+/// Returns `true` if the terminal is known to not support OSC color queries
+/// or if the environment is unreliable for escape-sequence round-trips.
+///
+/// Modelled after `terminal-colorsaurus`'s quirks detection, extended with
+/// additional checks for Docker, CI, devcontainers, and other environments.
+#[cfg(unix)]
+fn is_osc_query_unsupported() -> bool {
+    static UNSUPPORTED: OnceLock<bool> = OnceLock::new();
+    *UNSUPPORTED.get_or_init(|| {
+        if !std::io::stdout().is_terminal() || !std::io::stdin().is_terminal() {
+            return true;
+        }
+
+        // CI environments have no real terminal emulator behind the PTY.
+        if std::env::var_os("CI").is_some() || std::env::var_os("GITHUB_ACTIONS").is_some() {
+            return true;
+        }
+
+        // Warp terminal does not respond to OSC color queries in its
+        // block-mode renderer, causing a hang until the user presses a key.
+        if is_warp_terminal() {
+            return true;
+        }
+
+        // Emacs terminal emulators (ansi-term, vterm, eshell) don't support
+        // OSC queries.
+        if std::env::var_os("INSIDE_EMACS").is_some() {
+            return true;
+        }
+
+        // Docker containers and devcontainers may have a PTY with no real
+        // terminal emulator, causing OSC responses to leak as visible text.
+        if std::path::Path::new("/.dockerenv").exists()
+            || std::env::var_os("REMOTE_CONTAINERS").is_some()
+            || std::env::var_os("CODESPACES").is_some()
+            || std::env::var_os("KUBERNETES_SERVICE_HOST").is_some()
+        {
+            return true;
+        }
+
+        match std::env::var("TERM") {
+            // Missing or non-unicode TERM is highly suspect.
+            Err(_) => return true,
+            // `TERM=dumb` indicates a minimal terminal with no escape support.
+            Ok(term) if term == "dumb" => return true,
+            // GNU Screen responds to OSC queries in the wrong order, breaking
+            // the DA1 sandwich technique. It also only supports OSC 11, not
+            // OSC 10 or OSC 4.
+            Ok(term) if term == "screen" || term.starts_with("screen.") => return true,
+            // Eterm doesn't support DA1, so we skip to avoid the timeout.
+            Ok(term) if term == "Eterm" => return true,
+            _ => {}
+        }
+
+        // tmux and GNU Screen (via STY) do not reliably forward OSC color
+        // query responses back to the child process.
+        if std::env::var_os("TMUX").is_some() || std::env::var_os("STY").is_some() {
+            return true;
+        }
+
+        false
+    })
+}
+
+/// DA1 (Primary Device Attributes) query — supported by virtually all
+/// terminals. Used as a sentinel in the "DA1 sandwich" technique:
+/// we send our OSC queries followed by DA1, then read responses. If the
+/// DA1 response (`ESC [ ? ...`) arrives first, the terminal doesn't
+/// support OSC queries and we bail out immediately instead of waiting
+/// for a timeout.
+#[cfg(unix)]
+const DA1: &str = "\x1b[c";
+
 #[cfg(unix)]
 fn query_terminal_colors(palette_indices: &[u8]) -> (Option<Rgb>, Vec<(u8, Rgb)>) {
     use std::{
@@ -192,20 +266,7 @@ fn query_terminal_colors(palette_indices: &[u8]) -> (Option<Rgb>, Vec<(u8, Rgb)>
         unistd::read,
     };
 
-    if std::env::var_os("CI").is_some() {
-        return (None, vec![]);
-    }
-
-    // Warp terminal does not respond to OSC color queries in its block-mode
-    // renderer. Sending the queries causes the process to appear stuck until
-    // the user presses a key (which is consumed as a fake "response").
-    if is_warp_terminal() {
-        return (None, vec![]);
-    }
-
-    // tmux does not reliably forward OSC color query responses back to the
-    // child process, causing the same hang-until-keypress behavior as Warp.
-    if std::env::var_os("TMUX").is_some() {
+    if is_osc_query_unsupported() {
         return (None, vec![]);
     }
 
@@ -214,10 +275,6 @@ fn query_terminal_colors(palette_indices: &[u8]) -> (Option<Rgb>, Vec<(u8, Rgb)>
         Err(_) => return (None, vec![]),
     };
 
-    if !std::io::stdout().is_terminal() {
-        return (None, vec![]);
-    }
-
     struct RawGuard {
         fd: RawFd,
         original: Termios,
@@ -242,21 +299,39 @@ fn query_terminal_colors(palette_indices: &[u8]) -> (Option<Rgb>, Vec<(u8, Rgb)>
     }
     let _guard = RawGuard { fd: tty.as_raw_fd(), original };
 
-    let mut query = format!("{ESC}]10;?{ESC}\\");
+    // Build the query: OSC 10 (foreground) + OSC 4 (palette) + DA1 (sentinel).
+    // BEL (\x07) is used as string terminator instead of ST (\x1b\\) because
+    // urxvt has a bug where it terminates responses with bare ESC instead of
+    // ST, causing a parse hang. BEL-terminated queries produce BEL-terminated
+    // responses, avoiding this issue.
+    let mut query = format!("{ESC}]10;?\x07");
     for index in palette_indices {
-        query.push_str(&format!("{ESC}]4;{index};?{ESC}\\"));
+        query.push_str(&format!("{ESC}]4;{index};?\x07"));
     }
+    // DA1 sentinel — its response acts as a fence to detect unsupported
+    // terminals.
+    query.push_str(DA1);
+
     if tty.write_all(query.as_bytes()).is_err() {
         return (None, vec![]);
     }
     if tty.flush().is_err() {
         return (None, vec![]);
     }
 
-    let deadline = Instant::now() + Duration::from_millis(100);
+    // Use a longer timeout for SSH to account for round-trip latency.
+    let timeout_ms =
+        if std::env::var_os("SSH_CONNECTION").is_some() || std::env::var_os("SSH_TTY").is_some() {
+            1000
+        } else {
+            200
+        };
+
+    let deadline = Instant::now() + Duration::from_millis(timeout_ms);
     let mut last_data = Instant::now();
     let mut buffer = String::new();
     let mut foreground = None;
+    let mut da1_arrived_first = false;
     let mut palette_colors: Vec<(u8, Option<Rgb>)> =
         palette_indices.iter().copied().map(|index| (index, None)).collect();
 
@@ -296,6 +371,10 @@ fn query_terminal_colors(palette_indices: &[u8]) -> (Option<Rgb>, Vec<(u8, Rgb)>
             buffer = buffer[keep_from..].to_string();
         }
 
+        // Try to parse OSC responses before checking for DA1. On fast
+        // terminals all responses (OSC + DA1) may arrive in a single read,
+        // so we must extract OSC data first to avoid a false "DA1 arrived
+        // first" conclusion.
         if foreground.is_none() {
             foreground = parse_osc10_rgb(&buffer);
         }
@@ -305,18 +384,73 @@ fn query_terminal_colors(palette_indices: &[u8]) -> (Option<Rgb>, Vec<(u8, Rgb)>
             }
         }
 
+        // DA1 response starts with `ESC [ ?`. If it arrives before any OSC
+        // response, the terminal doesn't support OSC queries — bail out
+        // immediately instead of waiting for the full timeout.
+        if foreground.is_none() && buffer.contains("\x1b[?") {
+            da1_arrived_first = true;
+            break;
+        }
+
         if foreground.is_some() && palette_colors.iter().all(|(_, color)| color.is_some()) {
+            // All expected responses received. Drain the trailing DA1
+            // response so it doesn't leak into the user's input buffer.
+            drain_da1(&tty, &deadline);
             break;
         }
     }
 
+    if da1_arrived_first {
+        return (None, vec![]);
+    }
+
     let resolved = palette_colors
         .into_iter()
         .filter_map(|(index, color)| color.map(|rgb| (index, rgb)))
         .collect();
     (foreground, resolved)
 }
 
+/// Consume the trailing DA1 response (`ESC [ ? ... c`) so it doesn't leak
+/// as visible text after raw mode is restored.
+#[cfg(unix)]
+fn drain_da1(tty: &std::fs::File, deadline: &Instant) {
+    use std::os::fd::AsFd;
+
+    use nix::{
+        poll::{PollFd, PollFlags, PollTimeout, poll},
+        unistd::read,
+    };
+
+    while Instant::now() < *deadline {
+        let remaining = deadline.saturating_duration_since(Instant::now());
+        let wait = remaining.min(Duration::from_millis(20));
+
+        let mut fds = [PollFd::new(tty.as_fd(), PollFlags::POLLIN)];
+        let timeout = match PollTimeout::try_from(wait) {
+            Ok(value) => value,
+            Err(_) => break,
+        };
+        let ready = match poll(&mut fds, timeout) {
+            Ok(value) => value,
+            Err(_) => break,
+        };
+        if ready == 0 {
+            break;
+        }
+
+        let mut chunk = [0_u8; 64];
+        let n = match read(tty.as_fd(), &mut chunk) {
+            Ok(value) => value,
+            Err(_) => break,
+        };
+        // DA1 response ends with 'c'. Once we see it, we're done.
+        if chunk[..n].contains(&b'c') {
+            break;
+        }
+    }
+}
+
 #[cfg(not(unix))]
 fn query_terminal_colors(_palette_indices: &[u8]) -> (Option<Rgb>, Vec<(u8, Rgb)>) {
     (None, vec![])
@@ -376,7 +510,10 @@ pub fn vite_plus_header() -> String {
 
 #[cfg(all(test, unix))]
 mod tests {
-    use super::{Rgb, gradient_eased, parse_osc4_rgb, parse_osc10_rgb, to_8bit};
+    use super::{
+        Rgb, gradient_eased, parse_osc4_rgb, parse_osc10_rgb, parse_rgb_triplet,
+        query_terminal_colors, to_8bit,
+    };
 
     #[test]
     fn to_8bit_matches_js_rules() {
@@ -387,21 +524,137 @@ mod tests {
         assert_eq!(to_8bit("fff"), Some(255));
     }
 
+    #[test]
+    fn to_8bit_single_digit() {
+        assert_eq!(to_8bit("f"), Some(255));
+        assert_eq!(to_8bit("0"), Some(0));
+        assert_eq!(to_8bit("a"), Some(170));
+    }
+
+    #[test]
+    fn to_8bit_three_digit() {
+        assert_eq!(to_8bit("fff"), Some(255));
+        assert_eq!(to_8bit("000"), Some(0));
+        assert_eq!(to_8bit("800"), Some(128));
+    }
+
+    #[test]
+    fn to_8bit_empty_returns_none() {
+        assert_eq!(to_8bit(""), None);
+    }
+
+    #[test]
+    fn to_8bit_invalid_hex_returns_none() {
+        assert_eq!(to_8bit("zz"), None);
+        assert_eq!(to_8bit("gg"), None);
+    }
+
+    #[test]
+    fn parse_rgb_triplet_standard() {
+        assert_eq!(parse_rgb_triplet("ff/ff/ff"), Some(Rgb(255, 255, 255)));
+        assert_eq!(parse_rgb_triplet("00/00/00"), Some(Rgb(0, 0, 0)));
+    }
+
+    #[test]
+    fn parse_rgb_triplet_four_digit_channels() {
+        assert_eq!(parse_rgb_triplet("ffff/ffff/ffff"), Some(Rgb(255, 255, 255)));
+        assert_eq!(parse_rgb_triplet("0000/0000/0000"), Some(Rgb(0, 0, 0)));
+        assert_eq!(parse_rgb_triplet("aaaa/bbbb/cccc"), Some(Rgb(170, 187, 204)));
+    }
+
+    #[test]
+    fn parse_rgb_triplet_mixed_digit_channels() {
+        // Single digit channels
+        assert_eq!(parse_rgb_triplet("f/e/d"), Some(Rgb(255, 238, 221)));
+    }
+
+    #[test]
+    fn parse_rgb_triplet_trailing_junk_ignored() {
+        // The parser stops at non-hex chars for the blue channel
+        assert_eq!(parse_rgb_triplet("ff/ff/ff\x1b\\"), Some(Rgb(255, 255, 255)));
+    }
+
+    #[test]
+    fn parse_rgb_triplet_missing_channel_returns_none() {
+        assert_eq!(parse_rgb_triplet("ff/ff"), None);
+        assert_eq!(parse_rgb_triplet("ff"), None);
+    }
+
     #[test]
     fn parse_osc10_response_extracts_rgb() {
         let response = "\x1b]10;rgb:aaaa/bbbb/cccc\x1b\\";
         assert_eq!(parse_osc10_rgb(response), Some(Rgb(170, 187, 204)));
     }
 
+    #[test]
+    fn parse_osc10_bel_terminated() {
+        let response = "\x1b]10;rgb:aaaa/bbbb/cccc\x07";
+        assert_eq!(parse_osc10_rgb(response), Some(Rgb(170, 187, 204)));
+    }
+
+    #[test]
+    fn parse_osc10_no_match_returns_none() {
+        assert_eq!(parse_osc10_rgb("garbage"), None);
+        assert_eq!(parse_osc10_rgb(""), None);
+    }
+
     #[test]
     fn parse_osc4_response_extracts_rgb() {
         let response = "\x1b]4;5;rgb:aaaa/bbbb/cccc\x1b\\";
         assert_eq!(parse_osc4_rgb(response, 5), Some(Rgb(170, 187, 204)));
     }
 
+    #[test]
+    fn parse_osc4_bel_terminated() {
+        let response = "\x1b]4;4;rgb:5858/9292/ffff\x07";
+        assert_eq!(parse_osc4_rgb(response, 4), Some(Rgb(88, 146, 255)));
+    }
+
+    #[test]
+    fn parse_osc4_wrong_index_returns_none() {
+        let response = "\x1b]4;5;rgb:aaaa/bbbb/cccc\x1b\\";
+        assert_eq!(parse_osc4_rgb(response, 4), None);
+    }
+
+    #[test]
+    fn parse_osc4_no_match_returns_none() {
+        assert_eq!(parse_osc4_rgb("garbage", 5), None);
+        assert_eq!(parse_osc4_rgb("", 0), None);
+    }
+
+    #[test]
+    fn parse_osc_multiple_responses_in_buffer() {
+        // Simulates a buffer containing OSC 10 + OSC 4;4 + OSC 4;5 responses
+        let buffer = "\x1b]10;rgb:d0d0/d0d0/d0d0\x07\
+                       \x1b]4;4;rgb:5858/9292/ffff\x07\
+                       \x1b]4;5;rgb:bbbb/7474/f7f7\x07";
+        assert_eq!(parse_osc10_rgb(buffer), Some(Rgb(208, 208, 208)));
+        assert_eq!(parse_osc4_rgb(buffer, 4), Some(Rgb(88, 146, 255)));
+        assert_eq!(parse_osc4_rgb(buffer, 5), Some(Rgb(187, 116, 247)));
+    }
+
+    #[test]
+    fn parse_osc_buffer_with_da1_response() {
+        // DA1 response mixed in — OSC parsers should still find their data
+        let buffer = "\x1b]10;rgb:d0d0/d0d0/d0d0\x07\x1b[?64;1;2;4c";
+        assert_eq!(parse_osc10_rgb(buffer), Some(Rgb(208, 208, 208)));
+    }
+
     #[test]
     fn gradient_counts_match() {
         assert_eq!(gradient_eased(0, Rgb(0, 0, 0), Rgb(255, 255, 255), 1.0).len(), 1);
         assert_eq!(gradient_eased(5, Rgb(10, 20, 30), Rgb(40, 50, 60), 1.0).len(), 5);
     }
+
+    /// Regression test ported from terminal-colorsaurus (issue #38).
+    /// In CI there is no real terminal, so `query_terminal_colors` must
+    /// return `(None, vec![])` without hanging.
+    #[test]
+    fn query_terminal_colors_does_not_hang() {
+        let (fg, palette) = query_terminal_colors(&[4, 5]);
+        // In CI, the environment pre-screening or DA1 sandwich will cause an
+        // early return. We don't assert specific values — just that it
+        // completes promptly and doesn't panic.
+        let _ = (fg, palette);
+    }
 }