nits in exec server

codex-rs/exec-server/tests/exec_process.rs

@@ -6,10 +6,9 @@ use std::sync::Arc;
 
 use anyhow::Result;
 use codex_exec_server::Environment;
+use codex_exec_server::ExecBackend;
 use codex_exec_server::ExecParams;
-use codex_exec_server::ExecProcess;
 use codex_exec_server::ExecSessionEvent;
-use codex_exec_server::ExecSessionHandle;
 use pretty_assertions::assert_eq;
 use test_case::test_case;
 use tokio::time::Duration;
@@ -19,7 +18,7 @@ use common::exec_server::ExecServerHarness;
 use common::exec_server::exec_server;
 
 struct ProcessContext {
-    process: Arc<dyn ExecProcess>,
+    backend: Arc<dyn ExecBackend>,
     _server: Option<ExecServerHarness>,
 }
 
@@ -28,13 +27,13 @@ async fn create_process_context(use_remote: bool) -> Result<ProcessContext> {
         let server = exec_server().await?;
         let environment = Environment::create(Some(server.websocket_url().to_string())).await?;
         Ok(ProcessContext {
-            process: environment.get_executor(),
+            backend: environment.get_exec_backend(),
             _server: Some(server),
         })
     } else {
         let environment = Environment::create(None).await?;
         Ok(ProcessContext {
-            process: environment.get_executor(),
+            backend: environment.get_exec_backend(),
             _server: None,
         })
     }
@@ -42,8 +41,8 @@ async fn create_process_context(use_remote: bool) -> Result<ProcessContext> {
 
 async fn assert_exec_process_starts_and_exits(use_remote: bool) -> Result<()> {
     let context = create_process_context(use_remote).await?;
-    let mut session = context
-        .process
+    let session = context
+        .backend
         .start(ExecParams {
             process_id: "proc-1".to_string(),
             argv: vec!["true".to_string()],
@@ -53,11 +52,12 @@ async fn assert_exec_process_starts_and_exits(use_remote: bool) -> Result<()> {
             arg0: None,
         })
         .await?;
-    assert_eq!(session.process_id, "proc-1");
+    assert_eq!(session.process_id().as_str(), "proc-1");
+    let mut events = session.subscribe();
 
     let mut exit_code = None;
     loop {
-        match timeout(Duration::from_secs(2), session.events.recv()).await?? {
+        match timeout(Duration::from_secs(2), events.recv()).await?? {
             ExecSessionEvent::Exited {
                 exit_code: code, ..
             } => exit_code = Some(code),
@@ -71,12 +71,13 @@ async fn assert_exec_process_starts_and_exits(use_remote: bool) -> Result<()> {
 }
 
 async fn collect_process_output_from_events(
-    mut session: ExecSessionHandle,
+    session: Arc<dyn codex_exec_server::ExecProcess>,
 ) -> Result<(String, i32, bool)> {
+    let mut events = session.subscribe();
     let mut output = String::new();
     let mut exit_code = None;
     loop {
-        match timeout(Duration::from_secs(2), session.events.recv()).await?? {
+        match timeout(Duration::from_secs(2), events.recv()).await?? {
             ExecSessionEvent::Output { chunk, .. } => {
                 output.push_str(&String::from_utf8_lossy(&chunk));
             }
@@ -95,7 +96,7 @@ async fn assert_exec_process_streams_output(use_remote: bool) -> Result<()> {
     let context = create_process_context(use_remote).await?;
     let process_id = "proc-stream".to_string();
     let session = context
-        .process
+        .backend
         .start(ExecParams {
             process_id: process_id.clone(),
             argv: vec![
@@ -109,7 +110,7 @@ async fn assert_exec_process_streams_output(use_remote: bool) -> Result<()> {
             arg0: None,
         })
         .await?;
-    assert_eq!(session.process_id, process_id);
+    assert_eq!(session.process_id().as_str(), process_id);
 
     let (output, exit_code, closed) = collect_process_output_from_events(session).await?;
     assert_eq!(output, "session output\n");
@@ -122,7 +123,7 @@ async fn assert_exec_process_write_then_read(use_remote: bool) -> Result<()> {
     let context = create_process_context(use_remote).await?;
     let process_id = "proc-stdin".to_string();
     let session = context
-        .process
+        .backend
         .start(ExecParams {
             process_id: process_id.clone(),
             argv: vec![
@@ -136,10 +137,10 @@ async fn assert_exec_process_write_then_read(use_remote: bool) -> Result<()> {
             arg0: None,
         })
         .await?;
-    assert_eq!(session.process_id, process_id);
+    assert_eq!(session.process_id().as_str(), process_id);
 
     tokio::time::sleep(Duration::from_millis(200)).await;
-    session.write_stdin(b"hello\n".to_vec()).await?;
+    session.write(b"hello\n".to_vec()).await?;
     let (output, exit_code, closed) = collect_process_output_from_events(session).await?;
 
     assert!(
@@ -151,6 +152,35 @@ async fn assert_exec_process_write_then_read(use_remote: bool) -> Result<()> {
     Ok(())
 }
 
+async fn assert_exec_process_preserves_queued_events_before_subscribe(
+    use_remote: bool,
+) -> Result<()> {
+    let context = create_process_context(use_remote).await?;
+    let session = context
+        .backend
+        .start(ExecParams {
+            process_id: "proc-queued".to_string(),
+            argv: vec![
+                "/bin/sh".to_string(),
+                "-c".to_string(),
+                "printf 'queued output\\n'".to_string(),
+            ],
+            cwd: std::env::current_dir()?,
+            env: Default::default(),
+            tty: false,
+            arg0: None,
+        })
+        .await?;
+
+    tokio::time::sleep(Duration::from_millis(200)).await;
+
+    let (output, exit_code, closed) = collect_process_output_from_events(session).await?;
+    assert_eq!(output, "queued output\n");
+    assert_eq!(exit_code, 0);
+    assert!(closed);
+    Ok(())
+}
+
 #[test_case(false ; "local")]
 #[test_case(true ; "remote")]
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
@@ -171,3 +201,10 @@ async fn exec_process_streams_output(use_remote: bool) -> Result<()> {
 async fn exec_process_write_then_read(use_remote: bool) -> Result<()> {
     assert_exec_process_write_then_read(use_remote).await
 }
+
+#[test_case(false ; "local")]
+#[test_case(true ; "remote")]
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn exec_process_preserves_queued_events_before_subscribe(use_remote: bool) -> Result<()> {
+    assert_exec_process_preserves_queued_events_before_subscribe(use_remote).await
+}