Remove stdio transport from exec server (#15119)

Summary
- delete the deprecated stdio transport plumbing from the exec server
stack
- add a basic `exec_server()` harness plus test utilities to start a
server, send requests, and await events
- refresh exec-server dependencies, configs, and documentation to
reflect the new flow

Testing
- Not run (not requested)

---------

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

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

@@ -1,5 +1,4 @@
 use std::net::SocketAddr;
-use std::str::FromStr;
 
 use tokio::net::TcpListener;
 use tokio_tungstenite::accept_async;
@@ -8,26 +7,22 @@ use tracing::warn;
 use crate::connection::JsonRpcConnection;
 use crate::server::processor::run_connection;
 
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum ExecServerTransport {
-    Stdio,
-    WebSocket { bind_address: SocketAddr },
-}
+pub const DEFAULT_LISTEN_URL: &str = "ws://127.0.0.1:0";
 
 #[derive(Debug, Clone, Eq, PartialEq)]
-pub enum ExecServerTransportParseError {
+pub enum ExecServerListenUrlParseError {
     UnsupportedListenUrl(String),
     InvalidWebSocketListenUrl(String),
 }
 
-impl std::fmt::Display for ExecServerTransportParseError {
+impl std::fmt::Display for ExecServerListenUrlParseError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            ExecServerTransportParseError::UnsupportedListenUrl(listen_url) => write!(
+            ExecServerListenUrlParseError::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!(
+            ExecServerListenUrlParseError::InvalidWebSocketListenUrl(listen_url) => write!(
                 f,
                 "invalid websocket --listen URL `{listen_url}`; expected `ws://IP:PORT`"
             ),
@@ -35,54 +30,27 @@ impl std::fmt::Display for ExecServerTransportParseError {
     }
 }
 
-impl std::error::Error for ExecServerTransportParseError {}
+impl std::error::Error for ExecServerListenUrlParseError {}
 
-impl ExecServerTransport {
-    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 == "stdio://" {
-            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())
-            })?;
-            return Ok(Self::WebSocket { bind_address });
-        }
-
-        Err(ExecServerTransportParseError::UnsupportedListenUrl(
-            listen_url.to_string(),
-        ))
+pub(crate) fn parse_listen_url(
+    listen_url: &str,
+) -> Result<SocketAddr, ExecServerListenUrlParseError> {
+    if let Some(socket_addr) = listen_url.strip_prefix("ws://") {
+        return socket_addr.parse::<SocketAddr>().map_err(|_| {
+            ExecServerListenUrlParseError::InvalidWebSocketListenUrl(listen_url.to_string())
+        });
     }
-}
 
-impl FromStr for ExecServerTransport {
-    type Err = ExecServerTransportParseError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Self::from_listen_url(s)
-    }
+    Err(ExecServerListenUrlParseError::UnsupportedListenUrl(
+        listen_url.to_string(),
+    ))
 }
 
 pub(crate) async fn run_transport(
-    transport: ExecServerTransport,
+    listen_url: &str,
 ) -> 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
-        }
-    }
+    let bind_address = parse_listen_url(listen_url)?;
+    run_websocket_listener(bind_address).await
 }
 
 async fn run_websocket_listener(

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

@@ -1,41 +1,31 @@
 use pretty_assertions::assert_eq;
 
-use super::ExecServerTransport;
+use super::DEFAULT_LISTEN_URL;
+use super::parse_listen_url;
 
 #[test]
-fn exec_server_transport_parses_default_websocket_listen_url() {
-    let transport = ExecServerTransport::from_listen_url(ExecServerTransport::DEFAULT_LISTEN_URL)
-        .expect("default listen URL should parse");
+fn parse_listen_url_accepts_default_websocket_url() {
+    let bind_address =
+        parse_listen_url(DEFAULT_LISTEN_URL).expect("default listen URL should parse");
     assert_eq!(
-        transport,
-        ExecServerTransport::WebSocket {
-            bind_address: "127.0.0.1:0".parse().expect("valid socket address"),
-        }
+        bind_address,
+        "127.0.0.1:0".parse().expect("valid socket address")
     );
 }
 
 #[test]
-fn exec_server_transport_parses_stdio_listen_url() {
-    let transport =
-        ExecServerTransport::from_listen_url("stdio://").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")
-        .expect("websocket listen URL should parse");
+fn parse_listen_url_accepts_websocket_url() {
+    let bind_address =
+        parse_listen_url("ws://127.0.0.1:1234").expect("websocket listen URL should parse");
     assert_eq!(
-        transport,
-        ExecServerTransport::WebSocket {
-            bind_address: "127.0.0.1:1234".parse().expect("valid socket address"),
-        }
+        bind_address,
+        "127.0.0.1:1234".parse().expect("valid socket address")
     );
 }
 
 #[test]
-fn exec_server_transport_rejects_invalid_websocket_listen_url() {
-    let err = ExecServerTransport::from_listen_url("ws://localhost:1234")
+fn parse_listen_url_rejects_invalid_websocket_url() {
+    let err = parse_listen_url("ws://localhost:1234")
         .expect_err("hostname bind address should be rejected");
     assert_eq!(
         err.to_string(),
@@ -44,11 +34,11 @@ fn exec_server_transport_rejects_invalid_websocket_listen_url() {
 }
 
 #[test]
-fn exec_server_transport_rejects_unsupported_listen_url() {
-    let err = ExecServerTransport::from_listen_url("http://127.0.0.1:1234")
-        .expect_err("unsupported scheme should fail");
+fn parse_listen_url_rejects_unsupported_url() {
+    let err =
+        parse_listen_url("http://127.0.0.1:1234").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`"
     );
 }