feat(acp-nats): add fs_write_text_file client handler

Author: yordis

rsworkspace/crates/acp-nats/src/client/fs_write_text_file.rs

@@ -0,0 +1,159 @@
+use crate::client::rpc_reply;
+use crate::jsonrpc::extract_request_id;
+use crate::nats::{FlushClient, PublishClient};
+use agent_client_protocol::{
+    Client, ErrorCode, Request, Response, WriteTextFileRequest, WriteTextFileResponse,
+};
+use bytes::Bytes;
+use serde::de::Error as SerdeDeError;
+use tracing::{instrument, warn};
+use trogon_std::JsonSerialize;
+
+#[derive(Debug)]
+pub enum FsWriteTextFileError {
+    InvalidRequest(serde_json::Error),
+    ClientError(agent_client_protocol::Error),
+}
+
+impl std::fmt::Display for FsWriteTextFileError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::InvalidRequest(e) => write!(f, "invalid request: {}", e),
+            Self::ClientError(e) => write!(f, "client error: {}", e),
+        }
+    }
+}
+
+impl std::error::Error for FsWriteTextFileError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            Self::InvalidRequest(e) => Some(e),
+            Self::ClientError(e) => Some(e),
+        }
+    }
+}
+
+pub fn error_code_and_message(e: &FsWriteTextFileError) -> (ErrorCode, String) {
+    match e {
+        FsWriteTextFileError::InvalidRequest(inner) => (
+            ErrorCode::InvalidParams,
+            format!("Invalid write_text_file request: {}", inner),
+        ),
+        FsWriteTextFileError::ClientError(inner) => (inner.code, inner.message.clone()),
+    }
+}
+
+/// Handles write_text_file: parses request, calls client, wraps response in JSON-RPC envelope,
+/// and publishes to reply subject. Reply is required (request-reply pattern).
+#[instrument(
+    name = "acp.client.fs.write_text_file",
+    skip(payload, client, nats, serializer)
+)]
+pub async fn handle<N: PublishClient + FlushClient, C: Client, S: JsonSerialize>(
+    payload: &[u8],
+    client: &C,
+    reply: Option<&str>,
+    nats: &N,
+    session_id: &str,
+    serializer: &S,
+    max_payload_bytes: usize,
+) {
+    let reply_to = match reply {
+        Some(r) => r,
+        None => {
+            warn!(
+                session_id = %session_id,
+                "write_text_file requires reply subject; ignoring message"
+            );
+            return;
+        }
+    };
+
+    let request_id = extract_request_id(payload);
+    match forward_to_client(payload, client).await {
+        Ok(response) => {
+            let (response_bytes, content_type) = serializer
+                .to_vec(&Response::Result {
+                    id: request_id.clone(),
+                    result: response,
+                })
+                .map(|v| (Bytes::from(v), rpc_reply::CONTENT_TYPE_JSON))
+                .unwrap_or_else(|e| {
+                    warn!(error = %e, "JSON serialization of response failed, sending error reply");
+                    rpc_reply::error_response_bytes(
+                        serializer,
+                        request_id.clone(),
+                        ErrorCode::InternalError,
+                        &format!("Failed to serialize response: {}", e),
+                    )
+                });
+            if response_bytes.len() > max_payload_bytes {
+                warn!(
+                    size = response_bytes.len(),
+                    max = max_payload_bytes,
+                    "write_text_file response exceeds NATS max payload"
+                );
+                let (bytes, content_type) = rpc_reply::error_response_bytes(
+                    serializer,
+                    request_id,
+                    ErrorCode::InternalError,
+                    &format!(
+                        "write_text_file response exceeds NATS max payload: {} > {}",
+                        response_bytes.len(),
+                        max_payload_bytes
+                    ),
+                );
+                rpc_reply::publish_reply(
+                    nats,
+                    reply_to,
+                    bytes,
+                    content_type,
+                    "fs_write_text_file reply",
+                )
+                .await;
+            } else {
+                rpc_reply::publish_reply(
+                    nats,
+                    reply_to,
+                    response_bytes,
+                    content_type,
+                    "fs_write_text_file reply",
+                )
+                .await;
+            }
+        }
+        Err(e) => {
+            let (code, message) = error_code_and_message(&e);
+            warn!(
+                error = %e,
+                session_id = %session_id,
+                "Failed to handle fs_write_text_file"
+            );
+            let (bytes, content_type) =
+                rpc_reply::error_response_bytes(serializer, request_id, code, &message);
+            rpc_reply::publish_reply(
+                nats,
+                reply_to,
+                bytes,
+                content_type,
+                "fs_write_text_file error reply",
+            )
+            .await;
+        }
+    }
+}
+
+async fn forward_to_client<C: Client>(
+    payload: &[u8],
+    client: &C,
+) -> Result<WriteTextFileResponse, FsWriteTextFileError> {
+    let envelope: Request<WriteTextFileRequest> =
+        serde_json::from_slice(payload).map_err(FsWriteTextFileError::InvalidRequest)?;
+    let request = envelope.params.ok_or_else(|| {
+        FsWriteTextFileError::InvalidRequest(serde_json::Error::custom("params is null or missing"))
+    })?;
+    client
+        .write_text_file(request)
+        .await
+        .map_err(FsWriteTextFileError::ClientError)
+}

rsworkspace/crates/acp-nats/src/client/mod.rs

@@ -1,4 +1,5 @@
 pub(crate) mod fs_read_text_file;
+pub(crate) mod fs_write_text_file;
 pub(crate) mod request_permission;
 pub(crate) mod rpc_reply;
 pub(crate) mod session_update;
@@ -196,6 +197,18 @@ async fn dispatch_client_method<
             )
             .await;
         }
+        ClientMethod::FsWriteTextFile => {
+            fs_write_text_file::handle(
+                &payload,
+                ctx.client,
+                reply.as_deref(),
+                ctx.nats,
+                parsed.session_id.as_str(),
+                ctx.serializer,
+                ctx.bridge.config.max_nats_payload_bytes(),
+            )
+            .await;
+        }
         ClientMethod::SessionRequestPermission => {
             request_permission::handle(
                 &payload,
@@ -280,7 +293,7 @@ mod tests {
         RequestPermissionOutcome, RequestPermissionRequest, RequestPermissionResponse,
         SessionNotification, SessionUpdate, TerminalExitStatus, TerminalOutputRequest,
         TerminalOutputResponse, ToolCallUpdate, ToolCallUpdateFields, WaitForTerminalExitRequest,
-        WaitForTerminalExitResponse,
+        WaitForTerminalExitResponse, WriteTextFileRequest, WriteTextFileResponse,
     };
     use async_trait::async_trait;
     use std::cell::RefCell;
@@ -351,6 +364,13 @@ mod tests {
             Ok(ReadTextFileResponse::new("mock file content".to_string()))
         }
 
+        async fn write_text_file(
+            &self,
+            _: WriteTextFileRequest,
+        ) -> agent_client_protocol::Result<WriteTextFileResponse> {
+            Ok(WriteTextFileResponse::new())
+        }
+
         async fn create_terminal(
             &self,
             _: CreateTerminalRequest,
@@ -568,6 +588,87 @@ mod tests {
         assert_eq!(nats.published_messages(), vec!["_INBOX.reply"]);
     }
 
+    #[tokio::test]
+    async fn dispatch_client_method_dispatches_fs_write_text_file() {
+        let nats = MockNatsClient::new();
+        let client = MockClient::new();
+        let session_id = AcpSessionId::new("sess-1").unwrap();
+
+        let envelope = Request {
+            id: RequestId::Number(42),
+            method: std::sync::Arc::from("fs/write_text_file"),
+            params: Some(WriteTextFileRequest::new(
+                agent_client_protocol::SessionId::from("sess-1"),
+                "/tmp/test.txt".to_string(),
+                "content".to_string(),
+            )),
+        };
+        let payload = bytes::Bytes::from(serde_json::to_vec(&envelope).unwrap());
+
+        let parsed = crate::nats::ParsedClientSubject {
+            session_id,
+            method: ClientMethod::FsWriteTextFile,
+        };
+
+        let bridge = make_bridge(nats.clone());
+        let ctx = DispatchContext {
+            nats: &nats,
+            client: &client,
+            bridge: &bridge,
+            serializer: &StdJsonSerialize,
+        };
+        dispatch_client_method(
+            "acp.sess-1.client.fs.write_text_file",
+            parsed,
+            payload,
+            Some("_INBOX.reply".to_string()),
+            &ctx,
+        )
+        .await;
+
+        assert_eq!(nats.published_messages(), vec!["_INBOX.reply"]);
+        let payloads = nats.published_payloads();
+        assert_eq!(payloads.len(), 1);
+        let response: serde_json::Value =
+            serde_json::from_slice(payloads[0].as_ref()).expect("response should be valid JSON");
+        assert_eq!(response["id"], 42, "response must be JSON-RPC envelope with matching id");
+        assert!(response.get("result").is_some(), "success response must have result field");
+    }
+
+    #[tokio::test]
+    async fn fs_write_text_file_round_trip() {
+        let nats = MockNatsClient::new();
+        let client = MockClient::new();
+        let envelope = Request {
+            id: RequestId::Number(1),
+            method: std::sync::Arc::from("fs/write_text_file"),
+            params: Some(WriteTextFileRequest::new(
+                agent_client_protocol::SessionId::from("session-001"),
+                "/tmp/test.txt".to_string(),
+                "content".to_string(),
+            )),
+        };
+        let payload = serde_json::to_vec(&envelope).unwrap();
+
+        fs_write_text_file::handle(
+            &payload,
+            &client,
+            Some("_INBOX.reply"),
+            &nats,
+            "session-001",
+            &StdJsonSerialize,
+            1_048_576,
+        )
+        .await;
+
+        assert_eq!(nats.published_messages(), vec!["_INBOX.reply"]);
+        let payloads = nats.published_payloads();
+        assert_eq!(payloads.len(), 1);
+        let response: serde_json::Value = serde_json::from_slice(payloads[0].as_ref()).unwrap();
+        assert_eq!(response["id"], 1);
+        assert!(response.get("result").is_some());
+    }
+
     #[tokio::test]
     async fn dispatch_client_method_dispatches_terminal_create() {
         let nats = MockNatsClient::new();
@@ -2354,6 +2455,13 @@ mod tests {
             Ok(ReadTextFileResponse::new("mock file content".to_string()))
         }
 
+        async fn write_text_file(
+            &self,
+            _: WriteTextFileRequest,
+        ) -> agent_client_protocol::Result<WriteTextFileResponse> {
+            Ok(WriteTextFileResponse::new())
+        }
+
         async fn create_terminal(
             &self,
             _: CreateTerminalRequest,
@@ -2421,6 +2529,13 @@ mod tests {
             Ok(ReadTextFileResponse::new("mock file content".to_string()))
         }
 
+        async fn write_text_file(
+            &self,
+            _: WriteTextFileRequest,
+        ) -> agent_client_protocol::Result<WriteTextFileResponse> {
+            Ok(WriteTextFileResponse::new())
+        }
+
         async fn create_terminal(
             &self,
             _: CreateTerminalRequest,
@@ -2494,6 +2609,13 @@ mod tests {
             Ok(ReadTextFileResponse::new("mock file content".to_string()))
         }
 
+        async fn write_text_file(
+            &self,
+            _: WriteTextFileRequest,
+        ) -> agent_client_protocol::Result<WriteTextFileResponse> {
+            Ok(WriteTextFileResponse::new())
+        }
+
         async fn create_terminal(
             &self,
             _: CreateTerminalRequest,
@@ -2565,6 +2687,13 @@ mod tests {
             Ok(ReadTextFileResponse::new("mock file content".to_string()))
         }
 
+        async fn write_text_file(
+            &self,
+            _: WriteTextFileRequest,
+        ) -> agent_client_protocol::Result<WriteTextFileResponse> {
+            Ok(WriteTextFileResponse::new())
+        }
+
         async fn create_terminal(
             &self,
             _: CreateTerminalRequest,
@@ -3136,6 +3265,13 @@ mod tests {
             Ok(ReadTextFileResponse::new("file contents".to_string()))
         }
 
+        async fn write_text_file(
+            &self,
+            _: WriteTextFileRequest,
+        ) -> agent_client_protocol::Result<WriteTextFileResponse> {
+            Ok(WriteTextFileResponse::new())
+        }
+
         async fn terminal_output(
             &self,
             _: TerminalOutputRequest,