Lightweight coding agent that runs in your terminal
Rust
Prevent Unix PTY I/O from blocking runtime shutdown (#40460)
viyatb-oaibf3eb2ec91fb
diff --git a/codex-rs/utils/pty/Cargo.toml b/codex-rs/utils/pty/Cargo.tomlindex 84801f4f11..2a27ab72ea 100644--- a/codex-rs/utils/pty/Cargo.toml+++ b/codex-rs/utils/pty/Cargo.toml@@ -10,7 +10,7 @@ workspace = true[dependencies]anyhow = { workspace = true }portable-pty = { workspace = true }-tokio = { workspace = true, features = ["io-util", "macros", "process", "rt-multi-thread", "sync", "time"] }+tokio = { workspace = true, features = ["io-util", "macros", "net", "process", "rt-multi-thread", "sync", "time"] }[dev-dependencies]pretty_assertions = { workspace = true }diff --git a/codex-rs/utils/pty/src/lib.rs b/codex-rs/utils/pty/src/lib.rsindex 24c667a0ac..1200c11438 100644--- a/codex-rs/utils/pty/src/lib.rs+++ b/codex-rs/utils/pty/src/lib.rs@@ -4,6 +4,8 @@ pub mod process_group;pub mod pty;#[cfg(test)]mod tests;+#[cfg(unix)]+mod unix_io;#[cfg(windows)]mod win;#[cfg(windows)]diff --git a/codex-rs/utils/pty/src/pty.rs b/codex-rs/utils/pty/src/pty.rsindex 182f96f4e3..1b848b33b7 100644--- a/codex-rs/utils/pty/src/pty.rs+++ b/codex-rs/utils/pty/src/pty.rs@@ -18,6 +18,7 @@ use std::process::Stdio;use std::sync::Arc;use std::sync::Mutex as StdMutex;use std::sync::atomic::AtomicBool;+#[cfg(not(unix))]use std::time::Duration;use anyhow::Result;@@ -159,6 +160,12 @@ async fn spawn_process_portable() -> Result<SpawnedProcess> {let pty_system = platform_native_pty_system();let pair = pty_system.openpty(size.into())?;+ #[cfg(unix)]+ let io = crate::unix_io::PtyIo::new(+ pair.master+ .as_raw_fd()+ .ok_or_else(|| anyhow::anyhow!("PTY master has no file descriptor"))?,+ )?;let mut command_builder = CommandBuilder::new(arg0.as_ref().unwrap_or(&program.to_string()));command_builder.cwd(cwd);@@ -178,45 +185,56 @@ async fn spawn_process_portable(let process_group_id = child.process_id();let killer = child.clone_killer();- let (writer_tx, mut writer_rx) = mpsc::channel::<Vec<u8>>(128);+ let (writer_tx, writer_rx) = mpsc::channel::<Vec<u8>>(128);let (stdout_tx, stdout_rx) = mpsc::channel::<Vec<u8>>(128);let (_stderr_tx, stderr_rx) = mpsc::channel::<Vec<u8>>(1);- let mut reader = pair.master.try_clone_reader()?;- let reader_handle: JoinHandle<()> = tokio::task::spawn_blocking(move || {- let mut buf = [0u8; 8_192];- loop {- match reader.read(&mut buf) {- Ok(0) => break,- Ok(n) => {- let _ = stdout_tx.blocking_send(buf[..n].to_vec());- }- Err(ref e) if e.kind() == ErrorKind::Interrupted => continue,- Err(ref e) if e.kind() == ErrorKind::WouldBlock => {- std::thread::sleep(Duration::from_millis(5));- continue;+ #[cfg(unix)]+ let (reader_handle, writer_handle) = io.spawn(+ stdout_tx,+ writer_rx,+ crate::unix_io::StdinCloseBehavior::SendEof,+ );+ #[cfg(not(unix))]+ let (reader_handle, writer_handle) = {+ let mut reader = pair.master.try_clone_reader()?;+ let reader_handle: JoinHandle<()> = tokio::task::spawn_blocking(move || {+ let mut buf = [0u8; 8_192];+ loop {+ match reader.read(&mut buf) {+ Ok(0) => break,+ Ok(n) => {+ let _ = stdout_tx.blocking_send(buf[..n].to_vec());+ }+ Err(ref e) if e.kind() == ErrorKind::Interrupted => continue,+ Err(ref e) if e.kind() == ErrorKind::WouldBlock => {+ std::thread::sleep(Duration::from_millis(5));+ continue;+ }+ Err(_) => break,}- Err(_) => break,}- }- });-- let writer = pair.master.take_writer()?;- let writer = Arc::new(tokio::sync::Mutex::new(writer));- let writer_handle: JoinHandle<()> = tokio::spawn({- let writer = Arc::clone(&writer);- async move {- #[cfg(windows)]- let mut windows_input = crate::WindowsTtyInputNormalizer::default();- while let Some(bytes) = writer_rx.recv().await {+ });++ let mut writer_rx = writer_rx;+ let writer = pair.master.take_writer()?;+ let writer = Arc::new(tokio::sync::Mutex::new(writer));+ let writer_handle: JoinHandle<()> = tokio::spawn({+ let writer = Arc::clone(&writer);+ async move {#[cfg(windows)]- let bytes = windows_input.normalize(&bytes);- let mut guard = writer.lock().await;- use std::io::Write;- let _ = guard.write_all(&bytes);- let _ = guard.flush();+ let mut windows_input = crate::WindowsTtyInputNormalizer::default();+ while let Some(bytes) = writer_rx.recv().await {+ #[cfg(windows)]+ let bytes = windows_input.normalize(&bytes);+ let mut guard = writer.lock().await;+ use std::io::Write;+ let _ = guard.write_all(&bytes);+ let _ = guard.flush();+ }}- }- });+ });+ (reader_handle, writer_handle)+ };let (exit_tx, exit_rx) = oneshot::channel::<i32>();let exit_status = Arc::new(AtomicBool::new(false));@@ -280,6 +298,7 @@ async fn spawn_process_preserving_fds(inherited_fds: &[RawFd],) -> Result<SpawnedProcess> {let (master, slave) = open_unix_pty(size)?;+ let io = crate::unix_io::PtyIo::new(master.as_raw_fd())?;let mut command = StdCommand::new(program);if let Some(arg0) = arg0 {command.arg0(arg0);@@ -342,40 +361,14 @@ async fn spawn_process_preserving_fds(drop(slave);let process_group_id = child.id();- let (writer_tx, mut writer_rx) = mpsc::channel::<Vec<u8>>(128);+ let (writer_tx, writer_rx) = mpsc::channel::<Vec<u8>>(128);let (stdout_tx, stdout_rx) = mpsc::channel::<Vec<u8>>(128);let (_stderr_tx, stderr_rx) = mpsc::channel::<Vec<u8>>(1);- let mut reader = master.try_clone()?;- let reader_handle: JoinHandle<()> = tokio::task::spawn_blocking(move || {- let mut buf = [0u8; 8_192];- loop {- match std::io::Read::read(&mut reader, &mut buf) {- Ok(0) => break,- Ok(n) => {- let _ = stdout_tx.blocking_send(buf[..n].to_vec());- }- Err(ref e) if e.kind() == ErrorKind::Interrupted => continue,- Err(ref e) if e.kind() == ErrorKind::WouldBlock => {- std::thread::sleep(Duration::from_millis(5));- continue;- }- Err(_) => break,- }- }- });-- let writer = Arc::new(tokio::sync::Mutex::new(master.try_clone()?));- let writer_handle: JoinHandle<()> = tokio::spawn({- let writer = Arc::clone(&writer);- async move {- while let Some(bytes) = writer_rx.recv().await {- let mut guard = writer.lock().await;- use std::io::Write;- let _ = guard.write_all(&bytes);- let _ = guard.flush();- }- }- });+ let (reader_handle, writer_handle) = io.spawn(+ stdout_tx,+ writer_rx,+ crate::unix_io::StdinCloseBehavior::NoEof,+ );let (exit_tx, exit_rx) = oneshot::channel::<i32>();let exit_status = Arc::new(AtomicBool::new(false));diff --git a/codex-rs/utils/pty/src/tests.rs b/codex-rs/utils/pty/src/tests.rsindex 8a7ddbebfa..b3d732bf85 100644--- a/codex-rs/utils/pty/src/tests.rs+++ b/codex-rs/utils/pty/src/tests.rs@@ -873,6 +873,314 @@ async fn pipe_drop_reaps_child() -> anyhow::Result<()> {Ok(())}+#[cfg(unix)]+enum PtyShutdown {+ Terminate,+ Drop,+}++#[cfg(unix)]+fn assert_pty_shutdown_with_detached_child(+ inherited_fds: &[i32],+ shutdown: PtyShutdown,+) -> anyhow::Result<()> {+ let Some(python) = find_python() else {+ eprintln!("python not found; skipping detached PTY shutdown test");+ return Ok(());+ };+ let runtime = tokio::runtime::Builder::new_current_thread()+ .enable_all()+ .build()?;+ let (session, child_pid) = runtime.block_on(async {+ let marker = "__codex_detached_pid:";+ // The detached child retains the slave descriptors but outlives the+ // original process group. Its alarm bounds a regressed runtime drop.+ let script = format!(+ r"import os, select, signal, time, tty+signal.alarm(10)+if os.fork() == 0:+ os.setsid()+ signal.signal(signal.SIGHUP, signal.SIG_IGN)+ signal.alarm(10)+ tty.setraw(0)+ print('{marker}' + str(os.getpid()), flush=True)+ select.select([0], [], [])+ print('__codex_input_ready__', flush=True)+ time.sleep(10)+ os._exit(0)+time.sleep(10)+"+ );+ let env_map: HashMap<String, String> = std::env::vars().collect();+ let spawned = spawn_pty_process(+ &python,+ &["-c".to_string(), script],+ Path::new("."),+ &env_map,+ &None,+ TerminalSize::default(),+ inherited_fds,+ )+ .await?;+ let (session, mut output_rx, exit_rx) = combine_spawned_output(spawned);+ let child_pid = wait_for_marker_pid(&mut output_rx, marker, /*timeout_ms*/ 2_000).await?;+ let writer = session.writer_sender();+ writer.send(vec![b'x'; 1024 * 1024]).await?;+ writer.send(b"pending".to_vec()).await?;+ // The slave reports readable input without consuming it; the first write+ // exceeds terminal capacity, so the second chunk must remain queued.+ wait_for_output_contains(+ &mut output_rx,+ "__codex_input_ready__",+ /*timeout_ms*/ 2_000,+ )+ .await?;+ assert_eq!(writer.capacity(), writer.max_capacity() - 1);+ drop(writer);+ let session = match shutdown {+ PtyShutdown::Terminate => {+ session.terminate();+ Some(session)+ }+ PtyShutdown::Drop => {+ drop(session);+ None+ }+ };+ tokio::time::timeout(std::time::Duration::from_secs(2), exit_rx).await??;+ Ok::<_, anyhow::Error>((session, child_pid))+ })?;++ let started = std::time::Instant::now();+ drop(runtime);+ let elapsed = started.elapsed();+ let detached_child_alive = process_exists(child_pid)?;+ let _ = unsafe { libc::kill(child_pid, libc::SIGKILL) };+ drop(session);+ assert!(+ elapsed < std::time::Duration::from_secs(2),+ "runtime shutdown waited for detached PTY child: {elapsed:?}"+ );+ assert!(+ detached_child_alive,+ "detached child exited before runtime shutdown"+ );+ Ok(())+}++#[cfg(unix)]+#[test]+fn pty_spawn_without_io_driver_returns_error() -> anyhow::Result<()> {+ use std::os::fd::AsRawFd;++ let runtime = tokio::runtime::Builder::new_current_thread()+ .enable_time()+ .build()?;+ let preserved_fd = std::fs::File::open("/dev/null")?;+ let env_map: HashMap<String, String> = std::env::vars().collect();+ let (program, args) = shell_command("true");+ for inherited_fds in [&[][..], &[preserved_fd.as_raw_fd()][..]] {+ let Err(error) = runtime.block_on(spawn_pty_process(+ &program,+ &args,+ Path::new("."),+ &env_map,+ &None,+ TerminalSize::default(),+ inherited_fds,+ )) else {+ anyhow::bail!("PTY spawn succeeded without a Tokio I/O driver");+ };+ assert_eq!(+ error.to_string(),+ "PTY I/O requires a Tokio runtime with I/O enabled"+ );+ }+ Ok(())+}++#[cfg(unix)]+#[test]+fn pty_terminate_allows_runtime_shutdown_with_detached_child() -> anyhow::Result<()> {+ assert_pty_shutdown_with_detached_child(&[], PtyShutdown::Terminate)+}++#[cfg(unix)]+#[test]+fn pty_drop_allows_runtime_shutdown_with_detached_child() -> anyhow::Result<()> {+ assert_pty_shutdown_with_detached_child(&[], PtyShutdown::Drop)+}++#[cfg(unix)]+#[test]+fn pty_preserving_fds_terminate_allows_runtime_shutdown_with_detached_child() -> anyhow::Result<()>+{+ use std::os::fd::AsRawFd;++ let preserved_fd = std::fs::File::open("/dev/null")?;+ assert_pty_shutdown_with_detached_child(&[preserved_fd.as_raw_fd()], PtyShutdown::Terminate)+}++#[cfg(unix)]+#[test]+fn pty_preserving_fds_drop_allows_runtime_shutdown_with_detached_child() -> anyhow::Result<()> {+ use std::os::fd::AsRawFd;++ let preserved_fd = std::fs::File::open("/dev/null")?;+ assert_pty_shutdown_with_detached_child(&[preserved_fd.as_raw_fd()], PtyShutdown::Drop)+}++#[cfg(unix)]+#[test]+fn pty_terminate_allows_runtime_shutdown_with_full_output_channel() -> anyhow::Result<()> {+ use std::os::fd::AsRawFd;++ let Some(python) = find_python() else {+ eprintln!("python not found; skipping PTY output backpressure test");+ return Ok(());+ };+ let preserved_fd = std::fs::File::open("/dev/null")?;+ for inherited_fds in [&[][..], &[preserved_fd.as_raw_fd()][..]] {+ let runtime = tokio::runtime::Builder::new_current_thread()+ .enable_all()+ .build()?;+ let (session, stdout_rx) = runtime.block_on(async {+ let env_map: HashMap<String, String> = std::env::vars().collect();+ let script =+ "import os, signal\nsignal.alarm(10)\nwhile True:\n os.write(1, b'x' * 8192)\n";+ let SpawnedProcess {+ session,+ stdout_rx,+ exit_rx,+ ..+ } = spawn_pty_process(+ &python,+ &["-c".to_string(), script.to_string()],+ Path::new("."),+ &env_map,+ &None,+ TerminalSize::default(),+ inherited_fds,+ )+ .await?;+ tokio::time::timeout(std::time::Duration::from_secs(2), async {+ while stdout_rx.len() < stdout_rx.max_capacity() {+ tokio::time::sleep(std::time::Duration::from_millis(10)).await;+ }+ })+ .await?;+ tokio::time::sleep(std::time::Duration::from_millis(20)).await;+ session.terminate();+ tokio::time::timeout(std::time::Duration::from_secs(2), exit_rx).await??;+ Ok::<_, anyhow::Error>((session, stdout_rx))+ })?;++ // Keep the receiver alive through runtime shutdown. An OS-thread+ // watchdog releases a regressed blocking_send without a Tokio timer.+ let (shutdown_tx, shutdown_rx) = std::sync::mpsc::channel();+ let receiver_guard = std::thread::spawn(move || {+ let _ = shutdown_rx.recv_timeout(std::time::Duration::from_secs(3));+ drop(stdout_rx);+ });+ let started = std::time::Instant::now();+ drop(runtime);+ let elapsed = started.elapsed();+ let _ = shutdown_tx.send(());+ receiver_guard+ .join()+ .map_err(|_| anyhow::anyhow!("output receiver watchdog panicked"))?;+ drop(session);+ assert!(+ elapsed < std::time::Duration::from_secs(2),+ "runtime shutdown waited on a full PTY output channel: {elapsed:?}"+ );+ }+ Ok(())+}++#[cfg(unix)]+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn pty_dropped_output_receiver_keeps_draining_child() -> anyhow::Result<()> {+ use std::os::fd::AsRawFd;++ let Some(python) = find_python() else {+ eprintln!("python not found; skipping PTY dropped output receiver test");+ return Ok(());+ };+ let preserved_fd = std::fs::File::open("/dev/null")?;+ let env_map: HashMap<String, String> = std::env::vars().collect();+ let script =+ "import signal, sys\nsignal.alarm(10)\nsys.stdout.buffer.write(b'x' * (4 * 1024 * 1024))";+ for inherited_fds in [&[][..], &[preserved_fd.as_raw_fd()][..]] {+ let SpawnedProcess {+ session: _session,+ stdout_rx,+ exit_rx,+ ..+ } = spawn_pty_process(+ &python,+ &["-c".to_string(), script.to_string()],+ Path::new("."),+ &env_map,+ &None,+ TerminalSize::default(),+ inherited_fds,+ )+ .await?;+ drop(stdout_rx);+ let code = tokio::time::timeout(std::time::Duration::from_secs(2), exit_rx).await??;+ assert_eq!(code, 0, "child should finish even when output is discarded");+ }+ Ok(())+}++#[cfg(unix)]+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn pty_close_stdin_preserves_large_input_and_delivers_eof() -> anyhow::Result<()> {+ let Some(python) = find_python() else {+ eprintln!("python not found; skipping PTY input backpressure and EOF test");+ return Ok(());+ };+ let script = r"import signal, sys, termios, time+signal.alarm(10)+attrs = termios.tcgetattr(0)+attrs[3] &= ~termios.ECHO+termios.tcsetattr(0, termios.TCSANOW, attrs)+print('__ready__', flush=True)+time.sleep(0.2)+data = sys.stdin.buffer.read()+# Closing the portable writer appends a newline before VEOF.+assert data == b'0123456789abcdefghijklmnopqrstuvwxyz\n' * 32768 + b'\n', len(data)+print('__complete__', flush=True)+";+ let env_map: HashMap<String, String> = std::env::vars().collect();+ let spawned = spawn_pty_process(+ &python,+ &["-c".to_string(), script.to_string()],+ Path::new("."),+ &env_map,+ &None,+ TerminalSize::default(),+ &[],+ )+ .await?;+ let (session, mut output_rx, exit_rx) = combine_spawned_output(spawned);+ wait_for_output_contains(&mut output_rx, "__ready__", /*timeout_ms*/ 2_000).await?;+ let writer = session.writer_sender();+ writer+ .send(b"0123456789abcdefghijklmnopqrstuvwxyz\n".repeat(32_768))+ .await?;+ drop(writer);+ session.close_stdin();++ let (output, code) = collect_output_until_exit(output_rx, exit_rx, /*timeout_ms*/ 5_000).await;+ assert_eq!(+ (code, String::from_utf8_lossy(&output).trim()),+ (0, "__complete__")+ );+ Ok(())+}+#[cfg(unix)]#[test]fn pty_terminate_reaps_child_when_waiter_is_queued() -> anyhow::Result<()> {diff --git a/codex-rs/utils/pty/src/unix_io.rs b/codex-rs/utils/pty/src/unix_io.rsnew file mode 100644index 0000000000..315c2b656a--- /dev/null+++ b/codex-rs/utils/pty/src/unix_io.rs@@ -0,0 +1,109 @@+use std::fs::File;+use std::io;+use std::io::Read;+use std::io::Write;+use std::os::fd::AsRawFd;+use std::os::fd::BorrowedFd;+use std::os::fd::RawFd;+use std::sync::Arc;++use tokio::io::Interest;+use tokio::io::unix::AsyncFd;+use tokio::sync::mpsc;+use tokio::task::JoinHandle;++pub(crate) enum StdinCloseBehavior {+ SendEof,+ NoEof,+}++pub(crate) struct PtyIo {+ fd: Arc<AsyncFd<File>>,+}++impl PtyIo {+ pub(crate) fn new(master_fd: RawFd) -> io::Result<Self> {+ // The PTY owner remains alive while its descriptor is duplicated.+ let fd = unsafe { BorrowedFd::borrow_raw(master_fd) }.try_clone_to_owned()?;+ let flags = unsafe { libc::fcntl(fd.as_raw_fd(), libc::F_GETFL) };+ if flags == -1+ || unsafe { libc::fcntl(fd.as_raw_fd(), libc::F_SETFL, flags | libc::O_NONBLOCK) } == -1+ {+ return Err(io::Error::last_os_error());+ }+ // Duplicates share O_NONBLOCK, so both reads and writes must use readiness.+ // Async tasks can be aborted even when a detached child keeps the PTY open+ // or the output channel is full; blocking read/send tasks cannot.+ // AsyncFd panics if the current runtime has no I/O driver.+ let fd = std::panic::catch_unwind(move || AsyncFd::new(File::from(fd)))+ .map_err(|_| io::Error::other("PTY I/O requires a Tokio runtime with I/O enabled"))??;+ Ok(Self { fd: Arc::new(fd) })+ }++ pub(crate) fn spawn(+ self,+ stdout_tx: mpsc::Sender<Vec<u8>>,+ mut writer_rx: mpsc::Receiver<Vec<u8>>,+ stdin_close: StdinCloseBehavior,+ ) -> (JoinHandle<()>, JoinHandle<()>) {+ let fd = self.fd;+ let reader = Arc::clone(&fd);+ let reader_handle = tokio::spawn(async move {+ let mut buf = [0u8; 8_192];+ loop {+ match reader+ .async_io(Interest::READABLE, |mut file| file.read(&mut buf))+ .await+ {+ Ok(0) => break,+ Ok(count) => {+ // Output caps may close the receiver before the child exits.+ let _ = stdout_tx.send(buf[..count].to_vec()).await;+ }+ Err(err) if err.kind() == io::ErrorKind::Interrupted => continue,+ // Unix PTYs may report EIO rather than EOF when the slave closes.+ Err(_) => break,+ }+ }+ });+ let writer_handle = tokio::spawn(async move {+ while let Some(bytes) = writer_rx.recv().await {+ if write_all(&fd, &bytes).await.is_err() {+ return;+ }+ }+ match stdin_close {+ StdinCloseBehavior::SendEof => {+ // Preserve portable-pty's newline + current VEOF on stdin close,+ // including when the terminal input queue requires waiting.+ let mut termios = std::mem::MaybeUninit::<libc::termios>::uninit();+ if unsafe { libc::tcgetattr(fd.get_ref().as_raw_fd(), termios.as_mut_ptr()) }+ == 0+ {+ let eof = unsafe { termios.assume_init() }.c_cc[libc::VEOF];+ if eof != 0 {+ let _ = write_all(&fd, &[b'\n', eof]).await;+ }+ }+ }+ StdinCloseBehavior::NoEof => {}+ }+ });+ (reader_handle, writer_handle)+ }+}++async fn write_all(fd: &AsyncFd<File>, mut bytes: &[u8]) -> io::Result<()> {+ while !bytes.is_empty() {+ match fd+ .async_io(Interest::WRITABLE, |mut file| file.write(bytes))+ .await+ {+ Ok(0) => return Err(io::ErrorKind::WriteZero.into()),+ Ok(count) => bytes = &bytes[count..],+ Err(err) if err.kind() == io::ErrorKind::Interrupted => continue,+ Err(err) => return Err(err),+ }+ }+ Ok(())+}