Lightweight coding agent that runs in your terminal
Rust
Prefer the Windows clipboard and bound copy attempts on WSL (#53453)
Eric Traut0c329ad2c9d5
diff --git a/codex-rs/tui/src/clipboard_copy.rs b/codex-rs/tui/src/clipboard_copy.rsindex 591c88f3f4..4d229364bc 100644--- a/codex-rs/tui/src/clipboard_copy.rs+++ b/codex-rs/tui/src/clipboard_copy.rs@@ -1,6 +1,6 @@//! Clipboard copy backend for the TUI's `/copy` command and `Ctrl+O` hotkey.//!-//! Local copying uses the native clipboard, with WSL PowerShell as a fallback.+//! Local copying uses the native clipboard, or the Windows clipboard directly on WSL.//! In tmux and Herdr, also forward to the attached terminal so clients attached after Codex//! started receive the copy. Over SSH without a multiplexer, send OSC 52 directly.//!@@ -22,6 +22,7 @@pub(crate) mod primary;mod tmux;pub(crate) mod worker;+mod wsl;use base64::Engine;use std::io::Write;@@ -98,10 +99,24 @@ fn copy_to_clipboard(begin_delivery: impl Fn() -> Result<(), String>,osc52: impl Fn(&str) -> Result<(), String>,) -> Result<CopyOutcome, String> {+ let wsl_deadline = std::time::Instant::now() + std::time::Duration::from_secs(/*secs*/ 5);+ let environment = CopyEnvironment {+ herdr_session: std::env::var("HERDR_ENV").is_ok_and(|value| value == "1"),+ ssh_session: is_ssh_session(),+ wsl_session: is_wsl_session(),+ tmux_session: is_tmux_session(),+ };#[cfg(not(target_os = "android"))]let native_copy = {- let clipboard = arboard::Clipboard::new();- move |text: &str, html: Option<&str>| arboard_copy(clipboard, text, html)+ // Never contact WSLg before trying Windows: even native setup can block forever.+ let clipboard = (!environment.wsl_session).then(arboard::Clipboard::new);+ move |text: &str, html: Option<&str>| {+ let clipboard = match clipboard {+ Some(clipboard) => clipboard.map_err(|e| format!("clipboard unavailable: {e}"))?,+ None => wsl::native_clipboard()?,+ };+ arboard_copy(clipboard, text, html)+ }};#[cfg(target_os = "android")]let native_copy = |_text: &str, _html: Option<&str>| {@@ -113,16 +128,11 @@ fn copy_to_clipboard(copy_to_clipboard_with(text,format,- CopyEnvironment {- herdr_session: std::env::var("HERDR_ENV").is_ok_and(|value| value == "1"),- ssh_session: is_ssh_session(),- wsl_session: is_wsl_session(),- tmux_session: is_tmux_session(),- },+ environment,tmux_clipboard_copy,osc52,native_copy,- wsl_clipboard_copy,+ |text| wsl::copy(text, wsl_deadline),)}@@ -198,22 +208,25 @@ fn copy_to_clipboard_with(osc52_copy_fn(text)}};- let html = match format {- CopyFormat::PlainText => None,- CopyFormat::Markdown => Some(crate::clipboard_html::render_markdown(text)),- CopyFormat::MarkdownSelection(source) => {- Some(crate::clipboard_html::render_markdown(&source))- }+ let native_copy = || {+ let html = match format {+ CopyFormat::PlainText => None,+ CopyFormat::Markdown => Some(crate::clipboard_html::render_markdown(text)),+ CopyFormat::MarkdownSelection(source) => {+ Some(crate::clipboard_html::render_markdown(&source))+ }+ };+ arboard_copy_fn(text, html.as_deref()).map_err(|error| format!("native clipboard: {error}"))};- let native_result = arboard_copy_fn(text, html.as_deref()).or_else(|native_error| {- if environment.wsl_session {- wsl_copy_fn(text).map(|()| None).map_err(|wsl_error| {- format!("native clipboard: {native_error}; WSL fallback: {wsl_error}")+ let native_result = if environment.wsl_session {+ wsl_copy_fn(text).map(|()| None).or_else(|windows_error| {+ native_copy().map_err(|native_error| {+ format!("Windows clipboard: {windows_error}; {native_error}")})- } else {- Err(format!("native clipboard: {native_error}"))- }- });+ })+ } else {+ native_copy()+ };// Copy natively first: an X11 SelectionClear from a terminal write can otherwise// race with arboard reusing its ownership window and clear the new native data.// Persistent multiplexer sessions may gain remote clients after Codex starts, so still@@ -255,11 +268,10 @@ pub(crate) fn is_wsl_session() -> bool {/// Write to the native clipboard. The TUI owns any process-wide stderr redirection.#[cfg(not(target_os = "android"))]fn arboard_copy(- clipboard: Result<arboard::Clipboard, arboard::Error>,+ mut clipboard: arboard::Clipboard,text: &str,html: Option<&str>,) -> Result<Option<ClipboardLease>, String> {- let mut clipboard = clipboard.map_err(|e| format!("clipboard unavailable: {e}"))?;match html {Some(html) => clipboard.set_html(html, Some(text))@@ -278,62 +290,6 @@ fn arboard_copy(}}-/// Copy text into the Windows clipboard from a WSL process.-#[cfg(target_os = "linux")]-fn wsl_clipboard_copy(text: &str) -> Result<(), String> {- let executable = codex_utils_path::system_executable("powershell.exe")- .ok_or_else(|| "PowerShell is unavailable in the system PATH".to_string())?;- let path = codex_utils_path::system_path()- .map_err(|error| format!("failed to resolve system PATH: {error}"))?;- let mut child = std::process::Command::new(executable)- .env("PATH", path)- .stdin(std::process::Stdio::piped())- .stdout(std::process::Stdio::null())- .stderr(std::process::Stdio::piped())- .args([- "-NoProfile",- "-Command",- "[Console]::InputEncoding = [System.Text.Encoding]::UTF8; $ErrorActionPreference = 'Stop'; $text = [Console]::In.ReadToEnd(); Set-Clipboard -Value $text",- ])- .spawn()- .map_err(|e| format!("failed to spawn powershell.exe: {e}"))?;-- let Some(mut stdin) = child.stdin.take() else {- let _ = child.kill();- let _ = child.wait();- return Err("failed to open powershell.exe stdin".to_string());- };-- if let Err(err) = stdin.write_all(text.as_bytes()) {- let _ = child.kill();- let _ = child.wait();- return Err(format!("failed to write to powershell.exe: {err}"));- }-- drop(stdin);-- let output = child- .wait_with_output()- .map_err(|e| format!("failed to wait for powershell.exe: {e}"))?;-- if output.status.success() {- Ok(())- } else {- let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();- if stderr.is_empty() {- let status = output.status;- Err(format!("powershell.exe exited with status {status}"))- } else {- Err(format!("powershell.exe failed: {stderr}"))- }- }-}--#[cfg(not(target_os = "linux"))]-fn wsl_clipboard_copy(_text: &str) -> Result<(), String> {- Err("WSL clipboard fallback unavailable on this platform".to_string())-}-/// Write text to the clipboard via the OSC 52 terminal escape sequence.fn osc52_copy(text: &str) -> Result<(), String> {let sequence = osc52_sequence(text, std::env::var_os("TMUX").is_some())?;@@ -468,7 +424,7 @@ mod tests {}#[test]- fn ssh_attempts_both_native_and_osc52() {+ fn ssh_on_wsl_attempts_windows_and_osc52() {let tmux_calls = Cell::new(/*value*/ 0_u8);let osc_calls = Cell::new(/*value*/ 0_u8);let native_calls = Cell::new(/*value*/ 0_u8);@@ -499,8 +455,8 @@ mod tests {assert!(matches!(result, Ok(CopyOutcome::Copied(None))));assert_eq!(tmux_calls.get(), 0);assert_eq!(osc_calls.get(), 1);- assert_eq!(native_calls.get(), 1);- assert_eq!(wsl_calls.get(), 0);+ assert_eq!(native_calls.get(), 0);+ assert_eq!(wsl_calls.get(), 1);}#[test]@@ -536,7 +492,7 @@ mod tests {};assert_eq!(error,- "native clipboard: native unavailable; WSL fallback: powershell unavailable; terminal clipboard: blocked"+ "Windows clipboard: powershell unavailable; native clipboard: native unavailable; terminal clipboard: blocked");assert_eq!(tmux_calls.get(), 0);assert_eq!(osc_calls.get(), 1);@@ -545,7 +501,7 @@ mod tests {}#[test]- fn ssh_inside_tmux_attempts_both_native_and_tmux() {+ fn ssh_on_wsl_inside_tmux_attempts_windows_and_tmux() {let tmux_calls = Cell::new(/*value*/ 0_u8);let osc_calls = Cell::new(/*value*/ 0_u8);let native_calls = Cell::new(/*value*/ 0_u8);@@ -575,8 +531,8 @@ mod tests {assert!(matches!(result, Ok(CopyOutcome::Copied(None))));assert_eq!(tmux_calls.get(), 1);assert_eq!(osc_calls.get(), 0);- assert_eq!(native_calls.get(), 1);- assert_eq!(wsl_calls.get(), 0);+ assert_eq!(native_calls.get(), 0);+ assert_eq!(wsl_calls.get(), 1);}#[test]@@ -610,8 +566,8 @@ mod tests {assert!(matches!(result, Ok(CopyOutcome::Copied(None))));assert_eq!(tmux_calls.get(), 1);assert_eq!(osc_calls.get(), 1);- assert_eq!(native_calls.get(), 1);- assert_eq!(wsl_calls.get(), 0);+ assert_eq!(native_calls.get(), 0);+ assert_eq!(wsl_calls.get(), 1);}#[test]@@ -629,10 +585,6 @@ mod tests {let Err(error) = result else {panic!("expected tmux and OSC 52 errors");};- assert_eq!(- error,- "native clipboard: native unavailable; WSL fallback: powershell unavailable; terminal clipboard: tmux clipboard: tmux unavailable; OSC 52 fallback: osc blocked"- );insta::assert_snapshot!("all_copy_backends_fail", error);}@@ -644,7 +596,7 @@ mod tests {let result = copy_to_clipboard_with("hello",CopyFormat::PlainText,- local_wsl_environment(),+ local_environment(),|_| Ok(()),|_| {osc_calls.set(osc_calls.get() + 1);@@ -681,19 +633,21 @@ mod tests {Some("<p><strong>hello</strong> /repo/my_notes!.txt</p>\n"),),] {- let result = copy_to_clipboard_with(- text,- format,- local_environment(),- |_| panic!("native copy should succeed"),- |_| panic!("native copy should succeed"),- |actual_text, actual_html| {- assert_eq!((actual_text, actual_html), (text, html));- Ok(None)- },- |_| panic!("native copy should succeed"),- );- assert!(matches!(result, Ok(CopyOutcome::Copied(None))));+ for environment in [local_environment(), local_wsl_environment()] {+ let result = copy_to_clipboard_with(+ text,+ format.clone(),+ environment,+ |_| panic!("native copy should succeed"),+ |_| panic!("native copy should succeed"),+ |actual_text, actual_html| {+ assert_eq!((actual_text, actual_html), (text, html));+ Ok(Some(super::ClipboardLease::test()))+ },+ |_| Err("Windows clipboard unavailable".into()),+ );+ assert!(matches!(result, Ok(CopyOutcome::Copied(Some(_)))));+ }}}@@ -767,7 +721,7 @@ mod tests {}#[test]- fn local_wsl_native_failure_uses_powershell_and_skips_osc52_on_success() {+ fn local_wsl_uses_windows_and_skips_osc52_on_success() {let osc_calls = Cell::new(/*value*/ 0_u8);let native_calls = Cell::new(/*value*/ 0_u8);let wsl_calls = Cell::new(/*value*/ 0_u8);@@ -792,12 +746,12 @@ mod tests {assert!(matches!(result, Ok(CopyOutcome::Copied(None))));assert_eq!(osc_calls.get(), 0);- assert_eq!(native_calls.get(), 1);+ assert_eq!(native_calls.get(), 0);assert_eq!(wsl_calls.get(), 1);}#[test]- fn local_wsl_falls_back_to_osc52_when_native_and_powershell_fail() {+ fn local_wsl_falls_back_to_osc52_when_powershell_fails() {let osc_calls = Cell::new(/*value*/ 0_u8);let native_calls = Cell::new(/*value*/ 0_u8);let wsl_calls = Cell::new(/*value*/ 0_u8);@@ -863,7 +817,7 @@ mod tests {}#[test]- fn local_wsl_reports_native_powershell_and_osc52_errors_when_all_fail() {+ fn local_wsl_reports_windows_and_osc52_errors_when_all_fail() {let osc_calls = Cell::new(/*value*/ 0_u8);let native_calls = Cell::new(/*value*/ 0_u8);let wsl_calls = Cell::new(/*value*/ 0_u8);@@ -887,11 +841,11 @@ mod tests {);let Err(error) = result else {- panic!("expected native, WSL, and OSC 52 errors");+ panic!("expected Windows and OSC 52 errors");};assert_eq!(error,- "native clipboard: native unavailable; WSL fallback: powershell unavailable; terminal clipboard: osc blocked"+ "Windows clipboard: powershell unavailable; native clipboard: native unavailable; terminal clipboard: osc blocked");assert_eq!(osc_calls.get(), 1);assert_eq!(native_calls.get(), 1);diff --git a/codex-rs/tui/src/clipboard_copy/wsl.rs b/codex-rs/tui/src/clipboard_copy/wsl.rsnew file mode 100644index 0000000000..d1c89cc9e3--- /dev/null+++ b/codex-rs/tui/src/clipboard_copy/wsl.rs@@ -0,0 +1,177 @@+//! WSL text copies with Windows interop use the Windows clipboard without contacting the display.+//! Bound discovery, input, and exit; give fallback native setup its own short deadline.+//! Never release the worker while a writer can still run.++#[cfg(target_os = "linux")]+use std::ffi::OsString;+#[cfg(target_os = "linux")]+use std::path::PathBuf;+#[cfg(target_os = "linux")]+use std::sync::Mutex;+#[cfg(target_os = "linux")]+use std::sync::mpsc;+#[cfg(any(target_os = "linux", all(test, unix)))]+use std::time::Instant;++#[cfg(target_os = "linux")]+type Pending<T> = Mutex<Option<mpsc::Receiver<Result<T, String>>>>;++#[cfg(target_os = "linux")]+pub(super) fn copy(text: &str, deadline: Instant) -> Result<(), String> {+ static DISCOVERY: Pending<(PathBuf, OsString)> = Mutex::new(None);+ let (executable, path) = read_only_setup(&DISCOVERY, deadline, || {+ let executable = codex_utils_path::system_executable("powershell.exe")+ .ok_or("PowerShell is unavailable in the system PATH")?;+ let path = codex_utils_path::system_path()+ .map_err(|error| format!("failed to resolve system PATH: {error}"))?;+ Ok((executable, path))+ })?;+ let status = tokio::runtime::Builder::new_current_thread()+ .enable_all()+ .build()+ .map_err(|error| format!("could not start Windows clipboard writer: {error}"))?+ .block_on(write_command(command(&executable, &path), text, deadline))?;+ if status.success() {+ Ok(())+ } else {+ Err(format!("powershell.exe exited with status {status}"))+ }+}++#[cfg(any(target_os = "linux", all(test, unix)))]+fn command(executable: &std::path::Path, path: &std::ffi::OsStr) -> tokio::process::Command {+ // Spawn only the native shell here: directly spawning a Windows exe can block on WSL.+ let mut command = tokio::process::Command::new("/bin/sh");+ command+ .env("PATH", path)+ .args(["-c", r#"exec "$@""#, "codex-wsl-copy"])+ .arg(executable)+ // Preserve the released command signature: trusted adapters may match it exactly.+ .args([+ "-NoProfile",+ "-Command",+ "[Console]::InputEncoding = [System.Text.Encoding]::UTF8; $ErrorActionPreference = 'Stop'; $text = [Console]::In.ReadToEnd(); Set-Clipboard -Value $text",+ ]);+ command+}++#[cfg(not(target_os = "linux"))]+pub(super) fn copy(_text: &str, _deadline: std::time::Instant) -> Result<(), String> {+ Err("Windows clipboard unavailable on this platform".into())+}++#[cfg(target_os = "linux")]+pub(super) fn native_clipboard() -> Result<arboard::Clipboard, String> {+ static NATIVE: Pending<arboard::Clipboard> = Mutex::new(None);+ // Windows discovery may have exhausted its budget. Do not starve a healthy WSLg.+ let deadline = Instant::now() + std::time::Duration::from_secs(/*secs*/ 1);+ read_only_setup(&NATIVE, deadline, || {+ arboard::Clipboard::new().map_err(|error| format!("clipboard unavailable: {error}"))+ })+}++// Discovery and WSLg setup may block forever. Keep at most one outstanding task of each+// kind and reuse its result after a timeout. Neither task may capture text or write a clipboard.+#[cfg(target_os = "linux")]+fn read_only_setup<T: Send + 'static>(+ pending: &Pending<T>,+ deadline: Instant,+ setup: impl FnOnce() -> Result<T, String> + Send + 'static,+) -> Result<T, String> {+ let remaining = deadline+ .checked_duration_since(Instant::now())+ .ok_or("clipboard setup timed out")?;+ let mut pending = pending.lock().map_err(|error| error.to_string())?;+ if pending.is_none() {+ let (tx, rx) = mpsc::channel();+ std::thread::Builder::new()+ .name("wsl-clipboard-setup".into())+ .spawn(move || {+ let _ = tx.send(setup());+ })+ .map_err(|error| format!("could not start clipboard setup: {error}"))?;+ *pending = Some(rx);+ }+ let result = pending+ .as_ref()+ .ok_or("clipboard setup unavailable")?+ .recv_timeout(remaining);+ if !matches!(result, Err(mpsc::RecvTimeoutError::Timeout)) {+ *pending = None;+ }+ result.map_err(|error| format!("clipboard setup: {error}"))?+}++#[cfg(not(any(target_os = "linux", target_os = "android")))]+pub(super) fn native_clipboard() -> Result<arboard::Clipboard, String> {+ Err("WSL native clipboard unavailable on this platform".into())+}++#[cfg(any(target_os = "linux", all(test, unix)))]+async fn write_command(+ mut command: tokio::process::Command,+ text: &str,+ deadline: Instant,+) -> Result<std::process::ExitStatus, String> {+ use std::process::Stdio;+ use tokio::io::AsyncWriteExt;++ if Instant::now() >= deadline {+ return Err("Windows clipboard writer timed out".into());+ }+ let mut child = command+ .process_group(/*pgroup*/ 0)+ .stdin(Stdio::piped())+ .stdout(Stdio::null())+ // Do not expose clipboard contents from PowerShell errors or let its stderr block input.+ .stderr(Stdio::null())+ .kill_on_drop(/*kill_on_drop*/ true)+ .spawn()+ .map_err(|error| format!("failed to spawn powershell.exe: {error}"))?;+ // WSL process spawn itself may stall. Do not write after a late spawn.+ let result = tokio::time::timeout_at(deadline.into(), async {+ if Instant::now() >= deadline {+ return Err("Windows clipboard writer timed out".into());+ }+ child+ .stdin+ .as_mut()+ .ok_or("failed to open powershell.exe stdin")?+ .write_all(text.as_bytes())+ .await+ .map_err(|error| format!("failed to write to powershell.exe: {error}"))?;+ drop(child.stdin.take());+ child+ .wait()+ .await+ .map_err(|error| format!("failed to wait for powershell.exe: {error}"))+ })+ .await+ .unwrap_or_else(|_| Err("Windows clipboard writer timed out".into()));+ match result {+ Ok(status) => Ok(status),+ Err(error) => {+ // Keep partially written stdin open until kill: PowerShell copies on EOF.+ // If kill fails, still wait. Releasing the worker earlier could allow an old copy+ // to overwrite a newer one. kill_on_drop alone does not guarantee reaping.+ if let Some(pid) = child.id() {+ // SAFETY: process_group(0) assigned the owned, unreaped child its own group.+ // An installed adapter may have spawned its own writer. Stop the whole group.+ unsafe { libc::killpg(pid as libc::pid_t, libc::SIGKILL) };+ }+ let _ = child.start_kill();+ // wait() closes child.stdin itself, even if kill failed. Never give the+ // writer EOF with partial input while waiting for it to stop.+ let _stdin = child.stdin.take();+ child+ .wait()+ .await+ .map_err(|error| format!("failed to reap powershell.exe: {error}"))?;+ Err(error)+ }+ }+}++#[cfg(all(test, unix))]+#[path = "wsl_tests.rs"]+mod tests;diff --git a/codex-rs/tui/src/clipboard_copy/wsl_tests.rs b/codex-rs/tui/src/clipboard_copy/wsl_tests.rsnew file mode 100644index 0000000000..895fcc7616--- /dev/null+++ b/codex-rs/tui/src/clipboard_copy/wsl_tests.rs@@ -0,0 +1,99 @@+use super::write_command;+use pretty_assertions::assert_eq;+use std::time::Duration;+use std::time::Instant;++#[tokio::test]+async fn installed_adapter_receives_compatible_command_and_never_copies_expired_work() {+ use std::os::unix::fs::PermissionsExt;++ let dir = tempfile::tempdir().unwrap();+ let root = dir.path().canonicalize().unwrap();+ let executable = root.join("powershell.exe");+ std::fs::write(+ &executable,+ r#"#!/bin/sh+[ "$#" -eq 3 ] && [ "$1" = '-NoProfile' ] && [ "$2" = '-Command' ] || exit 46+[ "$3" = "[Console]::InputEncoding = [System.Text.Encoding]::UTF8; \$ErrorActionPreference = 'Stop'; \$text = [Console]::In.ReadToEnd(); Set-Clipboard -Value \$text" ] || exit 47+/bin/cat > "$COPY_OUTPUT"+"#,+ ).unwrap();+ std::fs::set_permissions(&executable, std::fs::Permissions::from_mode(0o755)).unwrap();+ let output = root.join("clipboard");+ let mut command = super::command(&executable, root.as_os_str());+ command.env("COPY_OUTPUT", &output);+ let text = " café 🦀\r\n\t".repeat(/*n*/ 32_768);+ let status = write_command(+ command,+ &text,+ Instant::now() + Duration::from_secs(/*secs*/ 5),+ )+ .await+ .unwrap();+ assert!(status.success(), "{status}");+ assert_eq!(std::fs::read_to_string(&output).unwrap(), text);+ let mut command = super::command(&executable, root.as_os_str());+ command.env("COPY_OUTPUT", &output);+ assert_eq!(+ write_command(command, "late", Instant::now()).await,+ Err("Windows clipboard writer timed out".into())+ );+ assert_eq!(std::fs::read_to_string(output).unwrap(), text);+}++#[tokio::test]+async fn stalled_input_and_stalled_exit_are_reaped_before_returning() {+ let dir = tempfile::tempdir().unwrap();+ // Large input blocks on the pipe; small input fits, so the worker reaches the exit wait.+ for (stage, text, script) in [+ (+ "input",+ "x".repeat(/*n*/ 1_048_576),+ "echo $$ > \"$1\"; exec sleep 30",+ ),+ ("exit", "small".into(), "echo $$ > \"$1\"; exec sleep 30"),+ // An adapter waiting on a subprocess must stop that subprocess too.+ (+ "subprocess",+ String::new(),+ "sh -c 'echo $$ > \"$1\"; exec sleep 30' sh \"$1\"; wait",+ ),+ ] {+ let pid_path = dir.path().join(format!("{stage}.pid"));+ let mut command = tokio::process::Command::new("sh");+ command.args(["-c", script, "sh"]).arg(&pid_path);+ let started = Instant::now();+ assert_eq!(+ write_command(command, &text, started + Duration::from_secs(/*secs*/ 1)).await,+ Err("Windows clipboard writer timed out".into())+ );+ assert!(+ started.elapsed() < Duration::from_secs(/*secs*/ 10),+ "{stage}: cleanup exceeded its budget: {:?}",+ started.elapsed()+ );+ let pid: libc::pid_t = std::fs::read_to_string(&pid_path)+ .unwrap()+ .trim()+ .parse()+ .unwrap();+ if stage == "subprocess" {+ // The grandchild must be stopped; only init can reap it. A zombie is+ // acceptable here and still responds to kill(pid, 0) until reaped.+ let output = std::process::Command::new("ps")+ .args(["-o", "stat=", "-p", &pid.to_string()])+ .output()+ .unwrap();+ let state = String::from_utf8(output.stdout).unwrap();+ let state = state.trim();+ assert!(state.is_empty() || state.starts_with('Z'), "state: {state}");+ } else {+ // SAFETY: Signal 0 observes this disposable child without modifying it.+ assert_eq!(unsafe { libc::kill(pid, 0) }, -1);+ assert_eq!(+ std::io::Error::last_os_error().raw_os_error(),+ Some(libc::ESRCH)+ );+ }+ }+}diff --git a/codex-rs/tui/src/snapshots/codex_tui__clipboard_copy__tests__all_copy_backends_fail.snap b/codex-rs/tui/src/snapshots/codex_tui__clipboard_copy__tests__all_copy_backends_fail.snapindex 5bf8b294a1..24faea6412 100644--- a/codex-rs/tui/src/snapshots/codex_tui__clipboard_copy__tests__all_copy_backends_fail.snap+++ b/codex-rs/tui/src/snapshots/codex_tui__clipboard_copy__tests__all_copy_backends_fail.snap@@ -1,5 +1,5 @@----source: codex-rs/tui/src/clipboard_copy.rs+source: tui/src/clipboard_copy.rsexpression: error----native clipboard: native unavailable; WSL fallback: powershell unavailable; terminal clipboard: tmux clipboard: tmux unavailable; OSC 52 fallback: osc blocked+Windows clipboard: powershell unavailable; native clipboard: native unavailable; terminal clipboard: tmux clipboard: tmux unavailable; OSC 52 fallback: osc blocked