exec-server: simplify transport and dispatch shape

Co-authored-by: Codex <noreply@openai.com>

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

@@ -6,11 +6,11 @@ use tokio_tungstenite::accept_async;
 use tracing::warn;
 
 use crate::connection::JsonRpcConnection;
+use crate::server::ExecServerConfig;
 use crate::server::processor::run_connection;
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum ExecServerTransport {
-    Stdio,
     WebSocket { bind_address: SocketAddr },
 }
 
@@ -25,7 +25,7 @@ impl std::fmt::Display for ExecServerTransportParseError {
         match self {
             ExecServerTransportParseError::UnsupportedListenUrl(listen_url) => write!(
                 f,
-                "unsupported --listen URL `{listen_url}`; expected `stdio://` or `ws://IP:PORT`"
+                "unsupported --listen URL `{listen_url}`; expected `ws://IP:PORT`"
             ),
             ExecServerTransportParseError::InvalidWebSocketListenUrl(listen_url) => write!(
                 f,
@@ -38,13 +38,9 @@ impl std::fmt::Display for ExecServerTransportParseError {
 impl std::error::Error for ExecServerTransportParseError {}
 
 impl ExecServerTransport {
-    pub const DEFAULT_LISTEN_URL: &str = "stdio://";
+    pub const DEFAULT_LISTEN_URL: &str = "ws://127.0.0.1:0";
 
     pub fn from_listen_url(listen_url: &str) -> Result<Self, ExecServerTransportParseError> {
-        if listen_url == Self::DEFAULT_LISTEN_URL {
-            return Ok(Self::Stdio);
-        }
-
         if let Some(socket_addr) = listen_url.strip_prefix("ws://") {
             let bind_address = socket_addr.parse::<SocketAddr>().map_err(|_| {
                 ExecServerTransportParseError::InvalidWebSocketListenUrl(listen_url.to_string())
@@ -58,6 +54,16 @@ impl ExecServerTransport {
     }
 }
 
+impl Default for ExecServerTransport {
+    fn default() -> Self {
+        Self::WebSocket {
+            bind_address: "127.0.0.1:0".parse().unwrap_or_else(|err| {
+                panic!("default exec-server websocket bind address should parse: {err}")
+            }),
+        }
+    }
+}
+
 impl FromStr for ExecServerTransport {
     type Err = ExecServerTransportParseError;
 
@@ -68,25 +74,18 @@ impl FromStr for ExecServerTransport {
 
 pub(crate) async fn run_transport(
     transport: ExecServerTransport,
+    config: ExecServerConfig,
 ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     match transport {
-        ExecServerTransport::Stdio => {
-            run_connection(JsonRpcConnection::from_stdio(
-                tokio::io::stdin(),
-                tokio::io::stdout(),
-                "exec-server stdio".to_string(),
-            ))
-            .await;
-            Ok(())
-        }
         ExecServerTransport::WebSocket { bind_address } => {
-            run_websocket_listener(bind_address).await
+            run_websocket_listener(bind_address, config).await
         }
     }
 }
 
 async fn run_websocket_listener(
     bind_address: SocketAddr,
+    config: ExecServerConfig,
 ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     let listener = TcpListener::bind(bind_address).await?;
     let local_addr = listener.local_addr()?;
@@ -94,13 +93,17 @@ async fn run_websocket_listener(
 
     loop {
         let (stream, peer_addr) = listener.accept().await?;
+        let config = config.clone();
         tokio::spawn(async move {
             match accept_async(stream).await {
                 Ok(websocket) => {
-                    run_connection(JsonRpcConnection::from_websocket(
-                        websocket,
-                        format!("exec-server websocket {peer_addr}"),
-                    ))
+                    run_connection(
+                        JsonRpcConnection::from_websocket(
+                            websocket,
+                            format!("exec-server websocket {peer_addr}"),
+                        ),
+                        config,
+                    )
                     .await;
                 }
                 Err(err) => {
@@ -124,14 +127,6 @@ mod tests {
 
     use super::ExecServerTransport;
 
-    #[test]
-    fn exec_server_transport_parses_stdio_listen_url() {
-        let transport =
-            ExecServerTransport::from_listen_url(ExecServerTransport::DEFAULT_LISTEN_URL)
-                .expect("stdio listen URL should parse");
-        assert_eq!(transport, ExecServerTransport::Stdio);
-    }
-
     #[test]
     fn exec_server_transport_parses_websocket_listen_url() {
         let transport = ExecServerTransport::from_listen_url("ws://127.0.0.1:1234")
@@ -160,7 +155,7 @@ mod tests {
             .expect_err("unsupported scheme should fail");
         assert_eq!(
             err.to_string(),
-            "unsupported --listen URL `http://127.0.0.1:1234`; expected `stdio://` or `ws://IP:PORT`"
+            "unsupported --listen URL `http://127.0.0.1:1234`; expected `ws://IP:PORT`"
         );
     }
 }