feat(vite_pty): return ExitStatus from read_to_end

Update Terminal::read_to_end() to return the child process exit status
instead of (). Uses OnceLock to synchronize between the background
thread (which waits for the child and sets the status) and read_to_end()
(which waits on the OnceLock after reading all output).

Changes:
- Add exit_status: Arc<OnceLock<ExitStatus>> field to Terminal
- Background thread now captures and stores exit status before closing writer
- read_to_end() returns ExitStatus after reading all output
- Re-export ExitStatus from vite_pty crate
- Add tests for successful (0) and non-zero (42) exit codes

All 16 tests pass on both macOS and Windows (via cargo xtest).

Generated with [Claude Code](https://claude.ai/code)
via [Happy](https://happy.engineering)

Co-Authored-By: Claude <noreply@anthropic.com>
Co-Authored-By: Happy <yesreply@happy.engineering>

Author: 3 people

crates/vite_pty/src/lib.rs

@@ -1,2 +1,4 @@
 pub mod geo;
 pub mod terminal;
+
+pub use portable_pty::ExitStatus;

crates/vite_pty/src/terminal.rs

@@ -1,11 +1,11 @@
 use std::{
     io::{Read, Write},
-    sync::{Arc, Mutex},
+    sync::{Arc, Mutex, OnceLock},
     thread,
 };
 
 pub use portable_pty::CommandBuilder;
-use portable_pty::{ChildKiller, PtyPair};
+use portable_pty::{ChildKiller, ExitStatus, PtyPair};
 
 use crate::geo::ScreenSize;
 
@@ -19,6 +19,9 @@ pub struct Terminal {
 
     /// Unprocessed data buffer for read_until
     read_until_buffer: Vec<u8>,
+
+    /// Exit status from the child process, set once by background thread
+    exit_status: Arc<OnceLock<ExitStatus>>,
 }
 
 struct Vt100Callbacks {
@@ -64,12 +67,17 @@ impl Terminal {
         let child_killer = child.clone_killer();
         let writer: Arc<Mutex<Option<Box<dyn Write + Send>>>> =
             Arc::new(Mutex::new(Some(pty_pair.master.take_writer()?)));
+        let exit_status: Arc<OnceLock<ExitStatus>> = Arc::new(OnceLock::new());
 
-        // Background thread: wait for child to exit, then close writer to trigger EOF
+        // Background thread: wait for child to exit, set exit status, then close writer to trigger EOF
         thread::spawn({
             let writer = Arc::clone(&writer);
+            let exit_status = Arc::clone(&exit_status);
             move || {
-                let _ = child.wait();
+                // Wait for child and set exit status
+                if let Ok(status) = child.wait() {
+                    let _ = exit_status.set(status);
+                }
                 // Close writer to signal EOF to the reader
                 *writer.lock().unwrap() = None;
             }
@@ -87,6 +95,7 @@ impl Terminal {
             reader,
             read_until_buffer: Vec::new(),
             writer,
+            exit_status,
         })
     }
 
@@ -138,7 +147,16 @@ impl Terminal {
         Ok(())
     }
 
-    pub fn read_to_end(&mut self) -> anyhow::Result<()> {
+    /// Reads all remaining output until the child process exits.
+    ///
+    /// Returns the exit status of the child process.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if:
+    /// - Reading from the PTY fails
+    /// - The exit status is not available (should not happen in normal operation)
+    pub fn read_to_end(&mut self) -> anyhow::Result<ExitStatus> {
         // `read_to_end` will move cursor to the end, so clear any buffered data for `read_until`
         self.read_until_buffer.clear();
 
@@ -151,7 +169,11 @@ impl Terminal {
                 break;
             }
         }
-        Ok(())
+
+        // Wait for exit status to be set by background thread
+        let status = self.exit_status.wait().clone();
+
+        Ok(status)
     }
 
     pub fn write(&mut self, data: &[u8]) -> anyhow::Result<()> {

crates/vite_pty/tests/terminal.rs

@@ -17,7 +17,7 @@ fn is_terminal() {
     }));
 
     let mut terminal = Terminal::spawn(ScreenSize { rows: 80, cols: 80 }, cmd).unwrap();
-    terminal.read_to_end().unwrap();
+    let _ = terminal.read_to_end().unwrap();
     let output = terminal.screen_contents();
     assert_eq!(output.trim(), "true true true");
 }
@@ -31,7 +31,7 @@ fn read_until_single() {
 
     let mut terminal = Terminal::spawn(ScreenSize { rows: 80, cols: 80 }, cmd).unwrap();
     terminal.read_until("hello").unwrap();
-    terminal.read_to_end().unwrap();
+    let _ = terminal.read_to_end().unwrap();
     let output = terminal.screen_contents();
     // After reading until "hello", the buffer should contain " world"
     // read_to_end should process the buffered data and continue reading
@@ -51,7 +51,7 @@ fn read_until_multiple_sequential() {
     terminal.read_until("first").unwrap();
     terminal.read_until("second").unwrap();
     terminal.read_until("third").unwrap();
-    terminal.read_to_end().unwrap();
+    let _ = terminal.read_to_end().unwrap();
     let output = terminal.screen_contents();
     // All three words should be in the screen
     assert!(output.contains("first"));
@@ -86,7 +86,7 @@ fn read_until_with_read_to_end() {
     let mut terminal = Terminal::spawn(ScreenSize { rows: 80, cols: 80 }, cmd).unwrap();
     terminal.read_until("middle").unwrap();
     // At this point, " suffix" should be buffered
-    terminal.read_to_end().unwrap();
+    let _ = terminal.read_to_end().unwrap();
     let output = terminal.screen_contents();
     // The full output should include everything
     assert!(output.contains("prefix"));
@@ -122,7 +122,7 @@ fn read_until_boundary_spanning() {
     let mut terminal = Terminal::spawn(ScreenSize { rows: 80, cols: 80 }, cmd).unwrap();
     // Search for a pattern that's likely to span boundaries
     terminal.read_until("abcd").unwrap();
-    terminal.read_to_end().unwrap();
+    let _ = terminal.read_to_end().unwrap();
     let output = terminal.screen_contents();
     assert!(output.contains("abcdef"));
 }
@@ -142,7 +142,7 @@ fn read_until_exact_boundary() {
     let mut terminal = Terminal::spawn(ScreenSize { rows: 80, cols: 80 }, cmd).unwrap();
     // This should find "second" even if "first" was in a previous read
     terminal.read_until("second").unwrap();
-    terminal.read_to_end().unwrap();
+    let _ = terminal.read_to_end().unwrap();
     let output = terminal.screen_contents();
     assert!(output.contains("first"));
     assert!(output.contains("second"));
@@ -162,7 +162,7 @@ fn read_until_after_read_to_end() {
     terminal.read_until("world").unwrap();
 
     // Read everything else
-    terminal.read_to_end().unwrap();
+    let _ = terminal.read_to_end().unwrap();
     let output = terminal.screen_contents();
     assert!(output.contains("hello world foo bar"));
 
@@ -195,7 +195,7 @@ fn write_basic_echo() {
 
     // Read until we see the echo
     terminal.read_until("hello world").unwrap();
-    terminal.read_to_end().unwrap();
+    let _ = terminal.read_to_end().unwrap();
 
     let output = terminal.screen_contents();
     // PTY echoes the input, so we see "hello world\nhello world"
@@ -231,7 +231,7 @@ fn write_multiple_lines() {
     terminal.write(b"third\n").unwrap();
     terminal.read_until("Echo: third").unwrap();
 
-    terminal.read_to_end().unwrap();
+    let _ = terminal.read_to_end().unwrap();
     let output = terminal.screen_contents();
     // PTY echoes input, so we see both the typed input and the echo response
     assert_eq!(output.trim(), "first\nEcho: firstsecond\nEcho: secondthird\nEcho: third");
@@ -247,7 +247,7 @@ fn write_after_exit() {
     let mut terminal = Terminal::spawn(ScreenSize { rows: 80, cols: 80 }, cmd).unwrap();
 
     // Read all output - this blocks until child exits and EOF is reached
-    terminal.read_to_end().unwrap();
+    let _ = terminal.read_to_end().unwrap();
 
     // The background thread should have set writer to None by now
     // since read_to_end only returns after EOF (child exit)
@@ -282,7 +282,7 @@ fn write_interactive_prompt() {
     // Wait for greeting
     terminal.read_until("Hello, Alice").unwrap();
 
-    terminal.read_to_end().unwrap();
+    let _ = terminal.read_to_end().unwrap();
     let output = terminal.screen_contents();
     assert_eq!(output.trim(), "Name: Alice\nHello, Alice");
 }
@@ -368,7 +368,7 @@ fn resize_terminal() {
     // Verify new size is correct
     terminal.read_until("resized: 40 40").unwrap();
 
-    terminal.read_to_end().unwrap();
+    let _ = terminal.read_to_end().unwrap();
 }
 
 #[test]
@@ -430,5 +430,31 @@ fn send_ctrl_c_interrupts_process() {
     // Verify interruption was detected
     terminal.read_until("INTERRUPTED").unwrap();
 
-    terminal.read_to_end().unwrap();
+    let _ = terminal.read_to_end().unwrap();
+}
+
+#[test]
+#[timeout(5000)]
+fn read_to_end_returns_exit_status_success() {
+    let cmd = CommandBuilder::from(command_for_fn!((), |_: ()| {
+        println!("success");
+    }));
+
+    let mut terminal = Terminal::spawn(ScreenSize { rows: 80, cols: 80 }, cmd).unwrap();
+    let status = terminal.read_to_end().unwrap();
+    assert!(status.success());
+    assert_eq!(status.exit_code(), 0);
+}
+
+#[test]
+#[timeout(5000)]
+fn read_to_end_returns_exit_status_nonzero() {
+    let cmd = CommandBuilder::from(command_for_fn!((), |_: ()| {
+        std::process::exit(42);
+    }));
+
+    let mut terminal = Terminal::spawn(ScreenSize { rows: 80, cols: 80 }, cmd).unwrap();
+    let status = terminal.read_to_end().unwrap();
+    assert!(!status.success());
+    assert_eq!(status.exit_code(), 42);
 }