プロトコルStreamのユーティリティ共通化

crates/pod/src/socket_server.rs

@@ -1,7 +1,7 @@
 use std::io;
 use std::path::PathBuf;
 
-use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
+use protocol::stream::{JsonLineReader, JsonLineWriter};
 use tokio::net::UnixListener;
 use tokio::task::JoinHandle;
 
@@ -61,34 +61,28 @@ impl Drop for SocketServer {
 }
 
 async fn handle_connection(stream: tokio::net::UnixStream, handle: PodHandle) {
-    let (reader, mut writer) = stream.into_split();
-    let mut lines = BufReader::new(reader).lines();
+    let (reader, writer) = stream.into_split();
+    let mut reader = JsonLineReader::new(reader);
+    let mut writer = JsonLineWriter::new(writer);
     let mut rx = handle.subscribe();
 
     // Event writer: broadcast events → socket
     let write_task = tokio::spawn(async move {
         while let Ok(event) = rx.recv().await {
-            if let Ok(line) = event.to_json_line() {
-                let mut buf = line.into_bytes();
-                buf.push(b'\n');
-                if writer.write_all(&buf).await.is_err() {
-                    break;
-                }
+            if writer.write(&event).await.is_err() {
+                break;
             }
         }
     });
 
     // Method reader: socket → controller
-    while let Ok(Some(line)) = lines.next_line().await {
-        if line.is_empty() {
-            continue;
-        }
-        match Method::from_json_line(&line) {
-            Ok(method) => {
+    loop {
+        match reader.next::<Method>().await {
+            Ok(Some(method)) => {
                 let _ = handle.send(method).await;
             }
+            Ok(None) => break,
             Err(e) => {
-                // Send parse error back as an event
                 let _ = handle.send_event(Event::Error {
                     code: protocol::ErrorCode::Internal,
                     message: format!("invalid method: {e}"),

crates/pod/tests/controller_test.rs

@@ -331,7 +331,7 @@ async fn status_json_reflects_pod_name() {
 
 #[tokio::test]
 async fn socket_run_receives_events() {
-    use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
+    use protocol::stream::{JsonLineReader, JsonLineWriter};
     use tokio::net::UnixStream;
 
     let client = MockClient::new(simple_text_events());
@@ -343,12 +343,15 @@ async fn socket_run_receives_events() {
 
     let sock_path = handle.runtime_dir.socket_path();
     let stream = UnixStream::connect(&sock_path).await.unwrap();
-    let (reader, mut writer) = stream.into_split();
-    let mut lines = BufReader::new(reader).lines();
+    let (reader, writer) = stream.into_split();
+    let mut reader = JsonLineReader::new(reader);
+    let mut writer = JsonLineWriter::new(writer);
 
     // Send run method via socket
     writer
-        .write_all(b"{\"method\":\"run\",\"params\":{\"input\":\"Hello\"}}\n")
+        .write(&Method::Run {
+            input: "Hello".into(),
+        })
         .await
         .unwrap();
 
@@ -360,21 +363,16 @@ async fn socket_run_receives_events() {
     let deadline = tokio::time::Instant::now() + std::time::Duration::from_secs(2);
     loop {
         tokio::select! {
-            line = lines.next_line() => {
-                match line {
-                    Ok(Some(line)) => {
-                        let parsed: serde_json::Value = serde_json::from_str(&line).unwrap();
-                        match parsed["event"].as_str() {
-                            Some("turn_start") => saw_turn_start = true,
-                            Some("text_delta") => saw_text_delta = true,
-                            Some("turn_end") => {
-                                saw_turn_end = true;
-                                break;
-                            }
-                            _ => {}
-                        }
+            event = reader.next::<Event>() => {
+                match event {
+                    Ok(Some(Event::TurnStart { .. })) => saw_turn_start = true,
+                    Ok(Some(Event::TextDelta { .. })) => saw_text_delta = true,
+                    Ok(Some(Event::TurnEnd { .. })) => {
+                        saw_turn_end = true;
+                        break;
                     }
-                    _ => break,
+                    Ok(None) | Err(_) => break,
+                    _ => {}
                 }
             }
             _ = tokio::time::sleep_until(deadline) => break,
@@ -388,7 +386,8 @@ async fn socket_run_receives_events() {
 
 #[tokio::test]
 async fn socket_invalid_method_returns_error() {
-    use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
+    use protocol::stream::JsonLineReader;
+    use tokio::io::AsyncWriteExt;
     use tokio::net::UnixStream;
 
     let client = MockClient::new(simple_text_events());
@@ -400,7 +399,7 @@ async fn socket_invalid_method_returns_error() {
     let sock_path = handle.runtime_dir.socket_path();
     let stream = UnixStream::connect(&sock_path).await.unwrap();
     let (reader, mut writer) = stream.into_split();
-    let mut lines = BufReader::new(reader).lines();
+    let mut reader = JsonLineReader::new(reader);
 
     // Send garbage
     writer.write_all(b"{\"bad\":\"json\"}\n").await.unwrap();
@@ -409,16 +408,14 @@ async fn socket_invalid_method_returns_error() {
     let mut saw_error = false;
     loop {
         tokio::select! {
-            line = lines.next_line() => {
-                match line {
-                    Ok(Some(line)) => {
-                        let parsed: serde_json::Value = serde_json::from_str(&line).unwrap();
-                        if parsed["event"] == "error" {
-                            saw_error = true;
-                            break;
-                        }
+            event = reader.next::<Event>() => {
+                match event {
+                    Ok(Some(Event::Error { .. })) => {
+                        saw_error = true;
+                        break;
                     }
-                    _ => break,
+                    Ok(None) | Err(_) => break,
+                    _ => {}
                 }
             }
             _ = tokio::time::sleep_until(deadline) => break,