mirror of
https://github.com/openai/codex.git
synced 2026-05-14 08:12:36 +00:00
085ffb4456
This introduces session-scoped ownership for exec-server so ws disconnects no longer immediately kill running remote exec processes, and it prepares the protocol for reconnect-based resume. - add session_id / resume_session_id to the exec-server initialize handshake - move process ownership under a shared session registry - detach sessions on websocket disconnect and expire them after a TTL instead of killing processes immediately (we will resume based on this) - allow a new connection to resume an existing session and take over notifications/ownership - I use UUID to make them not predictable as we don't have auth for now - make detached-session expiry authoritative at resume time so teardown wins at the TTL boundary - reject long-poll process/read calls that get resumed out from under an older attachment --------- Co-authored-by: Codex <noreply@openai.com>
59 lines
1.6 KiB
Rust
59 lines
1.6 KiB
Rust
use codex_app_server_protocol::JSONRPCErrorError;
|
|
|
|
use crate::local_process::LocalProcess;
|
|
use crate::protocol::ExecParams;
|
|
use crate::protocol::ExecResponse;
|
|
use crate::protocol::ReadParams;
|
|
use crate::protocol::ReadResponse;
|
|
use crate::protocol::TerminateParams;
|
|
use crate::protocol::TerminateResponse;
|
|
use crate::protocol::WriteParams;
|
|
use crate::protocol::WriteResponse;
|
|
use crate::rpc::RpcNotificationSender;
|
|
|
|
#[derive(Clone)]
|
|
pub(crate) struct ProcessHandler {
|
|
process: LocalProcess,
|
|
}
|
|
|
|
impl ProcessHandler {
|
|
pub(crate) fn new(notifications: RpcNotificationSender) -> Self {
|
|
Self {
|
|
process: LocalProcess::new(notifications),
|
|
}
|
|
}
|
|
|
|
pub(crate) async fn shutdown(&self) {
|
|
self.process.shutdown().await;
|
|
}
|
|
|
|
pub(crate) fn set_notification_sender(&self, notifications: Option<RpcNotificationSender>) {
|
|
self.process.set_notification_sender(notifications);
|
|
}
|
|
|
|
pub(crate) async fn exec(&self, params: ExecParams) -> Result<ExecResponse, JSONRPCErrorError> {
|
|
self.process.exec(params).await
|
|
}
|
|
|
|
pub(crate) async fn exec_read(
|
|
&self,
|
|
params: ReadParams,
|
|
) -> Result<ReadResponse, JSONRPCErrorError> {
|
|
self.process.exec_read(params).await
|
|
}
|
|
|
|
pub(crate) async fn exec_write(
|
|
&self,
|
|
params: WriteParams,
|
|
) -> Result<WriteResponse, JSONRPCErrorError> {
|
|
self.process.exec_write(params).await
|
|
}
|
|
|
|
pub(crate) async fn terminate(
|
|
&self,
|
|
params: TerminateParams,
|
|
) -> Result<TerminateResponse, JSONRPCErrorError> {
|
|
self.process.terminate_process(params).await
|
|
}
|
|
}
|