Function get_mcp_servers

src/apps/desktop/src/api/mcp_api.rs:179–315

(state: State<'_, AppState>)

#[tauri::command]
pub async fn get_mcp_servers(state: State<'_, AppState>) -> Result<Vec<MCPServerInfo>, String> {
    let mcp_service = state
        .mcp_service
        .as_ref()
        .ok_or_else(|| "MCP service not initialized".to_string())?;

    let configs = mcp_service
        .config_service()
        .load_all_configs()
        .await
        .map_err(|e| e.to_string())?;

    let mut infos = Vec::new();
    let runtime_manager = RuntimeManager::new().ok();

    for config in configs {
        let transport = config.resolved_transport();
        let static_auth_configured = if matches!(config.server_type, MCPServerType::Remote) {
            MCPConfigService::has_remote_authorization(&config)
        } else {
            false
        };
        let oauth_enabled = matches!(config.server_type, MCPServerType::Remote);
        let oauth_auth_configured = if oauth_enabled {
            has_stored_oauth_credentials(&config.id)
                .await
                .unwrap_or(false)
        } else {
            false
        };

        let (command, command_available, command_source, command_resolved_path) =
            if transport == bitfun_core::service::mcp::MCPServerTransport::Stdio {
                if let Some(command) = config.command.clone() {
                    let capability = runtime_manager
                        .as_ref()
                        .map(|manager| manager.get_command_capability(&command));
                    let available = capability.as_ref().map(|c| c.available);
                    let source = capability.and_then(|c| {
                        c.source.map(|source| match source {
                            RuntimeSource::System => "system".to_string(),
                            RuntimeSource::Managed => "managed".to_string(),
                        })
                    });
                    let resolved_path = runtime_manager
                        .as_ref()
                        .and_then(|manager| manager.resolve_command(&command))
                        .and_then(|resolved| resolved.resolved_path);
                    (Some(command), available, source, resolved_path)
                } else {
                    (None, None, None, None)
                }
            } else {
                (None, None, None, None)
            };

        let (start_supported, start_disabled_reason) = match config.server_type {
            MCPServerType::Remote if transport.as_str() == "sse" => (