Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Read voice helper frames independently of pipe chunks (#42404)

Benjamin Carlssondeb147116661
diff --git a/codex-rs/realtime-webrtc/src/client.rs b/codex-rs/realtime-webrtc/src/client.rs
index 98e467ff05..3073ca4dd2 100644
--- a/codex-rs/realtime-webrtc/src/client.rs
+++ b/codex-rs/realtime-webrtc/src/client.rs
@@ -4,20 +4,17 @@ use std::collections::HashMap;
use std::ffi::OsString;
use std::time::Duration;
-use anyhow::Context;
use anyhow::Result;
use anyhow::ensure;
use codex_install_context::CodexPackageLayout;
use codex_utils_pty::ProcessHandle;
use codex_utils_pty::SpawnedProcess;
-use tokio::sync::mpsc;
use tokio::sync::oneshot;
use tokio::time::timeout;
-use crate::MAX_FRAME_BYTES;
use crate::Message;
-use crate::decode_frame;
use crate::encode_frame;
+use crate::message_reader::MessageReader;
const DEADLINE: Duration = Duration::from_secs(/*secs*/ 5);
@@ -25,7 +22,7 @@ const DEADLINE: Duration = Duration::from_secs(/*secs*/ 5);
/// A successful handshake establishes compatibility only, not an active audio session.
pub struct VoiceHost {
process: ProcessHandle,
- output: mpsc::Receiver<Vec<u8>>,
+ output: MessageReader,
exit: oneshot::Receiver<i32>,
}
@@ -60,7 +57,7 @@ impl VoiceHost {
drop(stderr_rx); // Drain and discard diagnostics rather than logging untyped child output.
let mut host = Self {
process: session,
- output: stdout_rx,
+ output: MessageReader::new(stdout_rx),
exit: exit_rx,
};
host.exchange(
@@ -92,23 +89,9 @@ impl VoiceHost {
.send(encode_frame(&request)?)
.await
.map_err(|_| anyhow::anyhow!("voice helper input closed"))?;
- let mut frame = Vec::new();
- loop {
- let chunk = self
- .output
- .recv()
- .await
- .context("voice helper output closed")?;
- ensure!(
- frame.len() + chunk.len() <= MAX_FRAME_BYTES + 4,
- "voice helper output exceeds limit"
- );
- frame.extend(chunk);
- if let Some(response) = decode_frame(&frame)? {
- ensure!(response == expected, "unexpected voice helper response");
- return Ok(());
- }
- }
+ let response = self.output.next().await?;
+ ensure!(response == expected, "unexpected voice helper response");
+ Ok(())
})
.await?
}
diff --git a/codex-rs/realtime-webrtc/src/lib.rs b/codex-rs/realtime-webrtc/src/lib.rs
index dcbe7b49d2..281808152b 100644
--- a/codex-rs/realtime-webrtc/src/lib.rs
+++ b/codex-rs/realtime-webrtc/src/lib.rs
@@ -1,4 +1,5 @@
mod client;
+mod message_reader;
mod protocol;
pub use client::VoiceHost;
diff --git a/codex-rs/realtime-webrtc/src/message_reader.rs b/codex-rs/realtime-webrtc/src/message_reader.rs
new file mode 100644
index 0000000000..aaa45f8d7a
--- /dev/null
+++ b/codex-rs/realtime-webrtc/src/message_reader.rs
@@ -0,0 +1,61 @@
+//! Read bounded helper frames independently of pipe chunks; cancellation retains partial input.
+
+use std::io;
+
+use tokio::sync::mpsc;
+
+use crate::Message;
+use crate::decode_frame;
+
+// Matches the maximum read in codex_utils_pty's pipe output reader. Retain at most
+// one such chunk and one bounded partial frame, never a queue of decoded messages.
+const MAX_CHUNK_BYTES: usize = 8_192;
+
+pub(crate) struct MessageReader {
+ output: mpsc::Receiver<Vec<u8>>,
+ pending: std::vec::IntoIter<u8>,
+ frame: Vec<u8>,
+}
+
+impl MessageReader {
+ pub(crate) fn new(output: mpsc::Receiver<Vec<u8>>) -> Self {
+ Self {
+ output,
+ pending: Vec::new().into_iter(),
+ frame: Vec::new(),
+ }
+ }
+
+ pub(crate) async fn next(&mut self) -> io::Result<Message> {
+ loop {
+ let target = if let [a, b, c, d, ..] = self.frame.as_slice() {
+ // Validate the header before consuming or allocating its payload.
+ decode_frame(&self.frame)?;
+ u32::from_be_bytes([*a, *b, *c, *d]) as usize + 4
+ } else {
+ 4
+ };
+ while self.frame.len() < target {
+ if self.pending.len() == 0 {
+ let chunk = self.output.recv().await.ok_or_else(|| {
+ io::Error::new(io::ErrorKind::UnexpectedEof, "voice helper output closed")
+ })?;
+ if chunk.is_empty() || chunk.len() > MAX_CHUNK_BYTES {
+ return Err(io::Error::other("invalid voice helper output chunk"));
+ }
+ self.pending = chunk.into_iter();
+ }
+ self.frame
+ .extend(self.pending.by_ref().take(target - self.frame.len()));
+ }
+ if let Some(message) = decode_frame(&self.frame)? {
+ self.frame.clear();
+ return Ok(message);
+ }
+ }
+ }
+}
+
+#[cfg(test)]
+#[path = "message_reader_tests.rs"]
+mod tests;
diff --git a/codex-rs/realtime-webrtc/src/message_reader_tests.rs b/codex-rs/realtime-webrtc/src/message_reader_tests.rs
new file mode 100644
index 0000000000..e21e756a23
--- /dev/null
+++ b/codex-rs/realtime-webrtc/src/message_reader_tests.rs
@@ -0,0 +1,144 @@
+//! Exercise real frame decoding across pipe boundaries, cancellation, and invalid input.
+
+use std::future::Future;
+use std::io;
+use std::task::Context;
+use std::task::Poll;
+use std::task::Waker;
+
+use pretty_assertions::assert_eq;
+use tokio::sync::mpsc;
+
+use super::MAX_CHUNK_BYTES;
+use super::MessageReader;
+use crate::MAX_FRAME_BYTES;
+use crate::Message;
+use crate::encode_frame;
+
+#[tokio::test]
+async fn reads_fragmented_and_coalesced_messages() -> io::Result<()> {
+ let expected = [
+ Message::Hello {
+ protocol: 1,
+ build_commit: "test-build".into(),
+ },
+ Message::Ready {},
+ Message::Close {},
+ Message::Closed {},
+ ];
+ let frames = expected
+ .iter()
+ .map(encode_frame)
+ .collect::<io::Result<Vec<_>>>()?
+ .concat();
+ // Every split exercises both a partial frame and multiple messages in a chunk.
+ for split in 1..frames.len() {
+ let (sender, receiver) = mpsc::channel(/*buffer*/ 2);
+ sender.try_send(frames[..split].to_vec()).unwrap();
+ sender.try_send(frames[split..].to_vec()).unwrap();
+ drop(sender);
+ let mut reader = MessageReader::new(receiver);
+ let mut actual = Vec::new();
+ for _ in &expected {
+ actual.push(reader.next().await?);
+ }
+ assert_eq!(actual, expected);
+ assert_eq!(
+ reader.next().await.unwrap_err().kind(),
+ io::ErrorKind::UnexpectedEof
+ );
+ }
+ Ok(())
+}
+
+#[tokio::test]
+async fn cancelled_read_preserves_each_partial_header_and_payload() -> io::Result<()> {
+ let expected = Message::Hello {
+ protocol: 1,
+ build_commit: "test-build".into(),
+ };
+ let frame = encode_frame(&expected)?;
+ for split in 1..frame.len() {
+ let (sender, receiver) = mpsc::channel(/*buffer*/ 1);
+ sender.try_send(frame[..split].to_vec()).unwrap();
+ let mut reader = MessageReader::new(receiver);
+ {
+ let mut read = std::pin::pin!(reader.next());
+ assert!(matches!(
+ read.as_mut().poll(&mut Context::from_waker(Waker::noop())),
+ Poll::Pending
+ ));
+ }
+ sender.try_send(frame[split..].to_vec()).unwrap();
+ assert_eq!(reader.next().await?, expected);
+ }
+ Ok(())
+}
+
+#[tokio::test]
+async fn rejects_oversized_headers_without_waiting_for_payload() {
+ for length in [MAX_FRAME_BYTES as u32 + 1, u32::MAX] {
+ let (sender, receiver) = mpsc::channel(/*buffer*/ 1);
+ sender.try_send(length.to_be_bytes().to_vec()).unwrap();
+ let mut reader = MessageReader::new(receiver);
+ let mut read = std::pin::pin!(reader.next());
+ assert!(matches!(
+ read.as_mut().poll(&mut Context::from_waker(Waker::noop())),
+ Poll::Ready(Err(_))
+ ));
+ }
+}
+
+#[tokio::test]
+async fn rejects_truncation_at_every_byte_boundary() -> io::Result<()> {
+ let frame = encode_frame(&Message::Ready {})?;
+ for end in 0..frame.len() {
+ let (sender, receiver) = mpsc::channel(/*buffer*/ 1);
+ if end > 0 {
+ sender.try_send(frame[..end].to_vec()).unwrap();
+ }
+ drop(sender);
+ assert_eq!(
+ MessageReader::new(receiver)
+ .next()
+ .await
+ .unwrap_err()
+ .kind(),
+ io::ErrorKind::UnexpectedEof
+ );
+ }
+ Ok(())
+}
+
+#[tokio::test]
+async fn rejects_malformed_input_without_echoing_payload() {
+ let secret = b"sensitive-invalid-json";
+ let mut invalid = (secret.len() as u32).to_be_bytes().to_vec();
+ invalid.extend(secret);
+ let (sender, receiver) = mpsc::channel(/*buffer*/ 1);
+ sender.try_send(invalid).unwrap();
+ assert_eq!(
+ MessageReader::new(receiver)
+ .next()
+ .await
+ .unwrap_err()
+ .to_string(),
+ "invalid voice frame"
+ );
+}
+
+#[tokio::test]
+async fn rejects_chunks_outside_the_pipe_read_bound() {
+ for chunk in [vec![], vec![0; MAX_CHUNK_BYTES + 1]] {
+ let (sender, receiver) = mpsc::channel(/*buffer*/ 1);
+ sender.try_send(chunk).unwrap();
+ assert_eq!(
+ MessageReader::new(receiver)
+ .next()
+ .await
+ .unwrap_err()
+ .to_string(),
+ "invalid voice helper output chunk"
+ );
+ }
+}