Method execute_mcp_delete

src/apps/cli/src/modes/chat.rs:2658–2733

Execute MCP server delete (called from main loop after render)

(
        &mut self,
        server_id: &str,
        chat_view: &mut ChatView,
        chat_state: &mut ChatState,
        rt_handle: &tokio::runtime::Handle,
    )

    /// Execute MCP server delete (called from main loop after render)
    fn execute_mcp_delete(
        &mut self,
        server_id: &str,
        chat_view: &mut ChatView,
        chat_state: &mut ChatState,
        rt_handle: &tokio::runtime::Handle,
    ) {
        let mcp_service = match crate::get_mcp_service() {
            Some(svc) => svc.clone(),
            None => {
                chat_state.add_system_message("MCP service not initialized".to_string());
                chat_view.mcp_selector_set_loading(None);
                return;
            }
        };

        let server_id_owned = server_id.to_string();
        let task_server_id = server_id_owned.clone();
        let handle = rt_handle.spawn(async move {
            // Delete config first so UI can reflect removal immediately even if stop is blocked.
            mcp_service
                .config_service()
                .delete_server_config(&server_id_owned)
                .await?;

            // Best-effort async cleanup: slow startups may hold process write lock for a long time.
            // Retry stop with short timeout, without blocking the delete operation completion.
            let cleanup_service = mcp_service.clone();
            let cleanup_server_id = server_id_owned.clone();
            tokio::spawn(async move {
                for attempt in 1..=20 {
                    let stop_result = tokio::time::timeout(
                        Duration::from_millis(250),
                        cleanup_service
                            .server_manager()
                            .stop_server(&cleanup_server_id),
                    )
                    .await;

                    match stop_result {
                        Ok(Ok(())) => return,
                        Ok(Err(bitfun_core::util::errors::BitFunError::NotFound(_))) => return,
                        Ok(Err(e)) => {
                            tracing::debug!(
                                "Best-effort MCP stop failed: id={} attempt={} error={}",
                                cleanup_server_id,
                                attempt,
                                e
                            );
                        }
                        Err(_) => {
                            tracing::debug!(
                                "Best-effort MCP stop timed out: id={} attempt={}",
                                cleanup_server_id,
                                attempt
                            );
                        }
                    }