fix(core): compact parser raw outputs over certain size

Author: AgentEnder

packages/nx/src/native/pseudo_terminal/pseudo_terminal.rs

@@ -91,16 +91,42 @@ impl PseudoTerminal {
         let quiet_clone = quiet.clone();
         let running_clone = running.clone();
 
-        let parser = Arc::new(RwLock::new(Parser::new(h, w, 10000)));
+        // Scrollback size matches PtyInstance::SCROLLBACK_SIZE (1000 rows).
+        // Larger values make resize reparse and all_contents_formatted() more
+        // expensive, which blocks the parser write lock and starves rendering.
+        const SCROLLBACK_SIZE: usize = 1000;
+        // When raw output exceeds this threshold, compact the parser to prevent
+        // unbounded Vec growth. Without this, extend_from_slice() eventually
+        // triggers multi-hundred-millisecond reallocs under the write lock,
+        // causing the TUI to hang progressively worse as output accumulates.
+        const MAX_RAW_OUTPUT_BYTES: usize = 5 * 1024 * 1024; // 5 MB
+
+        let parser = Arc::new(RwLock::new(Parser::new(h, w, SCROLLBACK_SIZE)));
         let parser_clone = parser.clone();
         let stdout_tx_clone = stdout_tx.clone();
         std::thread::spawn(move || {
             let mut stdout = std::io::stdout();
             let mut buf = [0; 8 * 1024];
+            // Local buffer for batching parser writes when inside the TUI.
+            // Under firehose output, reader.read() returns a full 8KB buffer
+            // on every call. Without batching, the parser write lock is
+            // acquired on every 8KB chunk, leaving almost no gap for the
+            // rendering thread's try_read(). By accumulating locally and
+            // only flushing when the read returns short (PTY caught up) or
+            // the buffer exceeds a threshold, we reduce lock acquisitions
+            // and give rendering predictable windows to read.
+            let mut pending_tui_buf: Vec<u8> = Vec::new();
+            const BATCH_THRESHOLD: usize = 64 * 1024;
 
             'read_loop: loop {
                 if let Ok(len) = reader.read(&mut buf) {
                     if len == 0 {
+                        // EOF — flush any remaining buffered data before exiting
+                        if is_within_nx_tui && !pending_tui_buf.is_empty() {
+                            let mut parser = parser_clone.write();
+                            parser.process(&pending_tui_buf);
+                            pending_tui_buf.clear();
+                        }
                         break;
                     }
                     stdout_tx_clone
@@ -111,7 +137,34 @@ impl PseudoTerminal {
                     debug!("Read {} bytes", len);
                     if is_within_nx_tui {
                         trace!("Processing data via vt100 for use in tui");
-                        parser_clone.write().process(&buf[..len]);
+                        pending_tui_buf.extend_from_slice(&buf[..len]);
+                        // Batch: only take the parser write lock when the PTY
+                        // reader has caught up (short read) or we've accumulated
+                        // enough data. Under firehose output, full-buffer reads
+                        // (len == buf.len()) indicate more data is immediately
+                        // available, so we defer processing. Short reads mean
+                        // we've drained the PTY buffer and the next read will
+                        // block, giving us a natural processing window.
+                        let should_flush =
+                            len < buf.len() || pending_tui_buf.len() >= BATCH_THRESHOLD;
+                        if should_flush {
+                            let mut parser = parser_clone.write();
+                            parser.process(&pending_tui_buf);
+                            pending_tui_buf.clear();
+                            // Compact when raw output grows too large. Replays
+                            // the formatted screen state (bounded by SCROLLBACK_SIZE)
+                            // through a fresh parser, keeping raw_output small.
+                            if parser.get_raw_output().len() > MAX_RAW_OUTPUT_BYTES {
+                                let screen = parser.screen();
+                                let (rows, cols) = screen.size();
+                                let formatted = screen.all_contents_formatted();
+                                let scrollback = screen.scrollback();
+                                let mut compacted = Parser::new(rows, cols, SCROLLBACK_SIZE);
+                                compacted.process(&formatted);
+                                compacted.screen_mut().set_scrollback(scrollback);
+                                *parser = compacted;
+                            }
+                        }
                     }
 
                     if !quiet {