feat: enhance application structure and server management

- Integrated GlobalDialog and ConsentDialog into App component for improved user interaction.
- Updated Sidebar navigation to redirect users to the manage page instead of the dashboard.
- Removed LocalTable component to streamline the manage page and improve performance.
- Adjusted client configurations to mark "Cherry Studio" and "mcphub" as free clients.
- Refactored SettingsPage to utilize new SettingsSectionContent and SettingsSidebar components for better organization.
- Added isActived property to server configurations for enhanced server state management.

Author: milisp

src-tauri/src/client.rs

@@ -94,7 +94,9 @@ impl ClientConfig {
                     PathBuf::from(&home).join("mcp.json")
                 } else {
                     let given_path = PathBuf::from(path_str);
-                    if given_path.is_file() || given_path.extension().map_or(false, |ext| ext == "json") {
+                    if given_path.is_file()
+                        || given_path.extension().map_or(false, |ext| ext == "json")
+                    {
                         given_path
                     } else {
                         given_path.join("mcp.json")

src-tauri/src/json_manager/file_io.rs

@@ -10,13 +10,11 @@ pub async fn read_json_file(path: &Path) -> Result<Value, String> {
     let content_result = fs::read_to_string(&path_buf).await;
 
     match content_result {
-        Ok(content) => {
-            task::spawn_blocking(move || {
-                serde_json::from_str(&content).map_err(|e| format!("Failed to parse JSON: {}", e))
-            })
-            .await
-            .map_err(|e| format!("Failed to run blocking task for JSON parsing: {}", e))?
-        },
+        Ok(content) => task::spawn_blocking(move || {
+            serde_json::from_str(&content).map_err(|e| format!("Failed to parse JSON: {}", e))
+        })
+        .await
+        .map_err(|e| format!("Failed to run blocking task for JSON parsing: {}", e))?,
         Err(e) => {
             if e.kind() == ErrorKind::NotFound {
                 Ok(json!({})) // Return empty JSON for Not Found
@@ -35,20 +33,24 @@ pub async fn write_json_file(path: &Path, content: &Value) -> Result<(), String>
     // Ensure directory exists
     if let Some(parent) = path_buf.parent() {
         if !parent.exists() {
-            fs::create_dir_all(parent).await.map_err(|e| {
-                format!("Failed to create directory: {}", e)
-            })?;
+            fs::create_dir_all(parent)
+                .await
+                .map_err(|e| format!("Failed to create directory: {}", e))?;
         }
     }
 
     // Serialize JSON in a blocking task
     let json_string_result = task::spawn_blocking(move || {
         serde_json::to_string_pretty(&content_cloned)
             .map_err(|e| format!("Failed to serialize JSON: {}", e))
-    }).await.map_err(|e| format!("Failed to run blocking task for JSON serialization: {}", e))?;
+    })
+    .await
+    .map_err(|e| format!("Failed to run blocking task for JSON serialization: {}", e))?;
 
     let json_string = json_string_result?; // Handle the inner Result from the blocking task
 
     // Write the JSON file asynchronously
-    fs::write(&path_buf, json_string).await.map_err(|e| format!("Failed to write file: {}", e))
+    fs::write(&path_buf, json_string)
+        .await
+        .map_err(|e| format!("Failed to write file: {}", e))
 }

src-tauri/src/json_manager/mod.rs

@@ -8,12 +8,6 @@ pub mod server_state;
 pub mod utils;
 
 // Re-exports for convenience
-pub use file_io::{read_json_file, write_json_file};
-pub use server_crud::{add_mcp_server, remove_mcp_server, update_mcp_server, batch_delete_mcp_servers};
-pub use server_state::{
-    disable_mcp_server, enable_mcp_server, update_disabled_mcp_server, list_disabled_servers
-};
-pub use utils::{normalize_response_key, get_key_by_client, is_per_server_disabled_client};
 
 /// Main JsonManager struct that provides a unified interface for all JSON operations
 pub struct JsonManager;
@@ -58,9 +52,13 @@ impl JsonManager {
     ) -> Result<Value, String> {
         server_crud::batch_delete_mcp_servers(path, client, server_names).await
     }
-    
+
     // Server state management operations
-    pub async fn disable_mcp_server(path: &Path, client: &str, name: &str) -> Result<Value, String> {
+    pub async fn disable_mcp_server(
+        path: &Path,
+        client: &str,
+        name: &str,
+    ) -> Result<Value, String> {
         server_state::disable_mcp_server(path, client, name).await
     }
 
@@ -80,4 +78,4 @@ impl JsonManager {
     pub async fn list_disabled_servers(path: &Path, client: &str) -> Result<Value, String> {
         server_state::list_disabled_servers(path, client).await
     }
-}
+}

src-tauri/src/json_manager/server_crud.rs

@@ -65,23 +65,26 @@ pub async fn update_mcp_server(
     }
 
     // Check if server exists in active servers
-    if json.as_object().unwrap().contains_key(key) 
-        && json[key].is_object() 
-        && json[key].as_object().unwrap().contains_key(name) {
+    if json.as_object().unwrap().contains_key(key)
+        && json[key].is_object()
+        && json[key].as_object().unwrap().contains_key(name)
+    {
         json[key][name] = config;
     }
     // Check if server exists in disabled servers
     else if json.as_object().unwrap().contains_key("__disabled")
         && json["__disabled"].is_object()
-        && json["__disabled"].as_object().unwrap().contains_key(name) {
+        && json["__disabled"].as_object().unwrap().contains_key(name)
+    {
         json["__disabled"][name] = config;
     }
     // If server doesn't exist in either section, add to active servers
     else {
         if !json.as_object().unwrap().contains_key(key) {
             json[key] = json!({});
         }
-        json[key][name] = config;    }
+        json[key][name] = config;
+    }
 
     write_json_file(path, &json).await?;
 
@@ -96,7 +99,7 @@ pub async fn batch_delete_mcp_servers(
     server_names: Vec<String>,
 ) -> Result<Value, String> {
     use super::utils::is_per_server_disabled_client;
-    
+
     let mut json = read_json_file(path).await?;
     let key = get_key_by_client(client);
 

src-tauri/src/json_manager/server_state.rs

@@ -2,7 +2,7 @@ use serde_json::{json, Value};
 use std::path::Path;
 
 use super::file_io::{read_json_file, write_json_file};
-use super::utils::{get_key_by_client, is_per_server_disabled_client, normalize_response_key};
+use super::utils::{get_key_by_client, is_per_server_disabled_client, normalize_response_key, is_cherrystudio_client};
 
 /// Update a disabled MCP server configuration
 pub async fn update_disabled_mcp_server(
@@ -30,6 +30,22 @@ pub async fn update_disabled_mcp_server(
         return normalize_response_key(json, client);
     }
 
+    // cherrystudio: update mcpServers with isActived: false
+    if is_cherrystudio_client(client) {
+        if !json.is_object() {
+            json = json!({});
+        }
+        if !json.as_object().unwrap().contains_key(key) {
+            json[key] = json!({});
+        }
+        // Set config and isActived: false
+        let mut config_with_isactived = config;
+        config_with_isactived["isActived"] = json!(false);
+        json[key][name] = config_with_isactived;
+        write_json_file(path, &json).await?;
+        return normalize_response_key(json, client);
+    }
+
     // Default: update __disabled section
     if !json.is_object() {
         json = json!({});
@@ -71,6 +87,20 @@ pub async fn disable_mcp_server(path: &Path, client: &str, name: &str) -> Result
         return normalize_response_key(json, client);
     }
 
+    // cherrystudio: set isActived: false in mcpServers
+    if is_cherrystudio_client(client) {
+        if !json.as_object().unwrap().contains_key(key)
+            || !json[key].is_object()
+            || !json[key].as_object().unwrap().contains_key(name)
+        {
+            return Err(format!("Server '{}' not found in active servers", name));
+        }
+        // Set isActived: false
+        json[key][name]["isActived"] = json!(false);
+        write_json_file(path, &json).await?;
+        return normalize_response_key(json, client);
+    }
+
     // Default: move to __disabled section    // Check if server exists in active servers
     if !json.as_object().unwrap().contains_key(key)
         || !json[key].is_object()
@@ -125,6 +155,38 @@ pub async fn enable_mcp_server(path: &Path, client: &str, name: &str) -> Result<
         return normalize_response_key(json, client);
     }
 
+    // cherrystudio: set isActived: true in mcpServers, or move from __disabled if not found
+    if is_cherrystudio_client(client) {
+        if json.as_object().unwrap().contains_key(key)
+            && json[key].is_object()
+            && json[key].as_object().unwrap().contains_key(name)
+        {
+            // Set isActived: true
+            json[key][name]["isActived"] = json!(true);
+            write_json_file(path, &json).await?;
+            return normalize_response_key(json, client);
+        }
+        // If not found in mcpServers, try to move from __disabled
+        if json.as_object().unwrap().contains_key("__disabled")
+            && json["__disabled"].is_object()
+            && json["__disabled"].as_object().unwrap().contains_key(name)
+        {
+            let mut server_config = json["__disabled"][name].clone();
+            server_config["isActived"] = json!(true);
+            json["__disabled"].as_object_mut().unwrap().remove(name);
+            if json["__disabled"].as_object().unwrap().is_empty() {
+                json.as_object_mut().unwrap().remove("__disabled");
+            }
+            if !json.as_object().unwrap().contains_key(key) {
+                json[key] = json!({});
+            }
+            json[key][name] = server_config;
+            write_json_file(path, &json).await?;
+            return normalize_response_key(json, client);
+        }
+        return Err(format!("Server '{}' not found in active or disabled servers", name));
+    }
+
     // Default: move from __disabled section to active
     // Check if server exists in disabled section
     if !json.as_object().unwrap().contains_key("__disabled")
@@ -177,7 +239,30 @@ pub async fn list_disabled_servers(path: &Path, client: &str) -> Result<Value, S
         if json.is_object() && json.as_object().unwrap().contains_key(key) {
             if let Some(servers_obj) = json[key].as_object() {
                 for (name, server) in servers_obj {
-                    if server.get("disabled").and_then(|v| v.as_bool()).unwrap_or(false) {
+                    if server
+                        .get("disabled")
+                        .and_then(|v| v.as_bool())
+                        .unwrap_or(false)
+                    {
+                        disabled.insert(name.clone(), server.clone());
+                    }
+                }
+            }
+        }
+        return Ok(Value::Object(disabled));
+    }
+
+    // cherrystudio: return all mcpServers with isActived: false
+    if is_cherrystudio_client(client) {
+        let mut disabled = serde_json::Map::new();
+        if json.is_object() && json.as_object().unwrap().contains_key(key) {
+            if let Some(servers_obj) = json[key].as_object() {
+                for (name, server) in servers_obj {
+                    if server
+                        .get("isActived")
+                        .and_then(|v| v.as_bool())
+                        == Some(false)
+                    {
                         disabled.insert(name.clone(), server.clone());
                     }
                 }

src-tauri/src/json_manager/utils.rs

@@ -1,4 +1,4 @@
-use serde_json::{json, Value};
+use serde_json::Value;
 
 /// Normalize response key to mcpServers for consistent client API
 pub fn normalize_response_key(mut json: Value, client: &str) -> Result<Value, String> {
@@ -32,3 +32,8 @@ pub fn get_key_by_client(client: &str) -> &str {
 pub fn is_per_server_disabled_client(client: &str) -> bool {
     matches!(client, "cline" | "roo_code")
 }
+
+/// Returns true if the client is cherrystudio (uses per-server 'isActived' key)
+pub fn is_cherrystudio_client(client: &str) -> bool {
+    client == "cherrystudio"
+}

src-tauri/src/lib.rs

@@ -17,6 +17,8 @@ mod git;
 mod installer;
 mod json_manager;
 mod mcp_commands;
+mod mcp_crud;
+mod mcp_sync;
 
 #[derive(Debug, Serialize, Deserialize)]
 struct Config {
@@ -82,15 +84,15 @@ pub fn run() {
             cmd::write_json_file,
             cmd::get_app_path,
             cmd::check_mcplinker_config_exists,
-            mcp_commands::add_mcp_server,
-            mcp_commands::remove_mcp_server,
-            mcp_commands::update_mcp_server,
+            mcp_crud::add_mcp_server,
+            mcp_crud::remove_mcp_server,
+            mcp_crud::update_mcp_server,
+            mcp_crud::batch_delete_mcp_servers,
             mcp_commands::disable_mcp_server,
             mcp_commands::enable_mcp_server,
             mcp_commands::list_disabled_servers,
-            mcp_commands::sync_mcp_config,
-            mcp_commands::batch_delete_mcp_servers,
             mcp_commands::update_disabled_mcp_server,
+            mcp_sync::sync_mcp_config,
             installer::check_command_exists,
             installer::install_command,
             get_path_env,