use std::collections::{HashMap, VecDeque};
use std::ffi::{OsStr, OsString};
use std::process::Stdio;
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::{Arc, Mutex};
use std::time::Duration;
use serde::de::DeserializeOwned;
use serde_json::{Map, Value, json};
use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
use tokio::process::{Child, ChildStdin, Command};
use tokio::sync::{Mutex as AsyncMutex, mpsc, oneshot};
use tokio::task::JoinHandle;
use crate::config::{ApprovalHandler, CodexConfig};
use crate::error::{Error, JsonRpcError, Result};
use crate::types::Notification;
type NotificationSender = mpsc::UnboundedSender<Result<Notification>>;
pub(crate) type NotificationReceiver = mpsc::UnboundedReceiver<Result<Notification>>;
#[derive(Debug)]
struct Router {
responses: Mutex<HashMap<String, oneshot::Sender<Result<Value>>>>,
turn_routes: Mutex<HashMap<String, NotificationSender>>,
pending_turns: Mutex<HashMap<String, VecDeque<Notification>>>,
login_routes: Mutex<HashMap<String, NotificationSender>>,
pending_logins: Mutex<HashMap<String, VecDeque<Notification>>>,
global_tx: NotificationSender,
}
impl Router {
fn new(global_tx: NotificationSender) -> Self {
Self {
responses: Mutex::new(HashMap::new()),
turn_routes: Mutex::new(HashMap::new()),
pending_turns: Mutex::new(HashMap::new()),
login_routes: Mutex::new(HashMap::new()),
pending_logins: Mutex::new(HashMap::new()),
global_tx,
}
}
fn register_response(&self, id: String, sender: oneshot::Sender<Result<Value>>) {
self.responses
.lock()
.expect("response router lock poisoned")
.insert(id, sender);
}
fn discard_response(&self, id: &str) {
self.responses
.lock()
.expect("response router lock poisoned")
.remove(id);
}
fn route_response(&self, message: &Map<String, Value>) {
let Some(id) = message.get("id").map(request_id_key) else {
return;
};
let Some(sender) = self
.responses
.lock()
.expect("response router lock poisoned")
.remove(&id)
else {
return;
};
let result = if let Some(Value::Object(error)) = message.get("error") {
let code = error.get("code").and_then(Value::as_i64).unwrap_or(-32000);
let message = error
.get("message")
.and_then(Value::as_str)
.unwrap_or("unknown")
.to_owned();
let data = error.get("data").cloned();
Err(Error::JsonRpc(JsonRpcError::new(code, message, data)))
} else if message.contains_key("error") {
Err(Error::InvalidResponse {
method: "JSON-RPC",
message: "malformed error response".into(),
})
} else {
Ok(message.get("result").cloned().unwrap_or(Value::Null))
};
let _ = sender.send(result);
}
fn subscribe_turn(&self, turn_id: &str) -> Result<NotificationReceiver> {
let (sender, receiver) = mpsc::unbounded_channel();
let mut routes = self.turn_routes.lock().expect("turn router lock poisoned");
if routes.contains_key(turn_id) {
return Err(Error::StreamConsumed);
}
routes.insert(turn_id.to_owned(), sender.clone());
drop(routes);
if let Some(pending) = self
.pending_turns
.lock()
.expect("pending turn router lock poisoned")
.remove(turn_id)
{
for notification in pending {
let _ = sender.send(Ok(notification));
}
}
Ok(receiver)
}
fn unsubscribe_turn(&self, turn_id: &str) {
self.turn_routes
.lock()
.expect("turn router lock poisoned")
.remove(turn_id);
self.pending_turns
.lock()
.expect("pending turn router lock poisoned")
.remove(turn_id);
}
fn subscribe_login(&self, login_id: &str) -> Result<NotificationReceiver> {
let (sender, receiver) = mpsc::unbounded_channel();
let mut routes = self
.login_routes
.lock()
.expect("login router lock poisoned");
if routes.contains_key(login_id) {
return Err(Error::StreamConsumed);
}
routes.insert(login_id.to_owned(), sender.clone());
drop(routes);
if let Some(pending) = self
.pending_logins
.lock()
.expect("pending login router lock poisoned")
.remove(login_id)
{
for notification in pending {
let _ = sender.send(Ok(notification));
}
}
Ok(receiver)
}
fn unsubscribe_login(&self, login_id: &str) {
self.login_routes
.lock()
.expect("login router lock poisoned")
.remove(login_id);
self.pending_logins
.lock()
.expect("pending login router lock poisoned")
.remove(login_id);
}
fn route_notification(&self, notification: Notification) {
if let Some(login_id) = notification.login_id().map(str::to_owned) {
let sender = self
.login_routes
.lock()
.expect("login router lock poisoned")
.get(&login_id)
.cloned();
if let Some(sender) = sender {
let _ = sender.send(Ok(notification));
} else {
self.pending_logins
.lock()
.expect("pending login router lock poisoned")
.entry(login_id)
.or_default()
.push_back(notification);
}
return;
}
if let Some(turn_id) = notification.turn_id().map(str::to_owned) {
let sender = self
.turn_routes
.lock()
.expect("turn router lock poisoned")
.get(&turn_id)
.cloned();
if let Some(sender) = sender {
let _ = sender.send(Ok(notification));
} else {
self.pending_turns
.lock()
.expect("pending turn router lock poisoned")
.entry(turn_id)
.or_default()
.push_back(notification);
}
return;
}
let _ = self.global_tx.send(Ok(notification));
}
fn fail_all(&self, reason: &str) {
let responses = std::mem::take(
&mut *self
.responses
.lock()
.expect("response router lock poisoned"),
);
for (_, sender) in responses {
let _ = sender.send(Err(Error::TransportClosed(reason.into())));
}
let turn_routes =
std::mem::take(&mut *self.turn_routes.lock().expect("turn router lock poisoned"));
for (_, sender) in turn_routes {
let _ = sender.send(Err(Error::TransportClosed(reason.into())));
}
let login_routes = std::mem::take(
&mut *self
.login_routes
.lock()
.expect("login router lock poisoned"),
);
for (_, sender) in login_routes {
let _ = sender.send(Err(Error::TransportClosed(reason.into())));
}
self.pending_turns
.lock()
.expect("pending turn router lock poisoned")
.clear();
self.pending_logins
.lock()
.expect("pending login router lock poisoned")
.clear();
let _ = self
.global_tx
.send(Err(Error::TransportClosed(reason.into())));
}
}
fn request_id_key(value: &Value) -> String {
value
.as_str()
.map_or_else(|| value.to_string(), str::to_owned)
}
struct Inner {
child: AsyncMutex<Option<Child>>,
writer: Arc<AsyncMutex<Option<ChildStdin>>>,
router: Arc<Router>,
global_rx: AsyncMutex<NotificationReceiver>,
reader_task: AsyncMutex<Option<JoinHandle<()>>>,
stderr_task: AsyncMutex<Option<JoinHandle<()>>>,
request_id: AtomicU64,
closed: AtomicBool,
}
impl std::fmt::Debug for Inner {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("TransportInner")
.field("request_id", &self.request_id)
.field("closed", &self.closed)
.finish_non_exhaustive()
}
}
#[derive(Clone, Debug)]
pub(crate) struct Transport {
inner: Arc<Inner>,
}
impl Transport {
pub(crate) fn start(config: &CodexConfig) -> Result<Self> {
let mut command = build_command(config)?;
command
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.kill_on_drop(true);
if let Some(cwd) = &config.cwd {
command.current_dir(cwd);
}
command.envs(&config.env);
let mut child = command.spawn().map_err(|error| {
if error.kind() == std::io::ErrorKind::NotFound {
Error::BinaryNotFound(error.to_string())
} else {
Error::Launch(error)
}
})?;
let stdin = child
.stdin
.take()
.ok_or_else(|| Error::TransportClosed("stdin unavailable".into()))?;
let stdout = child
.stdout
.take()
.ok_or_else(|| Error::TransportClosed("stdout unavailable".into()))?;
let stderr = child
.stderr
.take()
.ok_or_else(|| Error::TransportClosed("stderr unavailable".into()))?;
let (global_tx, global_rx) = mpsc::unbounded_channel();
let router = Arc::new(Router::new(global_tx));
let writer = Arc::new(AsyncMutex::new(Some(stdin)));
let stderr_lines = Arc::new(Mutex::new(VecDeque::with_capacity(400)));
let reader_task = tokio::spawn(reader_loop(
stdout,
Arc::clone(&router),
Arc::clone(&writer),
Arc::clone(&config.approval_handler),
Arc::clone(&stderr_lines),
));
let stderr_task = tokio::spawn(stderr_loop(stderr, stderr_lines));
Ok(Self {
inner: Arc::new(Inner {
child: AsyncMutex::new(Some(child)),
writer,
router,
global_rx: AsyncMutex::new(global_rx),
reader_task: AsyncMutex::new(Some(reader_task)),
stderr_task: AsyncMutex::new(Some(stderr_task)),
request_id: AtomicU64::new(1),
closed: AtomicBool::new(false),
}),
})
}
pub(crate) async fn request<T: DeserializeOwned>(
&self,
method: &'static str,
params: Option<Value>,
) -> Result<T> {
let result = self.request_value(method, params).await?;
serde_json::from_value(result).map_err(|error| Error::InvalidResponse {
method,
message: error.to_string(),
})
}
pub(crate) async fn request_value(
&self,
method: &'static str,
params: Option<Value>,
) -> Result<Value> {
if self.inner.closed.load(Ordering::Acquire) {
return Err(Error::TransportClosed("client is closed".into()));
}
let id = self
.inner
.request_id
.fetch_add(1, Ordering::Relaxed)
.to_string();
let (sender, receiver) = oneshot::channel();
self.inner.router.register_response(id.clone(), sender);
let mut message = Map::new();
message.insert("id".into(), Value::String(id.clone()));
message.insert("method".into(), Value::String(method.into()));
if let Some(params) = params {
message.insert("params".into(), params);
}
if let Err(error) = write_message(&self.inner.writer, Value::Object(message)).await {
self.inner.router.discard_response(&id);
return Err(error);
}
receiver
.await
.map_err(|_| Error::TransportClosed("response router stopped".into()))?
}
pub(crate) async fn notify(&self, method: &str, params: Option<Value>) -> Result<()> {
let mut message = Map::new();
message.insert("method".into(), Value::String(method.into()));
if let Some(params) = params {
message.insert("params".into(), params);
}
write_message(&self.inner.writer, Value::Object(message)).await
}
pub(crate) fn subscribe_turn(&self, turn_id: &str) -> Result<NotificationReceiver> {
self.inner.router.subscribe_turn(turn_id)
}
pub(crate) fn unsubscribe_turn(&self, turn_id: &str) {
self.inner.router.unsubscribe_turn(turn_id);
}
pub(crate) fn subscribe_login(&self, login_id: &str) -> Result<NotificationReceiver> {
self.inner.router.subscribe_login(login_id)
}
pub(crate) fn unsubscribe_login(&self, login_id: &str) {
self.inner.router.unsubscribe_login(login_id);
}
pub(crate) async fn next_global_notification(&self) -> Result<Notification> {
self.inner
.global_rx
.lock()
.await
.recv()
.await
.unwrap_or_else(|| Err(Error::TransportClosed("notification router stopped".into())))
}
pub(crate) async fn close(&self) -> Result<()> {
if self.inner.closed.swap(true, Ordering::AcqRel) {
return Ok(());
}
if let Some(mut writer) = self.inner.writer.lock().await.take() {
let _ = writer.shutdown().await;
}
if let Some(mut child) = self.inner.child.lock().await.take() {
let _ = child.start_kill();
let _ = tokio::time::timeout(Duration::from_secs(2), child.wait()).await;
}
if let Some(task) = self.inner.reader_task.lock().await.take() {
let _ = tokio::time::timeout(Duration::from_millis(500), task).await;
}
if let Some(task) = self.inner.stderr_task.lock().await.take() {
let _ = tokio::time::timeout(Duration::from_millis(500), task).await;
}
self.inner.router.fail_all("client closed");
Ok(())
}
}
fn build_command(config: &CodexConfig) -> Result<Command> {
if let Some(arguments) = &config.launch_args_override {
let Some((program, arguments)) = arguments.split_first() else {
return Err(Error::InvalidConfiguration(
"launch_args_override cannot be empty".into(),
));
};
if program.is_empty() {
return Err(Error::InvalidConfiguration(
"launch_args_override program cannot be empty".into(),
));
}
let mut command = Command::new(program);
command.args(arguments);
return Ok(command);
}
let program = config
.codex_bin
.as_ref()
.map(|path| path.as_os_str().to_owned())
.or_else(|| config.env.get(OsStr::new("CODEX_BINARY")).cloned())
.or_else(|| std::env::var_os("CODEX_BINARY"))
.unwrap_or_else(|| OsString::from("codex"));
if config.codex_bin.is_some() && !std::path::Path::new(&program).is_file() {
return Err(Error::BinaryNotFound(
std::path::Path::new(&program).display().to_string(),
));
}
let mut command = Command::new(program);
for value in &config.config_overrides {
command.arg("--config").arg(value);
}
command.args(["app-server", "--listen", "stdio://"]);
Ok(command)
}
async fn write_message(writer: &Arc<AsyncMutex<Option<ChildStdin>>>, message: Value) -> Result<()> {
let mut encoded = serde_json::to_vec(&message)?;
encoded.push(b'\n');
let mut guard = writer.lock().await;
let writer = guard
.as_mut()
.ok_or_else(|| Error::TransportClosed("Codex process is not running".into()))?;
writer.write_all(&encoded).await?;
writer.flush().await?;
Ok(())
}
async fn reader_loop(
stdout: tokio::process::ChildStdout,
router: Arc<Router>,
writer: Arc<AsyncMutex<Option<ChildStdin>>>,
approval_handler: ApprovalHandler,
stderr_lines: Arc<Mutex<VecDeque<String>>>,
) {
let mut lines = BufReader::new(stdout).lines();
loop {
let line = match lines.next_line().await {
Ok(Some(line)) => line,
Ok(None) => {
let tail = stderr_lines
.lock()
.expect("stderr lock poisoned")
.iter()
.cloned()
.collect::<Vec<_>>()
.join("\n");
router.fail_all(&format!("Codex process closed stdout. stderr_tail={tail}"));
return;
}
Err(error) => {
router.fail_all(&format!("reading Codex stdout failed: {error}"));
return;
}
};
let Value::Object(message) = (match serde_json::from_str::<Value>(&line) {
Ok(value) => value,
Err(error) => {
router.fail_all(&format!("invalid JSON-RPC line: {error}"));
return;
}
}) else {
router.fail_all("invalid JSON-RPC payload: expected object");
return;
};
let method = message.get("method").and_then(Value::as_str);
match (method, message.get("id")) {
(Some(method), Some(id)) => {
let response = match approval_handler(method, message.get("params")) {
Ok(result) => json!({"id": id, "result": result}),
Err(error) => json!({
"id": id,
"error": {"code": -32603, "message": error.to_string()}
}),
};
if let Err(error) = write_message(&writer, response).await {
router.fail_all(&error.to_string());
return;
}
}
(Some(method), None) => {
let notification = Notification::from_wire(
method.to_owned(),
message.get("params").cloned().unwrap_or(Value::Null),
);
router.route_notification(notification);
}
(None, _) => router.route_response(&message),
}
}
}
async fn stderr_loop(
stderr: tokio::process::ChildStderr,
stderr_lines: Arc<Mutex<VecDeque<String>>>,
) {
let mut lines = BufReader::new(stderr).lines();
while let Ok(Some(line)) = lines.next_line().await {
let mut lines = stderr_lines.lock().expect("stderr lock poisoned");
if lines.len() == 400 {
lines.pop_front();
}
lines.push_back(line);
}
}
#[cfg(test)]
mod tests {
use super::*;
fn mock_config() -> (tempfile::TempDir, CodexConfig) {
let temp = tempfile::tempdir().unwrap();
let capture = temp.path().join("capture.jsonl");
std::fs::write(&capture, "").unwrap();
let script = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("tests/fixtures/mock_app_server.py");
let mut config = CodexConfig {
launch_args_override: Some(vec![
"uv".into(),
"run".into(),
"--no-project".into(),
"python".into(),
script.into_os_string(),
]),
cwd: Some(temp.path().into()),
..CodexConfig::default()
};
config
.env
.insert("MOCK_CODEX_CAPTURE".into(), capture.into_os_string());
(temp, config)
}
#[test]
fn rejects_empty_launch_override_and_missing_explicit_binary() {
let config = CodexConfig {
launch_args_override: Some(vec![]),
..CodexConfig::default()
};
assert!(matches!(
build_command(&config),
Err(Error::InvalidConfiguration(_))
));
let config = CodexConfig {
codex_bin: Some("/definitely/missing/codex".into()),
..CodexConfig::default()
};
assert!(matches!(
build_command(&config),
Err(Error::BinaryNotFound(_))
));
let config = CodexConfig {
launch_args_override: Some(vec![OsString::new()]),
..CodexConfig::default()
};
assert!(matches!(
build_command(&config),
Err(Error::InvalidConfiguration(_))
));
}
#[test]
fn command_builder_preserves_overrides_and_codex_arguments() {
let config = CodexConfig {
launch_args_override: Some(vec!["mock".into(), "--flag".into()]),
..CodexConfig::default()
};
let command = build_command(&config).unwrap();
assert_eq!(command.as_std().get_program(), "mock");
assert_eq!(command.as_std().get_args().collect::<Vec<_>>(), ["--flag"]);
let binary = tempfile::NamedTempFile::new().unwrap();
let config = CodexConfig {
codex_bin: Some(binary.path().into()),
config_overrides: vec!["model=\"mock\"".into()],
..CodexConfig::default()
};
let command = build_command(&config).unwrap();
assert_eq!(command.as_std().get_program(), binary.path());
assert_eq!(
command.as_std().get_args().collect::<Vec<_>>(),
[
"--config",
"model=\"mock\"",
"app-server",
"--listen",
"stdio://"
]
);
}
#[test]
fn request_ids_preserve_string_and_numeric_forms() {
assert_eq!(request_id_key(&json!("abc")), "abc");
assert_eq!(request_id_key(&json!(12)), "12");
}
fn router() -> (Router, NotificationReceiver) {
let (global_tx, global_rx) = mpsc::unbounded_channel();
(Router::new(global_tx), global_rx)
}
#[tokio::test]
async fn response_router_maps_results_errors_and_malformed_errors() {
let (router, _global) = router();
let (sender, receiver) = oneshot::channel();
router.register_response("one".into(), sender);
router.route_response(
json!({"id":"one","result":{"ok":true}})
.as_object()
.unwrap(),
);
assert_eq!(receiver.await.unwrap().unwrap(), json!({"ok":true}));
let (sender, receiver) = oneshot::channel();
router.register_response("two".into(), sender);
router.route_response(
json!({"id":"two","error":{"code":-32601,"message":"missing","data":{"x":1}}})
.as_object()
.unwrap(),
);
assert!(matches!(
receiver.await.unwrap(),
Err(Error::JsonRpc(error))
if error.kind == crate::JsonRpcErrorKind::MethodNotFound
&& error.data == Some(json!({"x":1}))
));
let (sender, receiver) = oneshot::channel();
router.register_response("three".into(), sender);
router.route_response(json!({"id":"three","error":"bad"}).as_object().unwrap());
assert!(matches!(
receiver.await.unwrap(),
Err(Error::InvalidResponse {
method: "JSON-RPC",
..
})
));
let (sender, receiver) = oneshot::channel();
router.register_response("four".into(), sender);
router.route_response(json!({"id":"four"}).as_object().unwrap());
assert_eq!(receiver.await.unwrap().unwrap(), Value::Null);
router.route_response(json!({"result":true}).as_object().unwrap());
router.route_response(json!({"id":"unknown","result":true}).as_object().unwrap());
router.discard_response("unknown");
}
#[tokio::test]
async fn notification_router_buffers_routes_and_preserves_first_subscriber() {
let (router, mut global) = router();
let turn = Notification::from_wire("future".into(), json!({"turnId":"turn-1"}));
router.route_notification(turn.clone());
let mut turn_events = router.subscribe_turn("turn-1").unwrap();
assert_eq!(turn_events.recv().await.unwrap().unwrap(), turn);
assert!(matches!(
router.subscribe_turn("turn-1"),
Err(Error::StreamConsumed)
));
router.route_notification(turn.clone());
assert_eq!(turn_events.recv().await.unwrap().unwrap(), turn);
let login = Notification::from_wire(
"account/login/completed".into(),
json!({"error":null,"loginId":"login-1","success":true}),
);
router.route_notification(login.clone());
let mut login_events = router.subscribe_login("login-1").unwrap();
assert_eq!(login_events.recv().await.unwrap().unwrap(), login);
assert!(matches!(
router.subscribe_login("login-1"),
Err(Error::StreamConsumed)
));
router.route_notification(login.clone());
assert_eq!(login_events.recv().await.unwrap().unwrap(), login);
let warning = Notification::from_wire("warning".into(), json!({"message":"warning"}));
router.route_notification(warning.clone());
assert_eq!(global.recv().await.unwrap().unwrap(), warning);
router.unsubscribe_turn("turn-1");
router.unsubscribe_login("login-1");
router.route_notification(turn);
router.route_notification(login);
assert!(router.pending_turns.lock().unwrap().contains_key("turn-1"));
assert!(
router
.pending_logins
.lock()
.unwrap()
.contains_key("login-1")
);
router.unsubscribe_turn("turn-1");
router.unsubscribe_login("login-1");
assert!(router.pending_turns.lock().unwrap().is_empty());
assert!(router.pending_logins.lock().unwrap().is_empty());
}
#[tokio::test]
async fn router_failure_releases_every_waiter_and_clears_pending_events() {
let (router, mut global) = router();
let (response_sender, response) = oneshot::channel();
router.register_response("one".into(), response_sender);
let mut turn = router.subscribe_turn("turn-1").unwrap();
let mut login = router.subscribe_login("login-1").unwrap();
router.route_notification(Notification::from_wire(
"future".into(),
json!({"turnId":"pending-turn"}),
));
router.route_notification(Notification::from_wire(
"account/login/completed".into(),
json!({"error":null,"loginId":"pending-login","success":true}),
));
router.fail_all("stopped");
assert!(matches!(
response.await.unwrap(),
Err(Error::TransportClosed(message)) if message == "stopped"
));
assert!(matches!(
turn.recv().await.unwrap(),
Err(Error::TransportClosed(message)) if message == "stopped"
));
assert!(matches!(
login.recv().await.unwrap(),
Err(Error::TransportClosed(message)) if message == "stopped"
));
assert!(matches!(
global.recv().await.unwrap(),
Err(Error::TransportClosed(message)) if message == "stopped"
));
assert!(router.pending_turns.lock().unwrap().is_empty());
assert!(router.pending_logins.lock().unwrap().is_empty());
}
#[tokio::test]
async fn transport_direct_operations_cover_typed_failures_and_idempotent_close() {
let (_temp, mut config) = mock_config();
config
.env
.insert("MOCK_CODEX_STARTUP_MODE".into(), "stderr".into());
let transport = Transport::start(&config).unwrap();
assert!(format!("{transport:?}").contains("TransportInner"));
let _: Value = transport
.request("initialize", Some(json!({"test":true})))
.await
.unwrap();
transport
.notify("initialized", Some(json!({"test":true})))
.await
.unwrap();
assert!(matches!(
transport.request::<u64>("model/list", None).await,
Err(Error::InvalidResponse {
method: "model/list",
..
})
));
transport.close().await.unwrap();
transport.close().await.unwrap();
assert!(matches!(
transport.request_value("closed", None).await,
Err(Error::TransportClosed(_))
));
assert!(matches!(
transport.notify("closed", None).await,
Err(Error::TransportClosed(_))
));
}
#[tokio::test]
async fn transport_classifies_spawn_and_invalid_wire_failures() {
let config = CodexConfig {
launch_args_override: Some(vec!["definitely-missing-codex-test-binary".into()]),
..CodexConfig::default()
};
assert!(matches!(
Transport::start(&config),
Err(Error::BinaryNotFound(_))
));
let not_executable = tempfile::NamedTempFile::new().unwrap();
let config = CodexConfig {
launch_args_override: Some(vec![not_executable.path().into()]),
..CodexConfig::default()
};
assert!(matches!(Transport::start(&config), Err(Error::Launch(_))));
for mode in ["invalid-json", "scalar-json"] {
let (_temp, mut config) = mock_config();
config
.env
.insert("MOCK_CODEX_STARTUP_MODE".into(), mode.into());
let transport = Transport::start(&config).unwrap();
assert!(matches!(
transport.next_global_notification().await,
Err(Error::TransportClosed(_))
));
transport.close().await.unwrap();
}
}
}