refactor: split PtyStream into PtyReader + PtyWriter with shared parser

wan9chi · claude · wan9chi · commit f690c734d519 · 2026-02-11T15:27:43.000+08:00
Share vt100 parser via Arc&lt;Mutex&lt;...&gt;&gt; between reader and writer,
allowing independent mutable borrows in tests without scoped BufReader workarounds.

Co-Authored-By: Claude Opus 4.6 &lt;noreply@anthropic.com&gt;
diff --git a/crates/pty_terminal/src/terminal.rs b/crates/pty_terminal/src/terminal.rs
@@ -9,17 +9,22 @@ use portable_pty::{ChildKiller, ExitStatus, MasterPty};
 
 use crate::geo::ScreenSize;
 
-/// A combined PTY reader/writer that implements [`Read`] and [`Write`].
+/// The read half of a PTY connection. Implements [`Read`].
 ///
-/// Reading feeds data through an internal vt100 parser, keeping `screen_contents()`
-/// up-to-date with parsed terminal output.
+/// Reading feeds data through an internal vt100 parser (shared with [`PtyWriter`]),
+/// keeping `screen_contents()` up-to-date with parsed terminal output.
+pub struct PtyReader {
+    reader: Box<dyn Read + Send>,
+    parser: Arc<Mutex<vt100::Parser<Vt100Callbacks>>>,
+}
+
+/// The write half of a PTY connection. Implements [`Write`].
 ///
 /// The writer is shared with `Vt100Callbacks` (for DSR query responses) and the
 /// background child-monitoring thread (which sets it to `None` on child exit).
-pub struct PtyStream {
-    reader: Box<dyn Read + Send>,
+pub struct PtyWriter {
     writer: Arc<Mutex<Option<Box<dyn Write + Send>>>>,
-    parser: vt100::Parser<Vt100Callbacks>,
+    parser: Arc<Mutex<vt100::Parser<Vt100Callbacks>>>,
     master: Box<dyn MasterPty + Send>,
 }
 
@@ -38,9 +43,10 @@ impl Clone for ChildHandle {
     }
 }
 
-/// A headless terminal consisting of a PTY stream and a child process handle.
+/// A headless terminal consisting of a PTY reader, writer, and a child process handle.
 pub struct Terminal {
-    pub pty_stream: PtyStream,
+    pub pty_reader: PtyReader,
+    pub pty_writer: PtyWriter,
     pub child_handle: ChildHandle,
 }
 
@@ -73,17 +79,17 @@ impl vt100::Callbacks for Vt100Callbacks {
     }
 }
 
-impl Read for PtyStream {
+impl Read for PtyReader {
     fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
         let n = self.reader.read(buf)?;
         if n > 0 {
-            self.parser.process(&buf[..n]);
+            self.parser.lock().unwrap().process(&buf[..n]);
         }
         Ok(n)
     }
 }
 
-impl Write for PtyStream {
+impl Write for PtyWriter {
     fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
         let mut guard =
             self.writer.lock().map_err(|e| std::io::Error::other(format!("Poisoned lock: {e}")))?;
@@ -102,7 +108,19 @@ impl Write for PtyStream {
     }
 }
 
-impl PtyStream {
+impl PtyReader {
+    /// Returns the current terminal screen contents as a string (parsed by the vt100 emulator).
+    ///
+    /// # Panics
+    ///
+    /// Panics if the parser lock is poisoned.
+    #[must_use]
+    pub fn screen_contents(&self) -> String {
+        self.parser.lock().unwrap().screen().contents()
+    }
+}
+
+impl PtyWriter {
     /// Writes `line` followed by a platform-appropriate line ending to the child process.
     ///
     /// On Unix, appends `\n`. On Windows `ConPTY`, appends `\r\n` for proper line handling.
@@ -122,12 +140,6 @@ impl PtyStream {
         self.flush()
     }
 
-    /// Returns the current terminal screen contents as a string (parsed by the vt100 emulator).
-    #[must_use]
-    pub fn screen_contents(&self) -> String {
-        self.parser.screen().contents()
-    }
-
     /// Sends Ctrl+C (SIGINT) to the child process.
     ///
     /// Writes ETX (0x03) to the PTY. On Unix, the terminal driver converts this
@@ -149,15 +161,19 @@ impl PtyStream {
     /// # Errors
     ///
     /// Returns an error if the PTY cannot be resized.
-    pub fn resize(&mut self, size: ScreenSize) -> anyhow::Result<()> {
+    ///
+    /// # Panics
+    ///
+    /// Panics if the parser lock is poisoned.
+    pub fn resize(&self, size: ScreenSize) -> anyhow::Result<()> {
         self.master.resize(portable_pty::PtySize {
             rows: size.rows,
             cols: size.cols,
             pixel_width: 0,
             pixel_height: 0,
         })?;
 
-        self.parser.screen_mut().set_size(size.rows, size.cols);
+        self.parser.lock().unwrap().screen_mut().set_size(size.rows, size.cols);
 
         Ok(())
     }
@@ -223,18 +239,16 @@ impl Terminal {
             }
         });
 
+        let parser = Arc::new(Mutex::new(vt100::Parser::new_with_callbacks(
+            size.rows,
+            size.cols,
+            0,
+            Vt100Callbacks { writer: Arc::clone(&writer) },
+        )));
+
         Ok(Self {
-            pty_stream: PtyStream {
-                parser: vt100::Parser::new_with_callbacks(
-                    size.rows,
-                    size.cols,
-                    0,
-                    Vt100Callbacks { writer: Arc::clone(&writer) },
-                ),
-                reader,
-                writer,
-                master,
-            },
+            pty_reader: PtyReader { reader, parser: Arc::clone(&parser) },
+            pty_writer: PtyWriter { writer, parser, master },
             child_handle: ChildHandle { child_killer, exit_status },
         })
     }
diff --git a/crates/pty_terminal/tests/terminal.rs b/crates/pty_terminal/tests/terminal.rs
@@ -13,12 +13,12 @@ fn is_terminal() {
         println!("{} {} {}", stdin().is_terminal(), stdout().is_terminal(), stderr().is_terminal());
     }));
 
-    let Terminal { mut pty_stream, child_handle } =
+    let Terminal { mut pty_reader, pty_writer: _pty_writer, child_handle } =
         Terminal::spawn(ScreenSize { rows: 80, cols: 80 }, cmd).unwrap();
     let mut discard = Vec::new();
-    pty_stream.read_to_end(&mut discard).unwrap();
+    pty_reader.read_to_end(&mut discard).unwrap();
     let _ = child_handle.wait();
-    let output = pty_stream.screen_contents();
+    let output = pty_reader.screen_contents();
     assert_eq!(output.trim(), "true true true");
 }
 
@@ -37,16 +37,16 @@ fn write_basic_echo() {
         }
     }));
 
-    let Terminal { mut pty_stream, child_handle } =
+    let Terminal { mut pty_reader, mut pty_writer, child_handle } =
         Terminal::spawn(ScreenSize { rows: 80, cols: 80 }, cmd).unwrap();
 
-    pty_stream.write_line(b"hello world").unwrap();
+    pty_writer.write_line(b"hello world").unwrap();
 
     let mut discard = Vec::new();
-    pty_stream.read_to_end(&mut discard).unwrap();
+    pty_reader.read_to_end(&mut discard).unwrap();
     let _ = child_handle.wait();
 
-    let output = pty_stream.screen_contents();
+    let output = pty_reader.screen_contents();
     // PTY echoes the input, so we see "hello world\nhello world"
     assert_eq!(output.trim(), "hello world\nhello world");
 }
@@ -68,12 +68,12 @@ fn write_multiple_lines() {
         }
     }));
 
-    let Terminal { mut pty_stream, child_handle } =
+    let Terminal { mut pty_reader, mut pty_writer, child_handle } =
         Terminal::spawn(ScreenSize { rows: 80, cols: 80 }, cmd).unwrap();
 
-    pty_stream.write_line(b"first").unwrap();
+    pty_writer.write_line(b"first").unwrap();
     {
-        let mut buf_reader = BufReader::new(&mut pty_stream);
+        let mut buf_reader = BufReader::new(&mut pty_reader);
         let mut line = Vec::new();
         // Read PTY echo of "first\n"
         buf_reader.read_until(b'\n', &mut line).unwrap();
@@ -82,22 +82,22 @@ fn write_multiple_lines() {
         buf_reader.read_until(b'\n', &mut line).unwrap();
     }
 
-    pty_stream.write_line(b"second").unwrap();
+    pty_writer.write_line(b"second").unwrap();
     {
-        let mut buf_reader = BufReader::new(&mut pty_stream);
+        let mut buf_reader = BufReader::new(&mut pty_reader);
         let mut line = Vec::new();
         buf_reader.read_until(b'\n', &mut line).unwrap();
         line.clear();
         buf_reader.read_until(b'\n', &mut line).unwrap();
     }
 
-    pty_stream.write_line(b"third").unwrap();
+    pty_writer.write_line(b"third").unwrap();
 
     let mut discard = Vec::new();
-    pty_stream.read_to_end(&mut discard).unwrap();
+    pty_reader.read_to_end(&mut discard).unwrap();
     let _ = child_handle.wait();
 
-    let output = pty_stream.screen_contents();
+    let output = pty_reader.screen_contents();
     // PTY echoes input, then child prints "Echo: {line}\n" for each
     assert_eq!(output.trim(), "first\nEcho: first\nsecond\nEcho: second\nthird\nEcho: third");
 }
@@ -110,18 +110,18 @@ fn write_after_exit() {
         print!("exiting");
     }));
 
-    let Terminal { mut pty_stream, child_handle } =
+    let Terminal { mut pty_reader, mut pty_writer, child_handle } =
         Terminal::spawn(ScreenSize { rows: 80, cols: 80 }, cmd).unwrap();
 
     // Read all output - this blocks until child exits and EOF is reached
     let mut discard = Vec::new();
-    pty_stream.read_to_end(&mut discard).unwrap();
+    pty_reader.read_to_end(&mut discard).unwrap();
     let _ = child_handle.wait();
 
     // The background thread should have set writer to None by now
     // since read_to_end only returns after EOF (child exit)
     // Writing should fail with BrokenPipe
-    let result = pty_stream.write_all(b"too late\n");
+    let result = pty_writer.write_all(b"too late\n");
     assert!(result.is_err());
 }
 
@@ -141,25 +141,25 @@ fn write_interactive_prompt() {
         stdout.flush().unwrap();
     }));
 
-    let Terminal { mut pty_stream, child_handle } =
+    let Terminal { mut pty_reader, mut pty_writer, child_handle } =
         Terminal::spawn(ScreenSize { rows: 80, cols: 80 }, cmd).unwrap();
 
     // Wait for prompt "Name: " (read until the space after colon)
     {
-        let mut buf_reader = BufReader::new(&mut pty_stream);
+        let mut buf_reader = BufReader::new(&mut pty_reader);
         let mut buf = Vec::new();
         buf_reader.read_until(b' ', &mut buf).unwrap();
         assert!(String::from_utf8_lossy(&buf).contains("Name:"));
     }
 
     // Send response
-    pty_stream.write_line(b"Alice").unwrap();
+    pty_writer.write_line(b"Alice").unwrap();
 
     let mut discard = Vec::new();
-    pty_stream.read_to_end(&mut discard).unwrap();
+    pty_reader.read_to_end(&mut discard).unwrap();
     let _ = child_handle.wait();
 
-    let output = pty_stream.screen_contents();
+    let output = pty_reader.screen_contents();
     assert_eq!(output.trim(), "Name: Alice\nHello, Alice");
 }
 
@@ -232,28 +232,28 @@ fn resize_terminal() {
         stdout().flush().unwrap();
     }));
 
-    let Terminal { mut pty_stream, child_handle: _ } =
+    let Terminal { mut pty_reader, mut pty_writer, child_handle: _ } =
         Terminal::spawn(ScreenSize { rows: 80, cols: 80 }, cmd).unwrap();
 
     // Wait for initial size line (synchronize before resizing)
     {
-        let mut buf_reader = BufReader::new(&mut pty_stream);
+        let mut buf_reader = BufReader::new(&mut pty_reader);
         let mut line = Vec::new();
         buf_reader.read_until(b'\n', &mut line).unwrap();
         assert!(String::from_utf8_lossy(&line).contains("initial: 80 80"));
     }
 
     // Perform resize
-    pty_stream.resize(ScreenSize { rows: 40, cols: 40 }).unwrap();
+    pty_writer.resize(ScreenSize { rows: 40, cols: 40 }).unwrap();
 
     // Signal the process to continue and check resize
-    pty_stream.write_line(b"").unwrap();
+    pty_writer.write_line(b"").unwrap();
 
     // Read remaining output
     let mut discard = Vec::new();
-    pty_stream.read_to_end(&mut discard).unwrap();
+    pty_reader.read_to_end(&mut discard).unwrap();
 
-    let output = pty_stream.screen_contents();
+    let output = pty_reader.screen_contents();
     // Verify resize was detected (SIGWINCH on Unix, synchronous on Windows)
     assert!(output.contains("RESIZE_DETECTED"));
     // Verify new size is correct
@@ -303,25 +303,25 @@ fn send_ctrl_c_interrupts_process() {
         }
     }));
 
-    let Terminal { mut pty_stream, child_handle: _ } =
+    let Terminal { mut pty_reader, mut pty_writer, child_handle: _ } =
         Terminal::spawn(ScreenSize { rows: 80, cols: 80 }, cmd).unwrap();
 
     // Wait for process to be ready
     {
-        let mut buf_reader = BufReader::new(&mut pty_stream);
+        let mut buf_reader = BufReader::new(&mut pty_reader);
         let mut line = Vec::new();
         buf_reader.read_until(b'\n', &mut line).unwrap();
         assert!(String::from_utf8_lossy(&line).contains("ready"));
     }
 
     // Send Ctrl+C
-    pty_stream.send_ctrl_c().unwrap();
+    pty_writer.send_ctrl_c().unwrap();
 
     // Read remaining output
     let mut discard = Vec::new();
-    pty_stream.read_to_end(&mut discard).unwrap();
+    pty_reader.read_to_end(&mut discard).unwrap();
 
-    let output = pty_stream.screen_contents();
+    let output = pty_reader.screen_contents();
     // Verify interruption was detected
     assert!(output.contains("INTERRUPTED"));
 }
@@ -334,10 +334,10 @@ fn read_to_end_returns_exit_status_success() {
         println!("success");
     }));
 
-    let Terminal { mut pty_stream, child_handle } =
+    let Terminal { mut pty_reader, pty_writer: _pty_writer, child_handle } =
         Terminal::spawn(ScreenSize { rows: 80, cols: 80 }, cmd).unwrap();
     let mut discard = Vec::new();
-    pty_stream.read_to_end(&mut discard).unwrap();
+    pty_reader.read_to_end(&mut discard).unwrap();
     let status = child_handle.wait();
     assert!(status.success());
     assert_eq!(status.exit_code(), 0);
@@ -350,10 +350,10 @@ fn read_to_end_returns_exit_status_nonzero() {
         std::process::exit(42);
     }));
 
-    let Terminal { mut pty_stream, child_handle } =
+    let Terminal { mut pty_reader, pty_writer: _pty_writer, child_handle } =
         Terminal::spawn(ScreenSize { rows: 80, cols: 80 }, cmd).unwrap();
     let mut discard = Vec::new();
-    pty_stream.read_to_end(&mut discard).unwrap();
+    pty_reader.read_to_end(&mut discard).unwrap();
     let status = child_handle.wait();
     assert!(!status.success());
     assert_eq!(status.exit_code(), 42);
diff --git a/crates/vite_task_bin/tests/e2e_snapshots/main.rs b/crates/vite_task_bin/tests/e2e_snapshots/main.rs
@@ -213,10 +213,10 @@ fn run_case_inner(tmpdir: &AbsolutePath, fixture_path: &std::path::Path, fixture
             let mut killer = terminal.child_handle.clone();
             let (tx, rx) = mpsc::channel();
             std::thread::spawn(move || {
-                let Terminal { mut pty_stream, child_handle } = terminal;
+                let Terminal { mut pty_reader, pty_writer: _pty_writer, child_handle } = terminal;
                 let mut discard = Vec::new();
-                let read_result = pty_stream.read_to_end(&mut discard);
-                let screen = pty_stream.screen_contents();
+                let read_result = pty_reader.read_to_end(&mut discard);
+                let screen = pty_reader.screen_contents();
                 let status = read_result.map(|_| child_handle.wait());
                 let _ = tx.send((status, screen));
             });
