mirror of
https://github.com/pchuan98/codex.git
synced 2026-07-01 00:31:56 +08:00
pakrym-oai
f2969f36e8
## 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`
99 lines
2.6 KiB
Rust
99 lines
2.6 KiB
Rust
use std::sync::Arc;
|
|
|
|
use async_trait::async_trait;
|
|
use tokio::sync::watch;
|
|
use tracing::trace;
|
|
|
|
use crate::ExecBackend;
|
|
use crate::ExecProcess;
|
|
use crate::ExecProcessEventReceiver;
|
|
use crate::ExecServerError;
|
|
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;
|
|
|
|
#[derive(Clone)]
|
|
pub(crate) struct RemoteProcess {
|
|
client: LazyRemoteExecServerClient,
|
|
}
|
|
|
|
struct RemoteExecProcess {
|
|
session: Session,
|
|
}
|
|
|
|
impl RemoteProcess {
|
|
pub(crate) fn new(client: LazyRemoteExecServerClient) -> Self {
|
|
trace!("remote process new");
|
|
Self { client }
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl ExecBackend for RemoteProcess {
|
|
async fn start(&self, params: ExecParams) -> Result<StartedExecProcess, ExecServerError> {
|
|
let process_id = params.process_id.clone();
|
|
let client = self.client.get().await?;
|
|
let session = client.register_session(&process_id).await?;
|
|
if let Err(err) = client.exec(params).await {
|
|
session.unregister().await;
|
|
return Err(err);
|
|
}
|
|
|
|
Ok(StartedExecProcess {
|
|
process: Arc::new(RemoteExecProcess { session }),
|
|
})
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl ExecProcess for RemoteExecProcess {
|
|
fn process_id(&self) -> &crate::ProcessId {
|
|
self.session.process_id()
|
|
}
|
|
|
|
fn subscribe_wake(&self) -> watch::Receiver<u64> {
|
|
self.session.subscribe_wake()
|
|
}
|
|
|
|
fn subscribe_events(&self) -> ExecProcessEventReceiver {
|
|
self.session.subscribe_events()
|
|
}
|
|
|
|
async fn read(
|
|
&self,
|
|
after_seq: Option<u64>,
|
|
max_bytes: Option<usize>,
|
|
wait_ms: Option<u64>,
|
|
) -> Result<ReadResponse, ExecServerError> {
|
|
self.session.read(after_seq, max_bytes, wait_ms).await
|
|
}
|
|
|
|
async fn write(&self, chunk: Vec<u8>) -> Result<WriteResponse, ExecServerError> {
|
|
trace!("exec process write");
|
|
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
|
|
}
|
|
}
|
|
|
|
impl Drop for RemoteExecProcess {
|
|
fn drop(&mut self) {
|
|
let session = self.session.clone();
|
|
tokio::spawn(async move {
|
|
session.unregister().await;
|
|
});
|
|
}
|
|
}
|