fix(iterm): add fallback check for "ReportCellSize"

As a indicator if iterm image protocol is supported.

Author: hasezoey

CHANGELOG.md

@@ -3,7 +3,7 @@
 - Remove `lazy_static` dependency in favor of `std::sync::LazyLock`
 - MSRV is now 1.80
 - Use sixel if found in device attributes instead of static TERM list
-- Detect iterm2 protocol support by querying capabilities
+- Detect iterm2 protocol support by querying `1337;Capabilities` or `1337;ReportCellSize`
 
 ## 0.9.2
 - Use iterm and sixel in more terminals

src/printer/iterm.rs

@@ -32,6 +32,8 @@ impl Printer for iTermPrinter {
         img: &DynamicImage,
         config: &Config,
     ) -> ViuResult<(u32, u32)> {
+        // DEBUG: REMOVE THIS BEFORE MERGE
+        eprintln!("using iterm");
         let (width, height) = img.dimensions();
 
         // Transform the dynamic image to a PNG which can be given directly to iTerm
@@ -96,7 +98,7 @@ const ITERM_CAP_REPLY_SIZE: usize = "1337;Capabilities=".len();
 /// Check if the terminal supports "iterm2 inline image protocol" by querying capabilities.
 ///
 /// This function is based on what is written in <https://iterm2.com/feature-reporting/> and <https://gitlab.com/gnachman/iterm2/-/issues/10236>.
-fn has_iterm_support(stdout: &mut impl Write, stdin: &impl ReadKey) -> ViuResult {
+fn has_iterm_support_capabilities(stdout: &mut impl Write, stdin: &impl ReadKey) -> ViuResult {
     // send the query
     write!(
         stdout,
@@ -124,10 +126,10 @@ fn has_iterm_support(stdout: &mut impl Write, stdin: &impl ReadKey) -> ViuResult
     }
 
     // DEBUG: REMOVE THIS BEFORE MERGE
-    eprintln!("Iterm2 Response: {:#?}", response);
+    eprintln!("Iterm2 Response Capabilities: {:#?}", response);
 
     // no response to the "Capabilities" query, or pre-maturely ended without the DSR
-    if response.last() != Some(&end_seq) || response.len() < ITERM_CAP_REPLY_SIZE + 1/* BEL */ + 1
+    if response.last() != Some(&end_seq) || response.len() < ITERM_CAP_REPLY_SIZE + 1/* ST */ + 1
     /* END SEQ */
     {
         return Err(ViuError::ItermResponse(response));
@@ -148,11 +150,85 @@ fn has_iterm_support(stdout: &mut impl Write, stdin: &impl ReadKey) -> ViuResult
     Err(ViuError::ItermResponse(response))
 }
 
+const ITERM_CELL_REPLY_SIZE: usize = "1337;ReportCellSize=".len();
+
+/// Check if the terminal liekly supports "iterm2 inline image protocol" by querying ReportCellSize.
+///
+/// This function is based on what is written in <https://iterm2.com/documentation-escape-codes.html#report-cell-size> and <https://github.com/atanunq/viuer/pull/88>.
+fn has_iterm_support_reportcellsize(stdout: &mut impl Write, stdin: &impl ReadKey) -> ViuResult {
+    // send the query
+    write!(
+        stdout,
+        // Query iterm2 ReportCellSize https://iterm2.com/documentation-escape-codes.html#report-cell-size
+        "\x1b]1337;ReportCellSize\x1b\\"
+    )?;
+    // send extra "Device Status Report (DSR)" which practically all terminals respond to, to avoid infinitely blocking if not replied to the query above
+    // see https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h3-Functions-using-CSI-_-ordered-by-the-final-character_s_
+    write!(stdout, "\x1b[5n")?;
+
+    stdout.flush()?;
+
+    let mut response = Vec::new();
+
+    let end_seq = Key::UnknownEscSeq(vec!['[', '0', 'n']);
+
+    while let Ok(key) = stdin.read_key() {
+        // The response will end with the reply to "\x1b[5n", which is "\x1b[0n"
+        // Also, break if the Unknown key is found, which is returned when we're not in a tty
+        let should_break = key == end_seq || key == Key::Unknown;
+        response.push(key);
+        if should_break {
+            break;
+        }
+    }
+
+    // DEBUG: REMOVE THIS BEFORE MERGE
+    eprintln!("Iterm2 Response ReportCellSize: {:#?}", response);
+
+    // no response to the "Capabilities" query, or pre-maturely ended without the DSR
+    if response.last() != Some(&end_seq) || response.len() < ITERM_CELL_REPLY_SIZE + 1/* ST */ + 1
+    /* END SEQ */
+    {
+        return Err(ViuError::ItermResponse(response));
+    }
+
+    // Check if the response we got actually contains the correct response (we only check the echo name)
+    const EXPECTED_RESPONSE: &str = "ReportCellSize";
+
+    let mut chars = EXPECTED_RESPONSE.chars().peekable();
+    let mut consumed: usize = 0;
+
+    // Check each key in the response and try to exhaust the "chars" iter, which will indicate the full response is available
+    for key in &response {
+        if chars.peek().map(|v| Key::Char(*v)).as_ref() == Some(key) {
+            let _ = chars.next();
+            consumed += 1;
+        } else if consumed != 0 {
+            // we hit something not in the correct sequence, so we break here
+            // for example we hit "ReportVariable" where we want to stop at "V" instead of trying to continue
+            break;
+        }
+    }
+
+    if chars.next().is_none() {
+        return Ok(());
+    }
+
+    Err(ViuError::ItermResponse(response))
+}
+
 /// Check if the iTerm protocol can be used
 fn check_iterm_support() -> bool {
     let mut stdout = std::io::stdout();
     let term = Term::stdout();
-    if has_iterm_support(&mut stdout, &term).is_ok() {
+    if has_iterm_support_capabilities(&mut stdout, &term).is_ok() {
+        // DEBUG: REMOVE THIS BEFORE MERGE
+        eprintln!("Capabilities OK");
+        return true;
+    }
+    if has_iterm_support_reportcellsize(&mut stdout, &term).is_ok() {
+        // DEBUG: REMOVE THIS BEFORE MERGE
+        eprintln!("ReportCellSize OK");
         return true;
     }
 
@@ -212,7 +288,8 @@ mod tests {
 
         let test_data = [
             // intro
-            Key::UnknownEscSeq([']', '1'].into()), // TODO: is this actually returning that, or differently? i dont know how "console" handles OSC
+            Key::UnknownEscSeq(vec![']']), // TODO: is this actually returning that, or differently? i dont know how "console" handles OSC
+            Key::Char('1'),
             Key::Char('3'),
             Key::Char('3'),
             Key::Char('7'),
@@ -239,14 +316,17 @@ mod tests {
             Key::Char('F'),
             Key::Char('S'),
             Key::Char('x'),
-            // BEL / Bell
+            // ST
             Key::UnknownEscSeq(vec!['\\']),
             // DSR
             Key::UnknownEscSeq(vec!['[', '0', 'n']),
         ];
         let test_response = TestKeys::new(&test_data);
 
-        assert_eq!(has_iterm_support(&mut vec, &test_response).unwrap(), ());
+        assert_eq!(
+            has_iterm_support_capabilities(&mut vec, &test_response).unwrap(),
+            ()
+        );
         let stdout = std::str::from_utf8(&vec).unwrap();
 
         assert_eq!(stdout, "\x1b]1337;Capabilities\x1b\\\x1b[5n");
@@ -263,10 +343,81 @@ mod tests {
         ];
         let test_response = TestKeys::new(&test_data);
 
-        assert!(has_iterm_support(&mut vec, &test_response).is_err());
+        assert!(has_iterm_support_capabilities(&mut vec, &test_response).is_err());
         let stdout = std::str::from_utf8(&vec).unwrap();
 
         assert_eq!(stdout, "\x1b]1337;Capabilities\x1b\\\x1b[5n");
         assert!(test_response.reached_end());
     }
+
+    #[test]
+    fn reportcellsize_iterm2_should_reply() {
+        // output captured on konsole 25.08.1
+        let mut vec = Vec::new();
+
+        let test_data = [
+            // intro
+            Key::UnknownEscSeq(vec![']']),
+            Key::Char('1'),
+            Key::Char('3'),
+            Key::Char('3'),
+            Key::Char('7'),
+            Key::Char(';'),
+            Key::Char('R'),
+            Key::Char('e'),
+            Key::Char('p'),
+            Key::Char('o'),
+            Key::Char('r'),
+            Key::Char('t'),
+            Key::Char('C'),
+            Key::Char('e'),
+            Key::Char('l'),
+            Key::Char('l'),
+            Key::Char('S'),
+            Key::Char('i'),
+            Key::Char('z'),
+            Key::Char('e'),
+            Key::Char('='),
+            // actual response
+            Key::Char('1'),
+            Key::Char('5'),
+            Key::Char('.'),
+            Key::Char('0'),
+            Key::Char(';'),
+            Key::Char('1'),
+            Key::Char('.'),
+            Key::Char('0'),
+            // BEL / Bell
+            Key::Char('\x07'),
+            // DSR
+            Key::UnknownEscSeq(vec!['[', '0', 'n']),
+        ];
+        let test_response = TestKeys::new(&test_data);
+
+        assert_eq!(
+            has_iterm_support_reportcellsize(&mut vec, &test_response).unwrap(),
+            ()
+        );
+        let stdout = std::str::from_utf8(&vec).unwrap();
+
+        assert_eq!(stdout, "\x1b]1337;ReportCellSize\x1b\\\x1b[5n");
+        assert!(test_response.reached_end());
+    }
+
+    #[test]
+    fn reportcellsize_should_handle_no_reply() {
+        let mut vec = Vec::new();
+
+        let test_data = [
+            // DSR
+            Key::UnknownEscSeq(['[', '0', 'n'].into()),
+        ];
+        let test_response = TestKeys::new(&test_data);
+
+        assert!(has_iterm_support_reportcellsize(&mut vec, &test_response).is_err());
+        let stdout = std::str::from_utf8(&vec).unwrap();
+
+        assert_eq!(stdout, "\x1b]1337;ReportCellSize\x1b\\\x1b[5n");
+        assert!(test_response.reached_end());
+    }
 }