add message interceptor return action

Author: cameronfyfe

mcp-guardian-core/src/message_interceptor.rs

@@ -16,6 +16,7 @@ use crate::message::{
 pub enum MessageInterceptorAction {
     Send(Message),
     Drop,
+    Return(Message),
 }
 
 #[async_trait]

mcp-guardian-core/src/message_interceptor/chain.rs

@@ -7,7 +7,7 @@ use crate::{
     message::{Message, MessageDirection},
     message_interceptor::{
         MessageInterceptor, MessageInterceptorAction,
-        MessageInterceptorAction::{Drop, Send},
+        MessageInterceptorAction::{Drop, Return, Send},
     },
 };
 pub struct ChainInterceptor {
@@ -35,6 +35,7 @@ impl MessageInterceptor for ChainInterceptor {
             match interceptor.intercept_message(direction, message).await? {
                 Send(new_message) => message = new_message,
                 Drop => return Ok(Drop),
+                Return(return_message) => return Ok(Return(return_message)),
             }
         }
 

mcp-guardian-core/src/message_interceptor/manual_approval.rs

@@ -1,11 +1,12 @@
 use anyhow::Result;
 use async_trait::async_trait;
+use serde_json::json;
 use tokio::time::{sleep, Duration};
 use uuid::Uuid;
-use MessageInterceptorAction::{Drop, Send};
+use MessageInterceptorAction::{Return, Send};
 
 use crate::{
-    message::{Message, MessageDirection},
+    message::{Message, MessageDirection, MessageType},
     message_approval::{request_approval, MessageStatus},
     message_interceptor::{MessageInterceptor, MessageInterceptorAction},
 };
@@ -43,7 +44,30 @@ impl MessageInterceptor for ManualApprovalInterceptor {
                     return Ok(Send(message));
                 }
                 MessageStatus::Denied | MessageStatus::Unknown => {
-                    return Ok(Drop);
+                    let id = message
+                        .raw_msg
+                        .get("id")
+                        .ok_or_else(|| anyhow::anyhow!("Request message did not contain an ID"))?
+                        .to_owned();
+
+                    let return_message = Message {
+                        type_: MessageType::ResponseSuccess,
+                        raw_msg: json!({
+                            "id": id,
+                            "jsonrpc": "2.0",
+                            "result": {
+                                "content": [
+                                    {
+                                        "text": "Acess approval was denied.",
+                                        "type": "text"
+                                    }
+                                ],
+                                "isError": false
+                            }
+                        }),
+                    };
+
+                    return Ok(Return(return_message));
                 }
             }
         }

mcp-guardian-core/src/proxy.rs

@@ -13,7 +13,7 @@ use crate::{
     message::Message,
     message_interceptor::{
         MessageInterceptor,
-        MessageInterceptorAction::{Drop, Send},
+        MessageInterceptorAction::{Drop, Return, Send},
     },
 };
 
@@ -128,6 +128,14 @@ pub async fn proxy_mcp_server(
                         }
                     }
                     Ok(Drop) => {}
+                    Ok(Return(message)) => {
+                        if let Err(e) = writeln!(io::stdout(), "{}", message.raw_msg) {
+                            log::error!("Failed to write to stdout: {e}");
+                        }
+                        if let Err(e) = io::stdout().flush() {
+                            log::error!("Failed to flush stdout: {e}");
+                        }
+                    }
                     Err(e) => {
                         log::error!("Failed to intercept outbound message properly: {e}");
                     }
@@ -161,6 +169,14 @@ pub async fn proxy_mcp_server(
                         }
                     }
                     Ok(Drop) => {}
+                    Ok(Return(message)) => {
+                        if let Err(e) = writeln!(io::stdout(), "{}", message.raw_msg) {
+                            log::error!("Failed to write to stdout: {e}");
+                        }
+                        if let Err(e) = io::stdout().flush() {
+                            log::error!("Failed to flush stdout: {e}");
+                        }
+                    }
                     Err(e) => {
                         log::error!("Failed to intercept outbound message properly: {e}");
                     }