diff --git a/docs/src/pages/docs/_assets/assistant-dropdown-updated.png b/docs/src/pages/docs/_assets/assistant-dropdown-updated.png new file mode 100644 index 000000000..b6ee0b53d Binary files /dev/null and b/docs/src/pages/docs/_assets/assistant-dropdown-updated.png differ diff --git a/docs/src/pages/docs/_assets/jan-app-new.png b/docs/src/pages/docs/_assets/jan-app-new.png new file mode 100644 index 000000000..85db5d552 Binary files /dev/null and b/docs/src/pages/docs/_assets/jan-app-new.png differ diff --git a/docs/src/pages/docs/_assets/threads-context-menu-updated.png b/docs/src/pages/docs/_assets/threads-context-menu-updated.png new file mode 100644 index 000000000..e90baf2ab Binary files /dev/null and b/docs/src/pages/docs/_assets/threads-context-menu-updated.png differ diff --git a/docs/src/pages/docs/_assets/threads-favorites-and-recents-updated.png b/docs/src/pages/docs/_assets/threads-favorites-and-recents-updated.png new file mode 100644 index 000000000..5d62974e4 Binary files /dev/null and b/docs/src/pages/docs/_assets/threads-favorites-and-recents-updated.png differ diff --git a/docs/src/pages/docs/_assets/threads-new-chat-updated.png b/docs/src/pages/docs/_assets/threads-new-chat-updated.png new file mode 100644 index 000000000..6780e7df3 Binary files /dev/null and b/docs/src/pages/docs/_assets/threads-new-chat-updated.png differ diff --git a/docs/src/pages/docs/assistants.mdx b/docs/src/pages/docs/assistants.mdx index 8625252e8..814df0c8f 100644 --- a/docs/src/pages/docs/assistants.mdx +++ b/docs/src/pages/docs/assistants.mdx @@ -77,7 +77,7 @@ Provide examples when explaining complex topics. You can quickly switch between assistants, or create and edit them, directly from the Chat screen using the assistant dropdown menu at the top: -![Assistant Dropdown](./_assets/assistant-dropdown.png) +![Assistant Dropdown](./_assets/assistant-dropdown-updated.png) - Click the assistant's name (e.g., "Travel Planner") at the top of the Chat screen to open the dropdown menu. - The dropdown lists all of your assistants. Click on any of the assistants available to switch to it for the diff --git a/docs/src/pages/docs/index.mdx b/docs/src/pages/docs/index.mdx index 3e3efd458..66a502335 100644 --- a/docs/src/pages/docs/index.mdx +++ b/docs/src/pages/docs/index.mdx @@ -22,7 +22,7 @@ import FAQBox from '@/components/FaqBox' # Jan -![Jan's Cover Image](./_assets/jan-app.png) +![Jan's Cover Image](./_assets/jan-app-new.png) Jan is a ChatGPT alternative that runs 100% offline on your desktop and (*soon*) on mobile. Our goal is to @@ -39,10 +39,10 @@ add it to Jan via the configuration's page and start talking to your favorite mo ### Features -- Download popular open-source LLMs (Llama3, Gemma3, Qwen3, and more) from the HuggingFace [Model Hub](./docs/models/manage-models.mdx) +- Download popular open-source LLMs (Llama3, Gemma3, Qwen3, and more) from the HuggingFace [Model Hub](./docs/manage-models.mdx) or import any GGUF files (the model format used by llama.cpp) available locally - Connect to [cloud services](/docs/remote-models/openai) (OpenAI, Anthropic, Mistral, Groq, etc.) -- [Chat](./docs/threads.mdx) with AI models & [customize their parameters](./docs/models/model-parameters.mdx) via our +- [Chat](./docs/threads.mdx) with AI models & [customize their parameters](/docs/model-parameters.mdx) via our intuitive interface - Use our [local API server](https://jan.ai/api-reference) with an OpenAI-equivalent API to power other apps. @@ -86,7 +86,7 @@ Jan is built on the shoulders of many open-source projects like: Jan supports all major operating systems, - [Mac](/docs/desktop/mac#compatibility) - [Windows](/docs/desktop/windows#compatibility) - - [Linux](docs/desktop/linux). + - [Linux](/docs/desktop/linux) Hardware compatibility includes: - NVIDIA GPUs (CUDA) @@ -111,7 +111,7 @@ Jan is built on the shoulders of many open-source projects like: - - Download optimized models from the [Jan Hub](/docs/models/manage-models#1-download-from-jan-hub-recommended) + - Download optimized models from the [Jan Hub](/docs/manage-models) - Import GGUF models from Hugging Face or your local files - Connect to cloud providers like OpenAI, Anthropic, Mistral and Groq (requires your own API keys) diff --git a/docs/src/pages/docs/quickstart.mdx b/docs/src/pages/docs/quickstart.mdx index c82a6f294..f17863fa2 100644 --- a/docs/src/pages/docs/quickstart.mdx +++ b/docs/src/pages/docs/quickstart.mdx @@ -91,7 +91,7 @@ Install all required dependencies and drivers before enabling GPU acceleration. ### Step 4: Customize Assistant Instructions With your model ready to roll, you can tailor how it responds by tweaking instructions or model configurations -in [Assistant.](/docs/assistants). +through the [Assistants feature](/docs/assistants).
@@ -104,7 +104,7 @@ these is that you can use them no matter which model you choose.
-![Add an Assistant Instruction](./_assets/add_assistant.png) +![Add an Assistant Instruction](./_assets/assistant-edit-dialog.png)
diff --git a/docs/src/pages/docs/threads.mdx b/docs/src/pages/docs/threads.mdx index d92151f76..12a21abd0 100644 --- a/docs/src/pages/docs/threads.mdx +++ b/docs/src/pages/docs/threads.mdx @@ -33,7 +33,7 @@ bottom left of Jan. 2. Select your preferred model in **Model Selector** in input field & start chatting.
-![Create New Thread](./_assets/threads-new-chat.png) +![Create New Thread](./_assets/threads-new-chat-updated.png) ## View Your Chat History @@ -51,7 +51,7 @@ thread and a context menu will pop up with the favorite option for you to click - **Recents**: See your most recently accessed threads for quick navigation.
-![Favorites and Recents](./_assets/threads-favorites-and-recents.png) +![Favorites and Recents](./_assets/threads-favorites-and-recents-updated.png) ## Edit a Chat Title @@ -61,7 +61,7 @@ thread and a context menu will pop up with the favorite option for you to click 4. Add new title & save
-![Context Menu](./_assets/threads-context-menu.png) +![Context Menu](./_assets/threads-context-menu-updated.png) ## Delete Thread @@ -77,7 +77,7 @@ When you want to completely remove a thread:
-![Delete Thread](./_assets/threads-context-menu.png) +![Delete Thread](./_assets/threads-context-menu-updated.png) ### Delete all threads at once diff --git a/extensions/download-extension/package.json b/extensions/download-extension/package.json index 58fe42289..1c3f2f174 100644 --- a/extensions/download-extension/package.json +++ b/extensions/download-extension/package.json @@ -16,7 +16,7 @@ "rimraf": "^3.0.2", "rolldown": "1.0.0-beta.1", "run-script-os": "^1.1.6", - "typescript": "5.3.3", + "typescript": "5.8.3", "vitest": "^3.0.6" }, "files": [ diff --git a/src-tauri/src/core/mcp.rs b/src-tauri/src/core/mcp.rs index f9509c8e5..e340a9aaa 100644 --- a/src-tauri/src/core/mcp.rs +++ b/src-tauri/src/core/mcp.rs @@ -3,8 +3,12 @@ use rmcp::{service::RunningService, transport::TokioChildProcess, RoleClient, Se use serde_json::{Map, Value}; use std::fs; use std::{collections::HashMap, env, sync::Arc, time::Duration}; -use tauri::{AppHandle, Emitter, Runtime, State}; -use tokio::{process::Command, sync::Mutex, time::timeout}; +use tauri::{AppHandle, Emitter, Manager, Runtime, State}; +use tokio::{ + process::Command, + sync::Mutex, + time::{sleep, timeout}, +}; use super::{cmd::get_jan_data_folder_path, state::AppState}; @@ -51,6 +55,58 @@ const DEFAULT_MCP_CONFIG: &str = r#"{ // Timeout for MCP tool calls (30 seconds) const MCP_TOOL_CALL_TIMEOUT: Duration = Duration::from_secs(30); +// MCP server restart configuration with exponential backoff +const MCP_BASE_RESTART_DELAY_MS: u64 = 1000; // Start with 1 second +const MCP_MAX_RESTART_DELAY_MS: u64 = 30000; // Cap at 30 seconds +const MCP_BACKOFF_MULTIPLIER: f64 = 2.0; // Double the delay each time + +/// Calculate exponential backoff delay with jitter +/// +/// # Arguments +/// * `attempt` - The current restart attempt number (1-based) +/// +/// # Returns +/// * `u64` - Delay in milliseconds, capped at MCP_MAX_RESTART_DELAY_MS +fn calculate_exponential_backoff_delay(attempt: u32) -> u64 { + use std::cmp; + + // Calculate base exponential delay: base_delay * multiplier^(attempt-1) + let exponential_delay = (MCP_BASE_RESTART_DELAY_MS as f64) + * MCP_BACKOFF_MULTIPLIER.powi((attempt - 1) as i32); + + // Cap the delay at maximum + let capped_delay = cmp::min(exponential_delay as u64, MCP_MAX_RESTART_DELAY_MS); + + // Add jitter (±25% randomness) to prevent thundering herd + let jitter_range = (capped_delay as f64 * 0.25) as u64; + let jitter = if jitter_range > 0 { + use std::collections::hash_map::DefaultHasher; + use std::hash::{Hash, Hasher}; + + // Use attempt number as seed for deterministic but varied jitter + let mut hasher = DefaultHasher::new(); + attempt.hash(&mut hasher); + let hash = hasher.finish(); + + // Convert hash to jitter value in range [-jitter_range, +jitter_range] + let jitter_offset = (hash % (jitter_range * 2)) as i64 - jitter_range as i64; + jitter_offset + } else { + 0 + }; + + // Apply jitter while ensuring delay stays positive and within bounds + let final_delay = cmp::max( + 100, // Minimum 100ms delay + cmp::min( + MCP_MAX_RESTART_DELAY_MS, + (capped_delay as i64 + jitter) as u64 + ) + ); + + final_delay +} + /// Runs MCP commands by reading configuration from a JSON file and initializing servers /// /// # Arguments @@ -70,46 +126,361 @@ pub async fn run_mcp_commands( "Load MCP configs from {}", app_path_str.clone() + "/mcp_config.json" ); - let config_content = std::fs::read_to_string(app_path_str.clone() + "/mcp_config.json") - .map_err(|e| format!("Failed to read config file: {}", e))?; + let config_content = std::fs::read_to_string(app_path_str + "/mcp_config.json") + .map_err(|e| format!("Failed to read config file: {e}"))?; let mcp_servers: serde_json::Value = serde_json::from_str(&config_content) - .map_err(|e| format!("Failed to parse config: {}", e))?; + .map_err(|e| format!("Failed to parse config: {e}"))?; - if let Some(server_map) = mcp_servers.get("mcpServers").and_then(Value::as_object) { - log::trace!("MCP Servers: {server_map:#?}"); + let server_map = mcp_servers + .get("mcpServers") + .and_then(Value::as_object) + .ok_or("No mcpServers found in config")?; - for (name, config) in server_map { - if let Some(false) = extract_active_status(config) { - log::trace!("Server {name} is not active, skipping."); - continue; + log::trace!("MCP Servers: {server_map:#?}"); + + // Collect handles for initial server startup + let mut startup_handles = Vec::new(); + + for (name, config) in server_map { + if extract_active_status(config) == Some(false) { + log::trace!("Server {name} is not active, skipping."); + continue; + } + + let app_clone = app.clone(); + let servers_clone = servers_state.clone(); + let name_clone = name.clone(); + let config_clone = config.clone(); + + // Spawn task for initial startup attempt + let handle = tokio::spawn(async move { + // Only wait for the initial startup attempt, not the monitoring + let result = start_mcp_server_with_restart( + app_clone.clone(), + servers_clone.clone(), + name_clone.clone(), + config_clone.clone(), + Some(3), // Default max restarts for startup + ).await; + + // If initial startup failed, we still want to continue with other servers + if let Err(e) = &result { + log::error!("Initial startup failed for MCP server {}: {}", name_clone, e); } - match start_mcp_server( - app.clone(), - servers_state.clone(), - name.clone(), - config.clone(), - ) - .await - { - Ok(_) => { - log::info!("Server {name} activated successfully."); - } - Err(e) => { - let _ = app.emit( - "mcp-error", - format!("Failed to activate MCP server {name}: {e}"), - ); - log::error!("Failed to activate server {name}: {e}"); - continue; // Skip to the next server + + (name_clone, result) + }); + + startup_handles.push(handle); + } + + // Wait for all initial startup attempts to complete + let mut successful_count = 0; + let mut failed_count = 0; + + for handle in startup_handles { + match handle.await { + Ok((name, result)) => { + match result { + Ok(_) => { + log::info!("MCP server {} initialized successfully", name); + successful_count += 1; + } + Err(e) => { + log::error!("MCP server {} failed to initialize: {}", name, e); + failed_count += 1; + } } } + Err(e) => { + log::error!("Failed to join startup task: {}", e); + failed_count += 1; + } } } + + log::info!( + "MCP server initialization complete: {} successful, {} failed", + successful_count, + failed_count + ); Ok(()) } +/// Monitor MCP server health without removing it from the HashMap +async fn monitor_mcp_server_handle( + servers_state: Arc>>>, + name: String, +) -> Option { + log::info!("Monitoring MCP server {} health", name); + + // Monitor server health with periodic checks + loop { + // Small delay between health checks + sleep(Duration::from_secs(5)).await; + + // Check if server is still healthy by trying to list tools + let health_check_result = { + let servers = servers_state.lock().await; + if let Some(service) = servers.get(&name) { + // Try to list tools as a health check with a short timeout + match timeout(Duration::from_secs(2), service.list_all_tools()).await { + Ok(Ok(_)) => { + // Server responded successfully + true + } + Ok(Err(e)) => { + log::warn!("MCP server {} health check failed: {}", name, e); + false + } + Err(_) => { + log::warn!("MCP server {} health check timed out", name); + false + } + } + } else { + // Server was removed from HashMap (e.g., by deactivate_mcp_server) + log::info!("MCP server {} no longer in running services", name); + return Some(rmcp::service::QuitReason::Closed); + } + }; + + if !health_check_result { + // Server failed health check - remove it and return + log::error!("MCP server {} failed health check, removing from active servers", name); + let mut servers = servers_state.lock().await; + if let Some(service) = servers.remove(&name) { + // Try to cancel the service gracefully + let _ = service.cancel().await; + } + return Some(rmcp::service::QuitReason::Closed); + } + } +} + +/// Starts an MCP server with restart monitoring (similar to cortex restart) +/// Returns the result of the first start attempt, then continues with restart monitoring +async fn start_mcp_server_with_restart( + app: AppHandle, + servers_state: Arc>>>, + name: String, + config: Value, + max_restarts: Option, +) -> Result<(), String> { + let app_state = app.state::(); + let restart_counts = app_state.mcp_restart_counts.clone(); + let active_servers_state = app_state.mcp_active_servers.clone(); + let successfully_connected = app_state.mcp_successfully_connected.clone(); + + // Store active server config for restart purposes + store_active_server_config(&active_servers_state, &name, &config).await; + + let max_restarts = max_restarts.unwrap_or(5); + + // Try the first start attempt and return its result + log::info!("Starting MCP server {} (Initial attempt)", name); + let first_start_result = schedule_mcp_start_task( + app.clone(), + servers_state.clone(), + name.clone(), + config.clone(), + ).await; + + match first_start_result { + Ok(_) => { + log::info!("MCP server {} started successfully on first attempt", name); + reset_restart_count(&restart_counts, &name).await; + + // Check if server was marked as successfully connected (passed verification) + let was_verified = { + let connected = successfully_connected.lock().await; + connected.get(&name).copied().unwrap_or(false) + }; + + if was_verified { + // Only spawn monitoring task if server passed verification + spawn_server_monitoring_task( + app, + servers_state, + name, + config, + max_restarts, + restart_counts, + successfully_connected, + ).await; + + Ok(()) + } else { + // Server failed verification, don't monitor for restarts + log::error!("MCP server {} failed verification after startup", name); + Err(format!("MCP server {} failed verification after startup", name)) + } + } + Err(e) => { + log::error!("Failed to start MCP server {} on first attempt: {}", name, e); + Err(e) + } + } +} + +/// Helper function to handle the restart loop logic +async fn start_restart_loop( + app: AppHandle, + servers_state: Arc>>>, + name: String, + config: Value, + max_restarts: u32, + restart_counts: Arc>>, + successfully_connected: Arc>>, +) { + loop { + let current_restart_count = { + let mut counts = restart_counts.lock().await; + let count = counts.entry(name.clone()).or_insert(0); + *count += 1; + *count + }; + + if current_restart_count > max_restarts { + log::error!( + "MCP server {} reached maximum restart attempts ({}). Giving up.", + name, + max_restarts + ); + if let Err(e) = app.emit("mcp_max_restarts_reached", + serde_json::json!({ + "server": name, + "max_restarts": max_restarts + }) + ) { + log::error!("Failed to emit mcp_max_restarts_reached event: {e}"); + } + break; + } + + log::info!( + "Restarting MCP server {} (Attempt {}/{})", + name, + current_restart_count, + max_restarts + ); + + // Calculate exponential backoff delay + let delay_ms = calculate_exponential_backoff_delay(current_restart_count); + log::info!( + "Waiting {}ms before restart attempt {} for MCP server {}", + delay_ms, + current_restart_count, + name + ); + sleep(Duration::from_millis(delay_ms)).await; + + // Attempt to restart the server + let start_result = schedule_mcp_start_task( + app.clone(), + servers_state.clone(), + name.clone(), + config.clone(), + ).await; + + match start_result { + Ok(_) => { + log::info!("MCP server {} restarted successfully.", name); + + // Check if server passed verification (was marked as successfully connected) + let passed_verification = { + let connected = successfully_connected.lock().await; + connected.get(&name).copied().unwrap_or(false) + }; + + if !passed_verification { + log::error!( + "MCP server {} failed verification after restart - stopping permanently", + name + ); + break; + } + + // Reset restart count on successful restart with verification + { + let mut counts = restart_counts.lock().await; + if let Some(count) = counts.get_mut(&name) { + if *count > 0 { + log::info!( + "MCP server {} restarted successfully, resetting restart count from {} to 0.", + name, + *count + ); + *count = 0; + } + } + } + + // Monitor the server again + let quit_reason = monitor_mcp_server_handle( + servers_state.clone(), + name.clone(), + ).await; + + log::info!("MCP server {} quit with reason: {:?}", name, quit_reason); + + // Check if server was marked as successfully connected + let was_connected = { + let connected = successfully_connected.lock().await; + connected.get(&name).copied().unwrap_or(false) + }; + + // Only continue restart loop if server was previously connected + if !was_connected { + log::error!( + "MCP server {} failed before establishing successful connection - stopping permanently", + name + ); + break; + } + + // Determine if we should restart based on quit reason + let should_restart = match quit_reason { + Some(reason) => { + log::warn!("MCP server {} terminated unexpectedly: {:?}", name, reason); + true + } + None => { + log::info!("MCP server {} was manually stopped - not restarting", name); + false + } + }; + + if !should_restart { + break; + } + // Continue the loop for another restart attempt + } + Err(e) => { + log::error!("Failed to restart MCP server {}: {}", name, e); + + // Check if server was marked as successfully connected before + let was_connected = { + let connected = successfully_connected.lock().await; + connected.get(&name).copied().unwrap_or(false) + }; + + // Only continue restart attempts if server was previously connected + if !was_connected { + log::error!( + "MCP server {} failed restart and was never successfully connected - stopping permanently", + name + ); + break; + } + // Continue the loop for another restart attempt + } + } + } +} + #[tauri::command] pub async fn activate_mcp_server( app: tauri::AppHandle, @@ -119,10 +490,12 @@ pub async fn activate_mcp_server( ) -> Result<(), String> { let servers: Arc>>> = state.mcp_servers.clone(); - start_mcp_server(app, servers, name, config).await + + // Use the modified start_mcp_server_with_restart that returns first attempt result + start_mcp_server_with_restart(app, servers, name, config, Some(3)).await } -async fn start_mcp_server( +async fn schedule_mcp_start_task( app: tauri::AppHandle, servers: Arc>>>, name: String, @@ -134,113 +507,159 @@ async fn start_mcp_server( .parent() .expect("Executable must have a parent directory"); let bin_path = exe_parent_path.to_path_buf(); - if let Some((command, args, envs)) = extract_command_args(&config) { - let mut cmd = Command::new(command.clone()); - if command.clone() == "npx" { - let mut cache_dir = app_path.clone(); - cache_dir.push(".npx"); - let bun_x_path = format!("{}/bun", bin_path.display()); - cmd = Command::new(bun_x_path); - cmd.arg("x"); - cmd.env("BUN_INSTALL", cache_dir.to_str().unwrap().to_string()); - } + + let (command, args, envs) = extract_command_args(&config) + .ok_or_else(|| format!("Failed to extract command args from config for {name}"))?; - if command.clone() == "uvx" { - let mut cache_dir = app_path.clone(); - cache_dir.push(".uvx"); - let bun_x_path = format!("{}/uv", bin_path.display()); - cmd = Command::new(bun_x_path); - cmd.arg("tool"); - cmd.arg("run"); - cmd.env("UV_CACHE_DIR", cache_dir.to_str().unwrap().to_string()); - } - #[cfg(windows)] - { - cmd.creation_flags(0x08000000); // CREATE_NO_WINDOW: prevents shell window on Windows - } - let app_path_str = app_path.to_str().unwrap().to_string(); - let log_file_path = format!("{}/logs/app.log", app_path_str); - match std::fs::OpenOptions::new() - .create(true) - .append(true) - .open(log_file_path) - { - Ok(file) => { - cmd.stderr(std::process::Stdio::from(file)); - } - Err(err) => { - log::error!("Failed to open log file: {}", err); - } - }; - - cmd.kill_on_drop(true); - - log::trace!("Command: {cmd:#?}"); - - args.iter().filter_map(Value::as_str).for_each(|arg| { - cmd.arg(arg); - }); - envs.iter().for_each(|(k, v)| { - if let Some(v_str) = v.as_str() { - cmd.env(k, v_str); - } - }); - - let process = TokioChildProcess::new(cmd); - match process { - Ok(p) => { - let service = ().serve(p).await; - - match service { - Ok(running_service) => { - // Get peer info and clone the needed values before moving the service - let (server_name, server_version) = { - let server_info = running_service.peer_info(); - log::trace!("Connected to server: {server_info:#?}"); - ( - server_info.server_info.name.clone(), - server_info.server_info.version.clone(), - ) - }; - - // Now move the service into the HashMap - servers.lock().await.insert(name.clone(), running_service); - log::info!("Server {name} started successfully."); - - // Emit event to the frontend - let event = format!("mcp-connected"); - let payload = serde_json::json!({ - "name": server_name, - "version": server_version, - }); - app.emit(&event, payload) - .map_err(|e| format!("Failed to emit event: {}", e))?; - } - Err(e) => { - return Err(format!("Failed to start MCP server {name}: {e}")); - } - } - } - Err(e) => { - log::error!("Failed to run command {name}: {e}"); - return Err(format!("Failed to run command {name}: {e}")); - } - } + let mut cmd = Command::new(command.clone()); + + if command == "npx" { + let mut cache_dir = app_path.clone(); + cache_dir.push(".npx"); + let bun_x_path = format!("{}/bun", bin_path.display()); + cmd = Command::new(bun_x_path); + cmd.arg("x"); + cmd.env("BUN_INSTALL", cache_dir.to_str().unwrap().to_string()); } + + if command == "uvx" { + let mut cache_dir = app_path.clone(); + cache_dir.push(".uvx"); + let bun_x_path = format!("{}/uv", bin_path.display()); + cmd = Command::new(bun_x_path); + cmd.arg("tool"); + cmd.arg("run"); + cmd.env("UV_CACHE_DIR", cache_dir.to_str().unwrap().to_string()); + } + + #[cfg(windows)] + { + cmd.creation_flags(0x08000000); // CREATE_NO_WINDOW: prevents shell window on Windows + } + + let app_path_str = app_path.to_str().unwrap().to_string(); + let log_file_path = format!("{}/logs/app.log", app_path_str); + match std::fs::OpenOptions::new() + .create(true) + .append(true) + .open(log_file_path) + { + Ok(file) => { + cmd.stderr(std::process::Stdio::from(file)); + } + Err(err) => { + log::error!("Failed to open log file: {}", err); + } + }; + + cmd.kill_on_drop(true); + log::trace!("Command: {cmd:#?}"); + + args.iter().filter_map(Value::as_str).for_each(|arg| { + cmd.arg(arg); + }); + envs.iter().for_each(|(k, v)| { + if let Some(v_str) = v.as_str() { + cmd.env(k, v_str); + } + }); + + let process = TokioChildProcess::new(cmd) + .map_err(|e| { + log::error!("Failed to run command {name}: {e}"); + format!("Failed to run command {name}: {e}") + })?; + + let service = ().serve(process).await + .map_err(|e| format!("Failed to start MCP server {name}: {e}"))?; + + // Get peer info and clone the needed values before moving the service + let (server_name, server_version) = { + let server_info = service.peer_info(); + log::trace!("Connected to server: {server_info:#?}"); + ( + server_info.server_info.name.clone(), + server_info.server_info.version.clone(), + ) + }; + + // Now move the service into the HashMap + servers.lock().await.insert(name.clone(), service); + log::info!("Server {name} started successfully."); + + // Wait a short time to verify the server is stable before marking as connected + // This prevents race conditions where the server quits immediately + let verification_delay = Duration::from_millis(500); + sleep(verification_delay).await; + + // Check if server is still running after the verification delay + let server_still_running = { + let servers_map = servers.lock().await; + servers_map.contains_key(&name) + }; + + if !server_still_running { + return Err(format!("MCP server {} quit immediately after starting", name)); + } + + // Mark server as successfully connected (for restart policy) + { + let app_state = app.state::(); + let mut connected = app_state.mcp_successfully_connected.lock().await; + connected.insert(name.clone(), true); + log::info!("Marked MCP server {} as successfully connected", name); + } + + // Emit event to the frontend + let event = format!("mcp-connected"); + let payload = serde_json::json!({ + "name": server_name, + "version": server_version, + }); + app.emit(&event, payload) + .map_err(|e| format!("Failed to emit event: {}", e))?; + Ok(()) } #[tauri::command] pub async fn deactivate_mcp_server(state: State<'_, AppState>, name: String) -> Result<(), String> { + log::info!("Deactivating MCP server: {}", name); + + // First, mark server as manually deactivated to prevent restart + // Remove from active servers list to prevent restart + { + let mut active_servers = state.mcp_active_servers.lock().await; + active_servers.remove(&name); + log::info!("Removed MCP server {} from active servers list", name); + } + + // Mark as not successfully connected to prevent restart logic + { + let mut connected = state.mcp_successfully_connected.lock().await; + connected.insert(name.clone(), false); + log::info!("Marked MCP server {} as not successfully connected", name); + } + + // Reset restart count + { + let mut counts = state.mcp_restart_counts.lock().await; + counts.remove(&name); + log::info!("Reset restart count for MCP server {}", name); + } + + // Now remove and stop the server let servers = state.mcp_servers.clone(); let mut servers_map = servers.lock().await; - if let Some(service) = servers_map.remove(&name) { - service.cancel().await.map_err(|e| e.to_string())?; - log::info!("Server {name} stopped successfully."); - } else { - return Err(format!("Server {} not found", name)); - } + let service = servers_map.remove(&name) + .ok_or_else(|| format!("Server {} not found", name))?; + + // Release the lock before calling cancel + drop(servers_map); + + service.cancel().await.map_err(|e| e.to_string())?; + log::info!("Server {name} stopped successfully and marked as deactivated."); Ok(()) } @@ -270,11 +689,83 @@ pub async fn restart_mcp_servers(app: AppHandle, state: State<'_, AppState>) -> // Stop the servers stop_mcp_servers(state.mcp_servers.clone()).await?; - // Restart the servers - run_mcp_commands(&app, servers).await?; + // Restart only previously active servers (like cortex) + restart_active_mcp_servers(&app, servers).await?; app.emit("mcp-update", "MCP servers updated") - .map_err(|e| format!("Failed to emit event: {}", e)) + .map_err(|e| format!("Failed to emit event: {}", e))?; + + Ok(()) +} + +/// Restart only servers that were previously active (like cortex restart behavior) +pub async fn restart_active_mcp_servers( + app: &AppHandle, + servers_state: Arc>>>, +) -> Result<(), String> { + let app_state = app.state::(); + let active_servers = app_state.mcp_active_servers.lock().await; + + log::info!("Restarting {} previously active MCP servers", active_servers.len()); + + for (name, config) in active_servers.iter() { + log::info!("Restarting MCP server: {}", name); + + // Start server with restart monitoring - spawn async task + let app_clone = app.clone(); + let servers_clone = servers_state.clone(); + let name_clone = name.clone(); + let config_clone = config.clone(); + + tauri::async_runtime::spawn(async move { + let _ = start_mcp_server_with_restart( + app_clone, + servers_clone, + name_clone, + config_clone, + Some(3), // Default max restarts for startup + ).await; + }); + } + + Ok(()) +} + +/// Handle app quit - stop all MCP servers cleanly (like cortex cleanup) +pub async fn handle_app_quit(state: &AppState) -> Result<(), String> { + log::info!("App quitting - stopping all MCP servers cleanly"); + + // Stop all running MCP servers + stop_mcp_servers(state.mcp_servers.clone()).await?; + + // Clear active servers and restart counts + { + let mut active_servers = state.mcp_active_servers.lock().await; + active_servers.clear(); + } + { + let mut restart_counts = state.mcp_restart_counts.lock().await; + restart_counts.clear(); + } + + log::info!("All MCP servers stopped cleanly"); + Ok(()) +} + +/// Reset MCP restart count for a specific server (like cortex reset) +#[tauri::command] +pub async fn reset_mcp_restart_count(state: State<'_, AppState>, server_name: String) -> Result<(), String> { + let mut counts = state.mcp_restart_counts.lock().await; + + let count = match counts.get_mut(&server_name) { + Some(count) => count, + None => return Ok(()), // Server not found, nothing to reset + }; + + let old_count = *count; + *count = 0; + log::info!("MCP server {} restart count reset from {} to 0.", server_name, old_count); + Ok(()) } pub async fn stop_mcp_servers( @@ -290,6 +781,7 @@ pub async fn stop_mcp_servers( drop(servers_map); // Release the lock after stopping Ok(()) } + #[tauri::command] pub async fn get_connected_servers( _app: AppHandle, @@ -366,31 +858,31 @@ pub async fn call_tool( // Iterate through servers and find the first one that contains the tool for (_, service) in servers.iter() { - if let Ok(tools) = service.list_all_tools().await { - if tools.iter().any(|t| t.name == tool_name) { - println!("Found tool {} in server", tool_name); + let tools = match service.list_all_tools().await { + Ok(tools) => tools, + Err(_) => continue, // Skip this server if we can't list tools + }; - // Call the tool with timeout - let tool_call = service.call_tool(CallToolRequestParam { - name: tool_name.clone().into(), - arguments, - }); - - return match timeout(MCP_TOOL_CALL_TIMEOUT, tool_call).await { - Ok(result) => { - match result { - Ok(ok_result) => Ok(ok_result), - Err(e) => Err(e.to_string()), - } - } - Err(_) => Err(format!( - "Tool call '{}' timed out after {} seconds", - tool_name, - MCP_TOOL_CALL_TIMEOUT.as_secs() - )), - }; - } + if !tools.iter().any(|t| t.name == tool_name) { + continue; // Tool not found in this server, try next } + + println!("Found tool {} in server", tool_name); + + // Call the tool with timeout + let tool_call = service.call_tool(CallToolRequestParam { + name: tool_name.clone().into(), + arguments, + }); + + return match timeout(MCP_TOOL_CALL_TIMEOUT, tool_call).await { + Ok(result) => result.map_err(|e| e.to_string()), + Err(_) => Err(format!( + "Tool call '{}' timed out after {} seconds", + tool_name, + MCP_TOOL_CALL_TIMEOUT.as_secs() + )), + }; } Err(format!("Tool {} not found", tool_name)) @@ -409,8 +901,7 @@ pub async fn get_mcp_configs(app: AppHandle) -> Result { .map_err(|e| format!("Failed to create default MCP config: {}", e))?; } - let contents = fs::read_to_string(path).map_err(|e| e.to_string())?; - return Ok(contents); + fs::read_to_string(path).map_err(|e| e.to_string()) } #[tauri::command] @@ -422,6 +913,100 @@ pub async fn save_mcp_configs(app: AppHandle, configs: String) -> Result<(), Str fs::write(path, configs).map_err(|e| e.to_string()) } +/// Store active server configuration for restart purposes +async fn store_active_server_config( + active_servers_state: &Arc>>, + name: &str, + config: &Value, +) { + let mut active_servers = active_servers_state.lock().await; + active_servers.insert(name.to_string(), config.clone()); +} + + +/// Reset restart count for a server +async fn reset_restart_count( + restart_counts: &Arc>>, + name: &str, +) { + let mut counts = restart_counts.lock().await; + counts.insert(name.to_string(), 0); +} + +/// Spawn the server monitoring task for handling restarts +async fn spawn_server_monitoring_task( + app: AppHandle, + servers_state: Arc>>>, + name: String, + config: Value, + max_restarts: u32, + restart_counts: Arc>>, + successfully_connected: Arc>>, +) { + let app_clone = app.clone(); + let servers_clone = servers_state.clone(); + let name_clone = name.clone(); + let config_clone = config.clone(); + + tauri::async_runtime::spawn(async move { + // Monitor the server using RunningService's JoinHandle + let quit_reason = monitor_mcp_server_handle( + servers_clone.clone(), + name_clone.clone(), + ).await; + + log::info!("MCP server {} quit with reason: {:?}", name_clone, quit_reason); + + // Check if we should restart based on connection status and quit reason + if should_restart_server(&successfully_connected, &name_clone, &quit_reason).await { + // Start the restart loop + start_restart_loop( + app_clone, + servers_clone, + name_clone, + config_clone, + max_restarts, + restart_counts, + successfully_connected, + ).await; + } + }); +} + +/// Determine if a server should be restarted based on its connection status and quit reason +async fn should_restart_server( + successfully_connected: &Arc>>, + name: &str, + quit_reason: &Option, +) -> bool { + // Check if server was marked as successfully connected + let was_connected = { + let connected = successfully_connected.lock().await; + connected.get(name).copied().unwrap_or(false) + }; + + // Only restart if server was previously connected + if !was_connected { + log::error!( + "MCP server {} failed before establishing successful connection - stopping permanently", + name + ); + return false; + } + + // Determine if we should restart based on quit reason + match quit_reason { + Some(reason) => { + log::warn!("MCP server {} terminated unexpectedly: {:?}", name, reason); + true + } + None => { + log::info!("MCP server {} was manually stopped - not restarting", name); + false + } + } +} + #[cfg(test)] mod tests { use super::*; diff --git a/src-tauri/src/core/setup.rs b/src-tauri/src/core/setup.rs index c2d3499f3..8d8a3d557 100644 --- a/src-tauri/src/core/setup.rs +++ b/src-tauri/src/core/setup.rs @@ -197,9 +197,39 @@ fn extract_extension_manifest( } pub fn setup_mcp(app: &App) { - let state = app.state::().inner(); + let state = app.state::(); let servers = state.mcp_servers.clone(); let app_handle: tauri::AppHandle = app.handle().clone(); + + // Setup kill-mcp-servers event listener (similar to cortex kill-sidecar) + let app_handle_for_kill = app_handle.clone(); + app_handle.listen("kill-mcp-servers", move |_event| { + let app_handle = app_handle_for_kill.clone(); + tauri::async_runtime::spawn(async move { + log::info!("Received kill-mcp-servers event - cleaning up MCP servers"); + + let app_state = app_handle.state::(); + + // Stop all running MCP servers + if let Err(e) = super::mcp::stop_mcp_servers(app_state.mcp_servers.clone()).await { + log::error!("Failed to stop MCP servers: {}", e); + return; + } + + // Clear active servers and restart counts + { + let mut active_servers = app_state.mcp_active_servers.lock().await; + active_servers.clear(); + } + { + let mut restart_counts = app_state.mcp_restart_counts.lock().await; + restart_counts.clear(); + } + + log::info!("MCP servers cleaned up successfully"); + }); + }); + tauri::async_runtime::spawn(async move { if let Err(e) = run_mcp_commands(&app_handle, servers).await { log::error!("Failed to run mcp commands: {}", e); diff --git a/src-tauri/src/core/state.rs b/src-tauri/src/core/state.rs index 9957ba92e..dab29aa85 100644 --- a/src-tauri/src/core/state.rs +++ b/src-tauri/src/core/state.rs @@ -16,6 +16,9 @@ pub struct AppState { pub download_manager: Arc>, pub cortex_restart_count: Arc>, pub cortex_killed_intentionally: Arc>, + pub mcp_restart_counts: Arc>>, + pub mcp_active_servers: Arc>>, + pub mcp_successfully_connected: Arc>>, pub server_handle: Arc>>, } pub fn generate_app_token() -> String { diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs index 4ed6ecee7..0ef6f059a 100644 --- a/src-tauri/src/lib.rs +++ b/src-tauri/src/lib.rs @@ -68,6 +68,7 @@ pub fn run() { core::mcp::get_mcp_configs, core::mcp::activate_mcp_server, core::mcp::deactivate_mcp_server, + core::mcp::reset_mcp_restart_count, // Threads core::threads::list_threads, core::threads::create_thread, @@ -93,6 +94,9 @@ pub fn run() { download_manager: Arc::new(Mutex::new(DownloadManagerState::default())), cortex_restart_count: Arc::new(Mutex::new(0)), cortex_killed_intentionally: Arc::new(Mutex::new(false)), + mcp_restart_counts: Arc::new(Mutex::new(HashMap::new())), + mcp_active_servers: Arc::new(Mutex::new(HashMap::new())), + mcp_successfully_connected: Arc::new(Mutex::new(HashMap::new())), server_handle: Arc::new(Mutex::new(None)), }) .setup(|app| { @@ -124,6 +128,7 @@ pub fn run() { tauri::WindowEvent::CloseRequested { .. } => { if window.label() == "main" { window.emit("kill-sidecar", ()).unwrap(); + window.emit("kill-mcp-servers", ()).unwrap(); clean_up(); } } diff --git a/web-app/package.json b/web-app/package.json index 8163bb3cd..f156bf943 100644 --- a/web-app/package.json +++ b/web-app/package.json @@ -28,7 +28,7 @@ "@tabler/icons-react": "^3.33.0", "@tailwindcss/vite": "^4.1.4", "@tanstack/react-router": "^1.116.0", - "@tanstack/react-router-devtools": "^1.116.0", + "@tanstack/react-router-devtools": "^1.121.34", "@tauri-apps/api": "^2.5.0", "@tauri-apps/plugin-deep-link": "~2", "@tauri-apps/plugin-dialog": "^2.2.1", diff --git a/web-app/src/containers/ThreadList.tsx b/web-app/src/containers/ThreadList.tsx index df9689f16..e4ed8aa93 100644 --- a/web-app/src/containers/ThreadList.tsx +++ b/web-app/src/containers/ThreadList.tsx @@ -101,9 +101,7 @@ const SortableItem = memo(({ thread }: { thread: Thread }) => { )} >
- + {thread.title || t('common:newThread')}
- {hardwareData.gpus.length > 0 ? ( - - gpu.id)} - strategy={verticalListSortingStrategy} + {!IS_MACOS ? ( + + {hardwareData.gpus.length > 0 ? ( + - {hardwareData.gpus.map((gpu, index) => ( - - ))} - - - ) : ( - } - /> - )} - + gpu.id)} + strategy={verticalListSortingStrategy} + > + {hardwareData.gpus.map((gpu, index) => ( + + ))} + + + ) : ( + } + /> + )} + + ) : ( + <> + )}
diff --git a/yarn.lock b/yarn.lock index 55e915e56..336d43a3c 100644 --- a/yarn.lock +++ b/yarn.lock @@ -2274,7 +2274,7 @@ __metadata: "@tabler/icons-react": "npm:^3.33.0" "@tailwindcss/vite": "npm:^4.1.4" "@tanstack/react-router": "npm:^1.116.0" - "@tanstack/react-router-devtools": "npm:^1.116.0" + "@tanstack/react-router-devtools": "npm:^1.121.34" "@tanstack/router-plugin": "npm:^1.116.1" "@tauri-apps/api": "npm:^2.5.0" "@tauri-apps/plugin-deep-link": "npm:~2" @@ -5751,17 +5751,16 @@ __metadata: languageName: node linkType: hard -"@tanstack/react-router-devtools@npm:^1.116.0": - version: 1.117.0 - resolution: "@tanstack/react-router-devtools@npm:1.117.0" +"@tanstack/react-router-devtools@npm:^1.121.34": + version: 1.121.34 + resolution: "@tanstack/react-router-devtools@npm:1.121.34" dependencies: - "@tanstack/router-devtools-core": "npm:^1.117.0" - solid-js: "npm:^1.9.5" + "@tanstack/router-devtools-core": "npm:^1.121.34" peerDependencies: - "@tanstack/react-router": ^1.117.0 + "@tanstack/react-router": ^1.121.34 react: ">=18.0.0 || >=19.0.0" react-dom: ">=18.0.0 || >=19.0.0" - checksum: 10c0/a30af002ec3bb3b835e1ec87dc2990778bd67f9b53cf8885fca625e537371eca3218620373797562a4196a5057a7fe8ea922c958dbb309792186dcf1ab113fb2 + checksum: 10c0/815b32eafde6755a6f6f36d28590abd72db50530433b94ee864a5f37e61497b4c5b143943d1ce96786528b20e066708f8f441bf306c8b97bbc5217c65a4c12be languageName: node linkType: hard @@ -5806,21 +5805,22 @@ __metadata: languageName: node linkType: hard -"@tanstack/router-devtools-core@npm:^1.117.0": - version: 1.117.0 - resolution: "@tanstack/router-devtools-core@npm:1.117.0" +"@tanstack/router-devtools-core@npm:^1.121.34": + version: 1.121.34 + resolution: "@tanstack/router-devtools-core@npm:1.121.34" dependencies: clsx: "npm:^2.1.1" goober: "npm:^2.1.16" + solid-js: "npm:^1.9.5" peerDependencies: - "@tanstack/router-core": ^1.117.0 + "@tanstack/router-core": ^1.121.34 csstype: ^3.0.10 solid-js: ">=1.9.5" tiny-invariant: ^1.3.3 peerDependenciesMeta: csstype: optional: true - checksum: 10c0/063252e7bd58562a67be0766a0cfbeec31c04c43d6324e5b44953059123d0c222320fa52dc1ade01d3110075e51487836c835ad2e957c8b61a3797e0943d1eac + checksum: 10c0/3cdc0ee4827e4ab37a979700d062c318538a13b982ed80bb23b5235eea6fa5992940b406cc9c4e03737742a45f3ab8397aefe52a1b7913cdc48a470702a00f24 languageName: node linkType: hard