Execute chipmunk search call for ApplyFilter message

Author: the-nick-fischer

application/apps/indexer/mcp/src/server/messages.rs

@@ -11,5 +11,11 @@ pub enum McpServerToChipmunk {
     },
 }
 
-// TODO: Mock
-pub type SearchFilter = String;
+// TODO: MOCK
+#[derive(Debug)]
+pub struct SearchFilter {
+    pub value: String,
+    pub is_regex: bool,
+    pub ignore_case: bool,
+    pub is_word: bool,
+}

application/apps/indexer/mcp/src/server/mod.rs

@@ -40,7 +40,12 @@ impl McpServer {
 
         let (response_tx, response_rx) = oneshot::channel();
 
-        let filters = vec![SearchFilter::from("Test")];
+        let filters = vec![SearchFilter {
+            value: String::from("icmp_seq=13"),
+            is_regex: false,
+            ignore_case: true,
+            is_word: true,
+        }];
 
         let message = McpServerToChipmunk::ApplyFilter {
             filters,
@@ -54,10 +59,18 @@ impl McpServer {
             return;
         }
 
-        if let Err(err) = response_rx.await {
-            error!(
-                "[Chipmunk] -X-> [MCP server]: server failed to receive response: ApplyFilter: {err}"
-            );
+        match response_rx.await {
+            Err(err) => {
+                error!(
+                    "[Chipmunk] -X-> [MCP server]: server failed to receive response: ApplyFilter: {err}"
+                );
+            }
+            Ok(result) => {
+                error!(
+                    "[Chipmunk] --> [MCP server]: ✅ Received response: {:?}",
+                    result
+                )
+            }
         }
     }
 }

application/apps/indexer/mcp/src/types.rs

@@ -3,22 +3,16 @@ use std::fmt;
 #[derive(Debug)]
 pub enum McpError {
     Generic { message: String },
+    ApplyFilter { message: String },
 }
 
 impl fmt::Display for McpError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             McpError::Generic { message } => write!(f, "{}", message),
+            McpError::ApplyFilter { message } => write!(f, "{}", message),
         }
     }
 }
 
 impl std::error::Error for McpError {}
-
-impl McpError {
-    pub fn generic(message: impl Into<String>) -> Self {
-        McpError::Generic {
-            message: message.into(),
-        }
-    }
-}

application/apps/indexer/session/src/mcp_api/mod.rs

@@ -1,12 +1,16 @@
+use crate::operations::{Operation, OperationKind};
 use crate::state::SessionStateAPI;
 use crate::tracker::OperationTrackerAPI;
 use log::error;
 use mcp::McpChannelEndpoints;
 use mcp::client::messages::{McpChipmunkToClient, McpClientToChipmunk};
 use mcp::server::messages::McpServerToChipmunk;
+use mcp::types::McpError;
+use processor::search::filter::SearchFilter;
 use tokio::select;
 use tokio::sync::mpsc;
 use tokio::sync::mpsc::UnboundedSender;
+use uuid::Uuid;
 
 #[derive(Debug, Clone)]
 pub struct McpApi {
@@ -43,30 +47,43 @@ impl McpApi {
 }
 
 pub async fn run(
+    session_uuid: Uuid,
     mut server_to_chipmunk_rx: tokio::sync::mpsc::Receiver<McpServerToChipmunk>,
     mut client_to_chipmunk_rx: tokio::sync::mpsc::Receiver<McpClientToChipmunk>,
+    tx_operations: UnboundedSender<Operation>,
     state_api: SessionStateAPI,
     tracker_api: OperationTrackerAPI,
     tx_callback_events: UnboundedSender<stypes::CallbackEvent>,
 ) {
     loop {
         select! {
-            Some(message) = server_to_chipmunk_rx.recv() => {
-                match message {
+            Some(server_request) = server_to_chipmunk_rx.recv() => {
+                match server_request {
                     McpServerToChipmunk::ApplyFilter {filters, response_tx} => {
-                        // TODO: Impelment functionality
-                        // state_api.set_matches(None, None).await;
 
-                        if let Err(err) = response_tx.send(Ok(())) {
-                            error!("\t[Chipmunk] -X-> [MCP server]: chipmunk failed to send response: ApplyFilter: {:?}", err);
-                        }
+                        error!(
+                            "[Chipmunk] received filters: {:?}", filters
+                        );
+
+                        let filters = filters.iter().map(|f| SearchFilter::new(f.value.clone(), f.is_regex, f.ignore_case, f.is_word)).collect();
 
+                        // Create a new Operation
+                        let operation = Operation::new(
+                            session_uuid,
+                            OperationKind::Search { filters },
+                        );
+
+                        if let Err(err) = tx_operations.send(operation) {
+                            let _ = response_tx.send(Err(McpError::ApplyFilter {message: err.to_string(),}));
+                        } else {
+                            let _ = response_tx.send(Ok(()));
+                        }
 
                     }
                 }
             }
-            Some(message) = client_to_chipmunk_rx.recv() => {
-                match message {
+            Some(client_request) = client_to_chipmunk_rx.recv() => {
+                match client_request {
                     McpClientToChipmunk::Response {..} => {
                         // TODO: Implement functionality
                     }

application/apps/indexer/session/src/session.rs

@@ -105,8 +105,10 @@ impl Session {
                 async {
                     join!(
                         mcp_api::run(
+                            uuid,
                             mcp_server_to_chipmunk_rx,
                             mcp_client_to_chipmunk_rx,
+                            tx_operations.clone(),
                             state_api.clone(),
                             tracker_api.clone(),
                             tx_callback_events.clone(),

application/apps/indexer/session/src/state/api.rs

@@ -29,7 +29,7 @@ use tokio_util::sync::CancellationToken;
 use uuid::Uuid;
 
 pub enum Api {
-    // TODO: Do we need to keep track of context. E.g. store a promptID?
+    // TODO: Can this be removed? Do we need to keep track of context. E.g. store a promptID?
     SendChatPrompt(String),
     SetSessionFile(
         (
@@ -266,7 +266,7 @@ impl Display for Api {
 }
 
 #[derive(Clone, Debug)]
-pub struct SessionStateAPI {
+pub struct  SessionStateAPI {
     tx_api: UnboundedSender<Api>,
     tracker: OperationTrackerAPI,
     closing_token: CancellationToken,