feat(acp-nats): add fs_write_text_file client handler

Signed-off-by: Yordis Prieto <yordis.prieto@gmail.com>

Author: yordis

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

@@ -0,0 +1,271 @@
+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,
+) {
+    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, session_id).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,
+                        ErrorCode::InternalError,
+                        &format!("Failed to serialize response: {}", e),
+                    )
+                });
+            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,
+    expected_session_id: &str,
+) -> 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"))
+    })?;
+    let params_session_id = request.session_id.to_string();
+    if params_session_id != expected_session_id {
+        return Err(FsWriteTextFileError::InvalidRequest(
+            serde_json::Error::custom(format!(
+                "params.sessionId ({}) does not match subject session id ({})",
+                params_session_id, expected_session_id
+            )),
+        ));
+    }
+    client
+        .write_text_file(request)
+        .await
+        .map_err(FsWriteTextFileError::ClientError)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use agent_client_protocol::{
+        ReadTextFileRequest, ReadTextFileResponse, Request, RequestId, RequestPermissionRequest,
+        RequestPermissionResponse, SessionNotification,
+    };
+    use async_trait::async_trait;
+    use trogon_nats::MockNatsClient;
+    use trogon_std::StdJsonSerialize;
+
+    struct FailingClient;
+
+    #[async_trait(?Send)]
+    impl Client for FailingClient {
+        async fn session_notification(
+            &self,
+            _: SessionNotification,
+        ) -> agent_client_protocol::Result<()> {
+            Ok(())
+        }
+
+        async fn request_permission(
+            &self,
+            _: RequestPermissionRequest,
+        ) -> agent_client_protocol::Result<RequestPermissionResponse> {
+            Err(agent_client_protocol::Error::new(
+                -32603,
+                "not implemented in test mock",
+            ))
+        }
+
+        async fn read_text_file(
+            &self,
+            _: ReadTextFileRequest,
+        ) -> agent_client_protocol::Result<ReadTextFileResponse> {
+            Err(agent_client_protocol::Error::new(
+                -32603,
+                "not implemented in test mock",
+            ))
+        }
+
+        async fn write_text_file(
+            &self,
+            _: WriteTextFileRequest,
+        ) -> agent_client_protocol::Result<WriteTextFileResponse> {
+            Err(agent_client_protocol::Error::new(
+                i32::from(ErrorCode::InvalidParams),
+                "permission denied",
+            ))
+        }
+    }
+
+    #[tokio::test]
+    async fn handle_client_error_publishes_error_reply_with_matching_id() {
+        let nats = MockNatsClient::new();
+        let client = FailingClient;
+        let envelope = Request {
+            id: RequestId::Number(99),
+            method: std::sync::Arc::from("fs/write_text_file"),
+            params: Some(WriteTextFileRequest::new(
+                agent_client_protocol::SessionId::from("sess-1"),
+                "/forbidden.txt".to_string(),
+                "content".to_string(),
+            )),
+        };
+        let payload = serde_json::to_vec(&envelope).unwrap();
+
+        handle(
+            &payload,
+            &client,
+            Some("_INBOX.err"),
+            &nats,
+            "sess-1",
+            &StdJsonSerialize,
+        )
+        .await;
+
+        assert_eq!(nats.published_messages(), vec!["_INBOX.err"]);
+        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"], 99,
+            "error response must preserve request id"
+        );
+        assert!(
+            response.get("error").is_some(),
+            "error response must have error field"
+        );
+        assert_eq!(
+            response["error"]["code"],
+            i32::from(ErrorCode::InvalidParams)
+        );
+    }
+
+    #[tokio::test]
+    async fn handle_invalid_payload_publishes_error_reply() {
+        let nats = MockNatsClient::new();
+        let client = FailingClient;
+
+        handle(
+            b"not json",
+            &client,
+            Some("_INBOX.err"),
+            &nats,
+            "sess-1",
+            &StdJsonSerialize,
+        )
+        .await;
+
+        assert_eq!(nats.published_messages(), vec!["_INBOX.err"]);
+        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!(response.get("error").is_some());
+    }
+
+    #[test]
+    fn error_code_and_message_client_error_preserves_client_code() {
+        let client_err =
+            agent_client_protocol::Error::new(ErrorCode::InvalidParams.into(), "permission denied");
+        let fs_err = FsWriteTextFileError::ClientError(client_err);
+        let (code, message) = error_code_and_message(&fs_err);
+        assert_eq!(code, ErrorCode::InvalidParams);
+        assert_eq!(message, "permission denied");
+    }
+}