fix(core): avoid panic when inline tui can't init (#34135)

AgentEnder · web-flow · commit 0137ea2dc918 · 2026-01-17T23:38:00.000-05:00
## Current Behavior
if inline tui init fails, we panic

## Expected Behavior
If inline tui init fails, inline mode is disabled. We show the reason
its disabled when someone tries to use it.

## Related Issue(s)
&lt;!-- Please link the issue being fixed so it gets closed when this is
merged. --&gt;

Fixes #
diff --git a/packages/nx/src/native/tui/app.rs b/packages/nx/src/native/tui/app.rs
@@ -542,7 +542,7 @@ impl App {
                 if matches!(key.code, KeyCode::F(11))
                     && !matches!(self.focus, Focus::CountdownPopup)
                 {
-                    self.try_switch_to_inline_mode();
+                    self.dispatch_action(Action::SwitchMode(TuiMode::Inline));
                     return Ok(false);
                 }
 
@@ -744,9 +744,7 @@ impl App {
                                     // swap to inline tui mode focusing that task
                                     KeyCode::Enter => {
                                         // dispatch action to switch to inline mode with focused task
-                                        if let Focus::MultipleOutput(_pane_idx) = self.focus {
-                                            self.try_switch_to_inline_mode();
-                                        }
+                                        self.dispatch_action(Action::SwitchMode(TuiMode::Inline));
                                     }
                                     _ => {
                                         // Forward other keys for interactivity, scrolling (j/k) etc
@@ -1266,22 +1264,6 @@ impl App {
         self.core.dispatch_action(action);
     }
 
-    /// Attempts to switch to inline mode, showing a hint if unavailable
-    ///
-    /// Inline mode requires stdin to be a TTY for cursor position queries.
-    /// In environments like git hooks where stdin is redirected, inline mode
-    /// would hang waiting for terminal responses. This method shows a helpful
-    /// hint instead of silently failing.
-    fn try_switch_to_inline_mode(&self) {
-        if tui::Tui::is_stdin_interactive() {
-            self.dispatch_action(Action::SwitchMode(TuiMode::Inline));
-        } else {
-            self.dispatch_action(Action::ShowHint(
-                "Inline mode is not available in this environment (stdin is not a TTY)".to_string(),
-            ));
-        }
-    }
-
     fn recalculate_layout_areas(&mut self) {
         if let Some(frame_area) = self.frame_area {
             self.layout_areas = Some(self.layout_manager.calculate_layout(frame_area));
diff --git a/packages/nx/src/native/tui/lifecycle.rs b/packages/nx/src/native/tui/lifecycle.rs
@@ -180,16 +180,21 @@ fn switch_mode(
     // This happens in git hooks where stderr is a TTY but stdin is redirected.
     // In this case, show a hint to the user and stay in fullscreen mode instead of hanging.
     // See: https://github.com/crossterm-rs/crossterm/issues/692
-    if target_mode == TuiMode::Inline && !super::tui::Tui::is_stdin_interactive() {
-        debug!(
-            "Cannot switch to inline mode: stdin is not a TTY. \
-             Staying in fullscreen mode to avoid hanging on cursor position query."
-        );
-        // Show hint to inform user why inline mode is unavailable
-        let _ = action_tx.send(Action::ShowHint(
-            "Inline mode is not available in this environment (stdin is not a TTY)".to_string(),
-        ));
-        return Some(tui.current_mode);
+    if target_mode == TuiMode::Inline {
+        let inline_tui_unsupported = tui.inline_tui_unsupported_reason();
+        if let Some(reason) = inline_tui_unsupported {
+            debug!(
+                "Cannot switch to inline mode: {}. \
+                 Staying in fullscreen mode to avoid hanging on cursor position query.",
+                reason
+            );
+            // Show hint to inform user why inline mode is unavailable
+            let _ = action_tx.send(Action::ShowHint(format!(
+                "Inline mode is not available in this environment: {}",
+                reason
+            )));
+            return Some(tui.current_mode);
+        }
     }
 
     // Save UI state before switching (for full-screen mode persistence)
diff --git a/packages/nx/src/native/tui/tui.rs b/packages/nx/src/native/tui/tui.rs
@@ -10,6 +10,7 @@ use crossterm::{
 use futures::{FutureExt, StreamExt};
 use ratatui::backend::CrosstermBackend;
 use std::{
+    env,
     io::{IsTerminal, Write},
     ops::{Deref, DerefMut},
     time::Duration,
@@ -86,10 +87,10 @@ impl Tui {
         // escape sequences that wait for responses on stdin. In git hooks and other
         // non-interactive environments, stdin is redirected so these queries hang.
         // By checking upfront, we avoid flakiness from deferred initialization.
-        let inline_terminal = if Self::is_stdin_interactive() {
-            let size = crossterm::terminal::size();
-            debug!("Terminal size: {:?}", size);
-            let inline_height = size.map(|(_cols, rows)| rows).unwrap_or(24);
+        let inline_terminal = if Self::inline_viewport_supported() {
+            let inline_height = crossterm::terminal::size()
+                .map(|(_cols, rows)| rows)
+                .unwrap_or(24);
             ratatui::Terminal::with_options(
                 CrosstermBackend::new(std::io::stderr()),
                 ratatui::TerminalOptions {
@@ -135,10 +136,35 @@ impl Tui {
     /// which hang indefinitely if stdin isn't a real terminal.
     ///
     /// See: https://github.com/crossterm-rs/crossterm/issues/692
-    pub fn is_stdin_interactive() -> bool {
+    fn is_stdin_interactive() -> bool {
         std::io::stdin().is_terminal()
     }
 
+    fn is_inline_mode_disabled() -> bool {
+        let env = env::var("NX_TUI_INLINE_MODE");
+        match env {
+            Ok(val) if val == "0" || val.to_lowercase() == "false" => true,
+            _ => false,
+        }
+    }
+
+    fn inline_viewport_supported() -> bool {
+        Self::is_stdin_interactive() && !Self::is_inline_mode_disabled()
+    }
+
+    pub fn inline_tui_unsupported_reason(&self) -> Option<String> {
+        if !Self::is_stdin_interactive() {
+            return Some("Stdin is not a TTY".to_string());
+        }
+        if Self::is_inline_mode_disabled() {
+            return Some("NX_TUI_INLINE_MODE is set to false or 0".to_string());
+        }
+        if !self.inline_terminal.is_some() {
+            return Some("Inline terminal failed to initialize".to_string());
+        }
+        None
+    }
+
     /// Returns a reference to the currently active terminal based on mode
     pub fn terminal(&self) -> &ratatui::Terminal<Backend> {
         match self.current_mode {
