[codex] Handle Ctrl-C for non-TTY unified exec (#26734)

## Why

A long-running unified exec process started with `tty: false` could not
be interrupted via `write_stdin`: ordinary non-TTY stdin writes are
rejected once stdin is closed, but an exact U+0003 payload should still
map to a process interrupt. The interrupt should flow through the same
process lifecycle path as a real signal so Codex preserves
process-reported output and exit metadata instead of fabricating a
Ctrl-C exit code or tearing down the session early.

## What Changed

- Add `process/signal` to exec-server with `ProcessSignal::Interrupt`
and an empty response.
- Add a non-consuming `ProcessHandle::signal` path for spawned
processes; on Unix it sends SIGINT to the process group and leaves
terminate/hard-kill unchanged.
- Route non-TTY U+0003 `write_stdin` through `process.signal(...)`
instead of `terminate`, then let the normal post-write collection path
drain output and observe exit.
- Add exec-server coverage where a shell `trap INT` handler prints the
signal and exits with its own code.
- Add unified exec coverage where a `tty: false` process traps SIGINT,
emits output, and exits with its own code.

## Validation

- `just test -p codex-exec-server
exec_process_signal_interrupts_process`
- `just test -p codex-exec-server`
- `just test -p codex-core
write_stdin_ctrl_c_interrupts_non_tty_session`

codex-rs/exec-server/src/client.rs

@@ -35,6 +35,7 @@ use crate::protocol::EXEC_EXITED_METHOD;
 use crate::protocol::EXEC_METHOD;
 use crate::protocol::EXEC_OUTPUT_DELTA_METHOD;
 use crate::protocol::EXEC_READ_METHOD;
+use crate::protocol::EXEC_SIGNAL_METHOD;
 use crate::protocol::EXEC_TERMINATE_METHOD;
 use crate::protocol::EXEC_WRITE_METHOD;
 use crate::protocol::EnvironmentInfo;
@@ -80,8 +81,11 @@ use crate::protocol::INITIALIZED_METHOD;
 use crate::protocol::InitializeParams;
 use crate::protocol::InitializeResponse;
 use crate::protocol::ProcessOutputChunk;
+use crate::protocol::ProcessSignal;
 use crate::protocol::ReadParams;
 use crate::protocol::ReadResponse;
+use crate::protocol::SignalParams;
+use crate::protocol::SignalResponse;
 use crate::protocol::TerminateParams;
 use crate::protocol::TerminateResponse;
 use crate::protocol::WriteParams;
@@ -394,6 +398,23 @@ impl ExecServerClient {
         .await
     }
 
+    pub async fn signal(
+        &self,
+        process_id: &ProcessId,
+        signal: ProcessSignal,
+    ) -> Result<(), ExecServerError> {
+        let _response: SignalResponse = self
+            .call(
+                EXEC_SIGNAL_METHOD,
+                &SignalParams {
+                    process_id: process_id.clone(),
+                    signal,
+                },
+            )
+            .await?;
+        Ok(())
+    }
+
     pub async fn terminate(
         &self,
         process_id: &ProcessId,
@@ -763,6 +784,10 @@ impl Session {
         self.client.write(&self.process_id, chunk).await
     }
 
+    pub(crate) async fn signal(&self, signal: ProcessSignal) -> Result<(), ExecServerError> {
+        self.client.signal(&self.process_id, signal).await
+    }
+
     pub(crate) async fn terminate(&self) -> Result<(), ExecServerError> {
         self.client.terminate(&self.process_id).await?;
         Ok(())

codex-rs/exec-server/src/lib.rs

@@ -93,9 +93,12 @@ pub use protocol::HttpRequestResponse;
 pub use protocol::InitializeParams;
 pub use protocol::InitializeResponse;
 pub use protocol::ProcessOutputChunk;
+pub use protocol::ProcessSignal;
 pub use protocol::ReadParams;
 pub use protocol::ReadResponse;
 pub use protocol::ShellInfo;
+pub use protocol::SignalParams;
+pub use protocol::SignalResponse;
 pub use protocol::TerminateParams;
 pub use protocol::TerminateResponse;
 pub use protocol::WriteParams;

codex-rs/exec-server/src/local_process.rs

@@ -10,6 +10,7 @@ use codex_protocol::config_types::EnvironmentVariablePattern;
 use codex_protocol::config_types::ShellEnvironmentPolicy;
 use codex_protocol::shell_environment;
 use codex_utils_pty::ExecCommandSession;
+use codex_utils_pty::ProcessSignal as PtyProcessSignal;
 use codex_utils_pty::TerminalSize;
 use tokio::sync::Mutex;
 use tokio::sync::Notify;
@@ -33,8 +34,11 @@ use crate::protocol::ExecOutputStream;
 use crate::protocol::ExecParams;
 use crate::protocol::ExecResponse;
 use crate::protocol::ProcessOutputChunk;
+use crate::protocol::ProcessSignal;
 use crate::protocol::ReadParams;
 use crate::protocol::ReadResponse;
+use crate::protocol::SignalParams;
+use crate::protocol::SignalResponse;
 use crate::protocol::TerminateParams;
 use crate::protocol::TerminateResponse;
 use crate::protocol::WriteParams;
@@ -272,7 +276,6 @@ impl LocalProcess {
         &self,
         params: ReadParams,
     ) -> Result<ReadResponse, JSONRPCErrorError> {
-        let _process_id = params.process_id.clone();
         let after_seq = params.after_seq.unwrap_or(0);
         let max_bytes = params.max_bytes.unwrap_or(usize::MAX);
         let wait = Duration::from_millis(params.wait_ms.unwrap_or(0));
@@ -351,7 +354,6 @@ impl LocalProcess {
         &self,
         params: WriteParams,
     ) -> Result<WriteResponse, JSONRPCErrorError> {
-        let _process_id = params.process_id.clone();
         let _input_bytes = params.chunk.0.len();
         let writer_tx = {
             let process_map = self.inner.processes.lock().await;
@@ -383,11 +385,33 @@ impl LocalProcess {
         })
     }
 
+    pub(crate) async fn signal_process(
+        &self,
+        params: SignalParams,
+    ) -> Result<SignalResponse, JSONRPCErrorError> {
+        {
+            let process_map = self.inner.processes.lock().await;
+            match process_map.get(&params.process_id) {
+                Some(ProcessEntry::Running(process)) => {
+                    if process.exit_code.is_some() {
+                        return Ok(SignalResponse {});
+                    }
+                    process
+                        .session
+                        .signal(pty_process_signal(params.signal))
+                        .map_err(|err| internal_error(format!("failed to signal process: {err}")))?
+                }
+                Some(ProcessEntry::Starting) | None => {}
+            }
+        }
+
+        Ok(SignalResponse {})
+    }
+
     pub(crate) async fn terminate_process(
         &self,
         params: TerminateParams,
     ) -> Result<TerminateResponse, JSONRPCErrorError> {
-        let _process_id = params.process_id.clone();
         let running = {
             let process_map = self.inner.processes.lock().await;
             match process_map.get(&params.process_id) {
@@ -483,6 +507,10 @@ impl ExecProcess for LocalExecProcess {
         self.backend.write(&self.process_id, chunk).await
     }
 
+    async fn signal(&self, signal: ProcessSignal) -> Result<(), ExecServerError> {
+        self.backend.signal(&self.process_id, signal).await
+    }
+
     async fn terminate(&self) -> Result<(), ExecServerError> {
         self.backend.terminate(&self.process_id).await
     }
@@ -519,6 +547,20 @@ impl LocalProcess {
         .map_err(map_handler_error)
     }
 
+    async fn signal(
+        &self,
+        process_id: &ProcessId,
+        signal: ProcessSignal,
+    ) -> Result<(), ExecServerError> {
+        self.signal_process(SignalParams {
+            process_id: process_id.clone(),
+            signal,
+        })
+        .await
+        .map_err(map_handler_error)?;
+        Ok(())
+    }
+
     async fn terminate(&self, process_id: &ProcessId) -> Result<(), ExecServerError> {
         self.terminate_process(TerminateParams {
             process_id: process_id.clone(),
@@ -529,6 +571,12 @@ impl LocalProcess {
     }
 }
 
+fn pty_process_signal(signal: ProcessSignal) -> PtyProcessSignal {
+    match signal {
+        ProcessSignal::Interrupt => PtyProcessSignal::Interrupt,
+    }
+}
+
 fn map_handler_error(error: JSONRPCErrorError) -> ExecServerError {
     ExecServerError::Server {
         code: error.code,

codex-rs/exec-server/src/process.rs

@@ -10,6 +10,7 @@ use crate::ExecServerError;
 use crate::ProcessId;
 use crate::protocol::ExecParams;
 use crate::protocol::ProcessOutputChunk;
+use crate::protocol::ProcessSignal;
 use crate::protocol::ReadResponse;
 use crate::protocol::WriteResponse;
 
@@ -178,6 +179,8 @@ pub trait ExecProcess: Send + Sync {
 
     async fn write(&self, chunk: Vec<u8>) -> Result<WriteResponse, ExecServerError>;
 
+    async fn signal(&self, signal: ProcessSignal) -> Result<(), ExecServerError>;
+
     async fn terminate(&self) -> Result<(), ExecServerError>;
 }
 

codex-rs/exec-server/src/protocol.rs

@@ -15,6 +15,7 @@ pub const INITIALIZED_METHOD: &str = "initialized";
 pub const EXEC_METHOD: &str = "process/start";
 pub const EXEC_READ_METHOD: &str = "process/read";
 pub const EXEC_WRITE_METHOD: &str = "process/write";
+pub const EXEC_SIGNAL_METHOD: &str = "process/signal";
 pub const EXEC_TERMINATE_METHOD: &str = "process/terminate";
 pub const EXEC_OUTPUT_DELTA_METHOD: &str = "process/output";
 pub const EXEC_EXITED_METHOD: &str = "process/exited";
@@ -166,6 +167,23 @@ pub struct WriteResponse {
     pub status: WriteStatus,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum ProcessSignal {
+    Interrupt,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SignalParams {
+    pub process_id: ProcessId,
+    pub signal: ProcessSignal,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SignalResponse {}
+
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct TerminateParams {

codex-rs/exec-server/src/remote_process.rs

@@ -12,6 +12,7 @@ use crate::StartedExecProcess;
 use crate::client::LazyRemoteExecServerClient;
 use crate::client::Session;
 use crate::protocol::ExecParams;
+use crate::protocol::ProcessSignal;
 use crate::protocol::ReadResponse;
 use crate::protocol::WriteResponse;
 
@@ -76,6 +77,11 @@ impl ExecProcess for RemoteExecProcess {
         self.session.write(chunk).await
     }
 
+    async fn signal(&self, signal: ProcessSignal) -> Result<(), ExecServerError> {
+        trace!("exec process signal");
+        self.session.signal(signal).await
+    }
+
     async fn terminate(&self) -> Result<(), ExecServerError> {
         trace!("exec process terminate");
         self.session.terminate().await

codex-rs/exec-server/src/server/handler.rs

@@ -42,6 +42,8 @@ use crate::protocol::InitializeParams;
 use crate::protocol::InitializeResponse;
 use crate::protocol::ReadParams;
 use crate::protocol::ReadResponse;
+use crate::protocol::SignalParams;
+use crate::protocol::SignalResponse;
 use crate::protocol::TerminateParams;
 use crate::protocol::TerminateResponse;
 use crate::protocol::WriteParams;
@@ -171,6 +173,14 @@ impl ExecServerHandler {
         session.process().exec_write(params).await
     }
 
+    pub(crate) async fn signal(
+        &self,
+        params: SignalParams,
+    ) -> Result<SignalResponse, JSONRPCErrorError> {
+        let session = self.require_initialized_for("exec")?;
+        session.process().signal(params).await
+    }
+
     pub(crate) async fn terminate(
         &self,
         params: TerminateParams,

codex-rs/exec-server/src/server/process_handler.rs

@@ -5,6 +5,8 @@ use crate::protocol::ExecParams;
 use crate::protocol::ExecResponse;
 use crate::protocol::ReadParams;
 use crate::protocol::ReadResponse;
+use crate::protocol::SignalParams;
+use crate::protocol::SignalResponse;
 use crate::protocol::TerminateParams;
 use crate::protocol::TerminateResponse;
 use crate::protocol::WriteParams;
@@ -49,6 +51,13 @@ impl ProcessHandler {
         self.process.exec_write(params).await
     }
 
+    pub(crate) async fn signal(
+        &self,
+        params: SignalParams,
+    ) -> Result<SignalResponse, JSONRPCErrorError> {
+        self.process.signal_process(params).await
+    }
+
     pub(crate) async fn terminate(
         &self,
         params: TerminateParams,

codex-rs/exec-server/src/server/registry.rs

@@ -3,6 +3,7 @@ use std::sync::Arc;
 use crate::protocol::ENVIRONMENT_INFO_METHOD;
 use crate::protocol::EXEC_METHOD;
 use crate::protocol::EXEC_READ_METHOD;
+use crate::protocol::EXEC_SIGNAL_METHOD;
 use crate::protocol::EXEC_TERMINATE_METHOD;
 use crate::protocol::EXEC_WRITE_METHOD;
 use crate::protocol::ExecParams;
@@ -32,6 +33,7 @@ use crate::protocol::INITIALIZE_METHOD;
 use crate::protocol::INITIALIZED_METHOD;
 use crate::protocol::InitializeParams;
 use crate::protocol::ReadParams;
+use crate::protocol::SignalParams;
 use crate::protocol::TerminateParams;
 use crate::protocol::WriteParams;
 use crate::rpc::RpcRouter;
@@ -77,6 +79,12 @@ pub(crate) fn build_router() -> RpcRouter<ExecServerHandler> {
             handler.exec_write(params).await
         },
     );
+    router.request(
+        EXEC_SIGNAL_METHOD,
+        |handler: Arc<ExecServerHandler>, params: SignalParams| async move {
+            handler.signal(params).await
+        },
+    );
     router.request(
         EXEC_TERMINATE_METHOD,
         |handler: Arc<ExecServerHandler>, params: TerminateParams| async move {