feat: implement server enable/disable functionality in MCP management

milisp · milisp · commit 8ba45684bbae · 2025-11-13T05:38:48.000-05:00
Added the ability to toggle the enabled state of MCP servers through a new switch component in the MCP page. Updated server configuration types to include an 'enabled' property, and implemented backend support for updating this state in the configuration file. Enhanced error handling and user feedback with toast notifications for better user experience.
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
@@ -30,7 +30,7 @@ use filesystem::{
     },
     watch::{start_watch_directory, stop_watch_directory},
 };
-use mcp::{add_mcp_server, delete_mcp_server, read_mcp_servers};
+use mcp::{add_mcp_server, delete_mcp_server, read_mcp_servers, set_mcp_server_enabled};
 use session_files::{
     cache::{load_project_sessions, write_project_cache, update_project_favorites, remove_project_session},
     delete::{delete_session_file, delete_sessions_files},
@@ -107,6 +107,7 @@ pub fn run() {
             read_mcp_servers,
             add_mcp_server,
             delete_mcp_server,
+            set_mcp_server_enabled,
             config::provider::read_model_providers,
             config::profile::read_profiles,
             config::profile::get_provider_config,
diff --git a/src-tauri/src/mcp.rs b/src-tauri/src/mcp.rs
@@ -3,11 +3,19 @@ use std::collections::HashMap;
 use std::fs;
 use std::str::FromStr;
 use tauri::command;
-use toml_edit::{Document, Item, Table};
+use toml_edit::{value, Document, Item, Table};
 
 use crate::config::{get_config_path, CodexConfig};
 use crate::config::toml_helpers::serialize_to_table;
 
+fn default_enabled() -> bool {
+    true
+}
+
+fn is_enabled_true(enabled: &bool) -> bool {
+    *enabled
+}
+
 #[derive(Debug, Clone, Serialize)]
 #[serde(tag = "type")]
 pub enum McpServerConfig {
@@ -17,11 +25,21 @@ pub enum McpServerConfig {
         args: Vec<String>,
         #[serde(skip_serializing_if = "Option::is_none")]
         env: Option<HashMap<String, String>>,
+        #[serde(default = "default_enabled", skip_serializing_if = "is_enabled_true")]
+        enabled: bool,
     },
     #[serde(rename = "http")]
-    Http { url: String },
+    Http {
+        url: String,
+        #[serde(default = "default_enabled", skip_serializing_if = "is_enabled_true")]
+        enabled: bool,
+    },
     #[serde(rename = "sse")]
-    Sse { url: String },
+    Sse {
+        url: String,
+        #[serde(default = "default_enabled", skip_serializing_if = "is_enabled_true")]
+        enabled: bool,
+    },
 }
 
 impl<'de> Deserialize<'de> for McpServerConfig {
@@ -38,11 +56,21 @@ impl<'de> Deserialize<'de> for McpServerConfig {
                 args: Vec<String>,
                 #[serde(default)]
                 env: Option<HashMap<String, String>>,
+                #[serde(default = "default_enabled")]
+                enabled: bool,
             },
             #[serde(rename = "http")]
-            Http { url: String },
+            Http {
+                url: String,
+                #[serde(default = "default_enabled")]
+                enabled: bool,
+            },
             #[serde(rename = "sse")]
-            Sse { url: String },
+            Sse {
+                url: String,
+                #[serde(default = "default_enabled")]
+                enabled: bool,
+            },
         }
 
         #[derive(Deserialize)]
@@ -52,6 +80,8 @@ impl<'de> Deserialize<'de> for McpServerConfig {
             args: Vec<String>,
             #[serde(default)]
             env: Option<HashMap<String, String>>,
+            #[serde(default = "default_enabled")]
+            enabled: bool,
         }
 
         #[derive(Deserialize)]
@@ -66,16 +96,30 @@ impl<'de> Deserialize<'de> for McpServerConfig {
                 command,
                 args,
                 env,
-            }) => Ok(McpServerConfig::Stdio { command, args, env }),
-            McpServerConfigHelper::Tagged(TaggedMcpServerConfig::Http { url }) => {
-                Ok(McpServerConfig::Http { url })
-            }
-            McpServerConfigHelper::Tagged(TaggedMcpServerConfig::Sse { url }) => {
-                Ok(McpServerConfig::Sse { url })
+                enabled,
+            }) => Ok(McpServerConfig::Stdio {
+                command,
+                args,
+                env,
+                enabled,
+            }),
+            McpServerConfigHelper::Tagged(TaggedMcpServerConfig::Http { url, enabled }) => {
+                Ok(McpServerConfig::Http { url, enabled })
             }
-            McpServerConfigHelper::Legacy(LegacyStdioConfig { command, args, env }) => {
-                Ok(McpServerConfig::Stdio { command, args, env })
+            McpServerConfigHelper::Tagged(TaggedMcpServerConfig::Sse { url, enabled }) => {
+                Ok(McpServerConfig::Sse { url, enabled })
             }
+            McpServerConfigHelper::Legacy(LegacyStdioConfig {
+                command,
+                args,
+                env,
+                enabled,
+            }) => Ok(McpServerConfig::Stdio {
+                command,
+                args,
+                env,
+                enabled,
+            }),
         }
     }
 }
@@ -176,3 +220,47 @@ pub async fn delete_mcp_server(name: String) -> Result<(), String> {
 
     Ok(())
 }
+
+#[command]
+pub async fn set_mcp_server_enabled(name: String, enabled: bool) -> Result<(), String> {
+    let config_path = get_config_path()?;
+
+    if !config_path.exists() {
+        return Err("Config file does not exist".to_string());
+    }
+
+    let content = fs::read_to_string(&config_path)
+        .map_err(|e| format!("Failed to read config file: {}", e))?;
+
+    let mut doc = Document::from_str(&content)
+        .map_err(|e| format!("Failed to parse config file: {}", e))?;
+
+    let mcp_servers_entry = doc
+        .entry("mcp_servers")
+        .or_insert(Item::Table(Table::new()));
+
+    let mcp_servers_table = mcp_servers_entry
+        .as_table_mut()
+        .ok_or("Failed to access mcp_servers table")?;
+
+    let server_entry = mcp_servers_table
+        .get_mut(&name)
+        .ok_or(format!("MCP server '{}' not found", name))?;
+
+    let server_table = server_entry
+        .as_table_mut()
+        .ok_or(format!("MCP server '{}' is not a table", name))?;
+
+    if enabled {
+        server_table.remove("enabled");
+    } else {
+        server_table.insert("enabled", value(enabled));
+    }
+
+    let toml_content = doc.to_string();
+
+    fs::write(&config_path, toml_content)
+        .map_err(|e| format!("Failed to write config file: {}", e))?;
+
+    Ok(())
+}
diff --git a/src/pages/mcp.tsx b/src/pages/mcp.tsx
@@ -2,6 +2,7 @@ import { useState, useEffect } from 'react';
 import { invoke } from '@/lib/tauri-proxy';
 import { Button } from '@/components/ui/button';
 import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
+import { Switch } from '@/components/ui/switch';
 import { Trash2, Plus, Edit, Save, X } from 'lucide-react';
 import { McpServerConfig } from '@/types';
 import { toast } from 'sonner';
@@ -93,6 +94,28 @@ export default function McpPage() {
     }
   };
 
+  const handleToggleServerEnabled = async (name: string, enabled: boolean) => {
+    try {
+      await invoke('set_mcp_server_enabled', { name, enabled });
+      setServers((prev) => {
+        const server = prev[name];
+        if (!server) {
+          return prev;
+        }
+        return {
+          ...prev,
+          [name]: {
+            ...server,
+            enabled,
+          },
+        };
+      });
+    } catch (error) {
+      console.error('Failed to update MCP server enabled flag:', error);
+      toast.error('Failed to update MCP server enabled flag: ' + error);
+    }
+  };
+
   const handleEditServer = (name: string, config: McpServerConfig) => {
     const protocol = getServerProtocol(config);
     const httpUrl = protocol === 'stdio' ? '' : ('url' in config ? config.url : '');
@@ -176,6 +199,7 @@ export default function McpPage() {
             <div className="space-y-2 max-h-96 overflow-y-auto">
               {Object.entries(servers).map(([name, config]) => {
                 const serverType = getServerProtocol(config);
+                const isEnabled = config.enabled ?? true;
                 return (
                   <Card key={name}>
                     {editingServer === name ? (
@@ -210,7 +234,12 @@ export default function McpPage() {
                         <CardHeader>
                           <CardTitle className="text-sm flex items-center justify-between">
                             {name}
-                            <div className="flex gap-1">
+                            <div className="flex gap-1 items-center">
+                              <Switch
+                                checked={isEnabled}
+                                onCheckedChange={(checked) => handleToggleServerEnabled(name, checked)}
+                                aria-label={`Toggle ${name} server`}
+                              />
                               <Button
                                 size="sm"
                                 variant="ghost"
diff --git a/src/types/mcp.ts b/src/types/mcp.ts
@@ -3,16 +3,19 @@ type StdioMcpServerConfig = {
   command: string;
   args: string[];
   env?: Record<string, string>;
+  enabled?: boolean;
 };
 
 type HttpMcpServerConfig = {
   type: "http";
   url: string;
+  enabled?: boolean;
 };
 
 type SseMcpServerConfig = {
   type: "sse";
   url: string;
+  enabled?: boolean;
 };
 
 export type McpServerConfig =
