feat: capture MCP protocol logging notifications in server connection logs

The McpClientHandler was missing an on_logging_message implementation,
causing all MCP protocol notifications/message log entries from servers
to be silently dropped. Only connection lifecycle events and stderr were
visible. This adds:

- LogSource::Server variant for MCP protocol log messages
- on_logging_message handler that forwards to ServerLogManager
- LoggingLevel -> LogLevel mapping (MCP -> internal)
- Cyan color for 'server' source in the log viewer UI

Signed-off-by: Claude <noreply@anthropic.com>

https://claude.ai/code/session_01CHdV8mcWB77r9Tf27K6o9f
Signed-off-by: Claude <noreply@anthropic.com>

Author: claude

apps/desktop/src/components/ServerLogViewer.tsx

@@ -29,6 +29,7 @@ const SOURCE_COLORS: Record<string, string> = {
   'sse-event': 'text-indigo-400',
   connection: 'text-green-300',
   oauth: 'text-pink-400',
+  server: 'text-cyan-400',
 };
 
 export function ServerLogViewer({ serverId, serverName, onClose }: ServerLogViewerProps) {

crates/mcpmux-core/src/domain/server_log.rs

@@ -101,6 +101,8 @@ pub enum LogSource {
     Connection,
     /// OAuth flow
     OAuth,
+    /// MCP protocol logging notifications (notifications/message from server)
+    Server,
 }
 
 impl LogSource {
@@ -114,6 +116,7 @@ impl LogSource {
             Self::SseEvent => "sse-event",
             Self::Connection => "connection",
             Self::OAuth => "oauth",
+            Self::Server => "server",
         }
     }
 }

crates/mcpmux-gateway/src/pool/instance.rs

@@ -6,9 +6,11 @@
 use std::collections::HashMap;
 use std::time::Instant;
 
-use mcpmux_core::DomainEvent;
+use std::sync::Arc;
+
+use mcpmux_core::{DomainEvent, LogLevel, LogSource, ServerLog, ServerLogManager};
 use parking_lot::RwLock;
-use rmcp::model::{ClientCapabilities, ClientInfo, Implementation};
+use rmcp::model::{ClientCapabilities, ClientInfo, Implementation, LoggingLevel};
 use rmcp::service::{NotificationContext, RunningService};
 use rmcp::RoleClient;
 use serde::{Deserialize, Serialize};
@@ -22,19 +24,31 @@ pub use mcpmux_core::TransportType;
 pub type McpClient = RunningService<RoleClient, McpClientHandler>;
 
 /// Client handler for MCP connections
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 pub struct McpClientHandler {
     info: ClientInfo,
     server_id: String,
     space_id: Uuid,
     event_tx: Option<tokio::sync::broadcast::Sender<DomainEvent>>,
+    log_manager: Option<Arc<ServerLogManager>>,
+}
+
+impl std::fmt::Debug for McpClientHandler {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("McpClientHandler")
+            .field("server_id", &self.server_id)
+            .field("space_id", &self.space_id)
+            .field("log_manager", &self.log_manager.is_some())
+            .finish()
+    }
 }
 
 impl McpClientHandler {
     pub fn new(
         server_id: &str,
         space_id: Uuid,
         event_tx: Option<tokio::sync::broadcast::Sender<DomainEvent>>,
+        log_manager: Option<Arc<ServerLogManager>>,
     ) -> Self {
         Self {
             info: ClientInfo {
@@ -53,6 +67,17 @@ impl McpClientHandler {
             server_id: server_id.to_string(),
             space_id,
             event_tx,
+            log_manager,
+        }
+    }
+
+    /// Convert MCP protocol LoggingLevel to our internal LogLevel
+    fn convert_logging_level(level: &LoggingLevel) -> LogLevel {
+        match level {
+            LoggingLevel::Debug => LogLevel::Debug,
+            LoggingLevel::Info | LoggingLevel::Notice => LogLevel::Info,
+            LoggingLevel::Warning => LogLevel::Warn,
+            LoggingLevel::Error | LoggingLevel::Critical | LoggingLevel::Alert | LoggingLevel::Emergency => LogLevel::Error,
         }
     }
 }
@@ -191,6 +216,45 @@ impl rmcp::ClientHandler for McpClientHandler {
             }
         }
     }
+
+    fn on_logging_message(
+        &self,
+        params: rmcp::model::LoggingMessageNotificationParam,
+        _context: NotificationContext<RoleClient>,
+    ) -> impl std::future::Future<Output = ()> + Send + '_ {
+        let server_id = self.server_id.clone();
+        let space_id = self.space_id;
+        let log_manager = self.log_manager.clone();
+        async move {
+            // Format the log message from the MCP data field
+            let message = match &params.data {
+                serde_json::Value::String(s) => s.clone(),
+                other => other.to_string(),
+            };
+
+            let level = Self::convert_logging_level(&params.level);
+
+            debug!(
+                server_id = %server_id,
+                space_id = %space_id,
+                level = ?params.level,
+                logger = ?params.logger,
+                "[McpClientHandler] Server log: {}",
+                message
+            );
+
+            if let Some(log_manager) = &log_manager {
+                let mut log = ServerLog::new(level, LogSource::Server, &message);
+                // Include logger name in metadata if present
+                if let Some(logger) = &params.logger {
+                    log = log.with_metadata(serde_json::json!({ "logger": logger }));
+                }
+                let _ = log_manager
+                    .append(&space_id.to_string(), &server_id, log)
+                    .await;
+            }
+        }
+    }
 }
 
 /// Instance key - identifies a server instance for debugging/logging.

crates/mcpmux-gateway/src/pool/transport/http.rs

@@ -244,7 +244,7 @@ impl HttpTransport {
         let transport = StreamableHttpClientTransport::with_client(auth_client, transport_config);
 
         let client_handler =
-            create_client_handler(&self.server_id, self.space_id, self.event_tx.clone());
+            create_client_handler(&self.server_id, self.space_id, self.event_tx.clone(), self.log_manager.clone());
 
         let connect_future = client_handler.serve(transport);
         match tokio::time::timeout(self.connect_timeout, connect_future).await {
@@ -364,7 +364,7 @@ impl HttpTransport {
         let transport = StreamableHttpClientTransport::with_client(client, transport_config);
 
         let client_handler =
-            create_client_handler(&self.server_id, self.space_id, self.event_tx.clone());
+            create_client_handler(&self.server_id, self.space_id, self.event_tx.clone(), self.log_manager.clone());
 
         let connect_future = client_handler.serve(transport);
         match tokio::time::timeout(self.connect_timeout, connect_future).await {
@@ -431,7 +431,7 @@ impl HttpTransport {
 
         let transport = StreamableHttpClientTransport::from_uri(self.url.as_str());
         let client_handler =
-            create_client_handler(&self.server_id, self.space_id, self.event_tx.clone());
+            create_client_handler(&self.server_id, self.space_id, self.event_tx.clone(), self.log_manager.clone());
 
         let connect_future = client_handler.serve(transport);
         match tokio::time::timeout(self.connect_timeout, connect_future).await {

crates/mcpmux-gateway/src/pool/transport/mod.rs

@@ -170,6 +170,7 @@ pub fn create_client_handler(
     server_id: &str,
     space_id: uuid::Uuid,
     event_tx: Option<tokio::sync::broadcast::Sender<mcpmux_core::DomainEvent>>,
+    log_manager: Option<Arc<ServerLogManager>>,
 ) -> McpClientHandler {
-    McpClientHandler::new(server_id, space_id, event_tx)
+    McpClientHandler::new(server_id, space_id, event_tx, log_manager)
 }

crates/mcpmux-gateway/src/pool/transport/stdio.rs

@@ -209,8 +209,12 @@ impl StdioTransport {
             };
 
         // Create client handler
-        let client_handler =
-            create_client_handler(&self.server_id, self.space_id, self.event_tx.clone());
+        let client_handler = create_client_handler(
+            &self.server_id,
+            self.space_id,
+            self.event_tx.clone(),
+            self.log_manager.clone(),
+        );
 
         // Connect with timeout
         let connect_future = client_handler.serve(transport);