Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
Initiate MCP OAuth flow on post-initialize 401 responses (#60236)
bgfraser12e1e24434eb
diff --git a/crates/context_server/src/client.rs b/crates/context_server/src/client.rsindex b8a321d01b5..3761f19ec4a 100644--- a/crates/context_server/src/client.rs+++ b/crates/context_server/src/client.rs@@ -4,7 +4,7 @@ use futures::{FutureExt, StreamExt, channel::oneshot, future, select};use futures_lite::future::yield_now;use gpui::{AppContext as _, AsyncApp, BackgroundExecutor, Task};use parking_lot::Mutex;-use postage::barrier;+use postage::{barrier, prelude::Stream as _};use serde::{Deserialize, Serialize, de::DeserializeOwned};use serde_json::{Value, value::RawValue};use slotmap::SlotMap;@@ -21,6 +21,7 @@ use std::{use util::{ResultExt, TryFutureExt};use crate::{+ oauth::WwwAuthenticate,transport::{StdioTransport, Transport},types::{CancelledParams, ClientNotification, Notification as _, notifications::Cancelled},};@@ -56,19 +57,19 @@ pub(crate) struct Client {#[allow(clippy::type_complexity)]#[allow(dead_code)]io_tasks: Mutex<Option<(Task<Option<()>>, Task<Option<()>>)>>,- #[allow(dead_code)]output_done_rx: Mutex<Option<barrier::Receiver>>,executor: BackgroundExecutor,- #[allow(dead_code)]transport: Arc<dyn Transport>,request_timeout: Option<Duration>,/// Single-slot side channel for the last transport-level error. When the/// output task encounters a send failure it stashes the error here and- /// exits; the next request to observe cancellation `.take()`s it so it can- /// propagate a typed error (e.g. `TransportError::AuthRequired`) instead- /// of a generic "cancelled". This works because `initialize` is the sole- /// in-flight request at startup, but would need rethinking if concurrent- /// requests are ever issued during that phase.+ /// exits; the next request to observe cancellation `.take()`s it so it+ /// can fail with the underlying cause (e.g. "connection refused") instead+ /// of a generic "cancelled". This is best-effort diagnostics: with+ /// concurrent requests in flight, a single arbitrary one receives the+ /// stashed error. Nothing may depend on it for correctness —+ /// authentication challenges are observed via [`Self::wait_for_shutdown`]+ /// and [`Transport::auth_challenge`], which do not involve requests.last_transport_error: Arc<Mutex<Option<anyhow::Error>>>,}@@ -348,6 +349,28 @@ impl Client {Ok(())}+ /// A future that resolves once the transport's output loop has terminated+ /// — after a send failure, or when this client is dropped — yielding the+ /// authentication challenge recorded by the transport if it shut down on a+ /// `401 Unauthorized` response.+ ///+ /// Unlike `last_transport_error`, this does not require a request to be in+ /// flight when the transport fails. Returns `None` if the shutdown signal+ /// was already claimed: there is a single signal per client.+ pub(crate) fn wait_for_shutdown(+ &self,+ ) -> Option<future::BoxFuture<'static, Option<WwwAuthenticate>>> {+ let mut output_done = self.output_done_rx.lock().take()?;+ let transport = self.transport.clone();+ Some(+ async move {+ output_done.recv().await;+ transport.auth_challenge()+ }+ .boxed(),+ )+ }+/// Sends a JSON-RPC request to the context server and waits for a response./// This function handles serialization, deserialization, timeout, and error handling.pub async fn request<T: DeserializeOwned>(diff --git a/crates/context_server/src/context_server.rs b/crates/context_server/src/context_server.rsindex 05a3451ea86..865f779b160 100644--- a/crates/context_server/src/context_server.rs+++ b/crates/context_server/src/context_server.rs@@ -21,6 +21,7 @@ use parking_lot::RwLock;pub use settings::ContextServerCommand;use url::Url;+use crate::oauth::WwwAuthenticate;use crate::transport::HttpTransport;#[derive(Debug, Clone, PartialEq, Eq, Hash)]@@ -106,6 +107,16 @@ impl ContextServer {self.client.read().clone()}+ /// The authentication challenge from the last `401 Unauthorized` response+ /// this server's transport gave up on, if any. See+ /// [`crate::transport::Transport::auth_challenge`].+ pub fn auth_challenge(&self) -> Option<WwwAuthenticate> {+ match &self.configuration {+ ContextServerTransport::Stdio(..) => None,+ ContextServerTransport::Custom(transport) => transport.auth_challenge(),+ }+ }+pub async fn start(&self, cx: &AsyncApp) -> Result<()> {self.initialize(self.new_client(cx)?).await}diff --git a/crates/context_server/src/protocol.rs b/crates/context_server/src/protocol.rsindex 05082637c27..6eb4a84a46c 100644--- a/crates/context_server/src/protocol.rs+++ b/crates/context_server/src/protocol.rs@@ -8,11 +8,12 @@use std::time::Duration;use anyhow::Result;-use futures::channel::oneshot;+use futures::{channel::oneshot, future::BoxFuture};use gpui::AsyncApp;use serde_json::Value;use crate::client::{Client, NotificationSubscription};+use crate::oauth::WwwAuthenticate;use crate::types::{self, Notification, Request};pub struct ModelContextProtocol {@@ -122,6 +123,20 @@ impl InitializedContextServerProtocol {self.inner.notify(T::METHOD, params)}+ /// A future that resolves once the underlying transport's output loop has+ /// terminated — after a send failure, or when the client is dropped —+ /// yielding the authentication challenge recorded by the transport if it+ /// shut down on a `401 Unauthorized` response.+ ///+ /// Servers may accept `initialize` unauthenticated and only challenge a+ /// later request or notification. Awaiting this is what lets the owner of+ /// the connection notice such a challenge even when no request was in+ /// flight to carry a typed error back. Returns `None` if the shutdown+ /// signal was already claimed: there is a single signal per client.+ pub fn wait_for_shutdown(&self) -> Option<BoxFuture<'static, Option<WwwAuthenticate>>> {+ self.inner.wait_for_shutdown()+ }+pub fn on_notification(&self,method: &'static str,diff --git a/crates/context_server/src/transport.rs b/crates/context_server/src/transport.rsindex bffd7e4c4d8..edb8a5e8da0 100644--- a/crates/context_server/src/transport.rs+++ b/crates/context_server/src/transport.rs@@ -6,6 +6,8 @@ use async_trait::async_trait;use futures::Stream;use std::pin::Pin;+use crate::oauth::WwwAuthenticate;+pub use http::*;pub use stdio_transport::*;@@ -19,4 +21,16 @@ pub trait Transport: Send + Sync {/// need the negotiated version (currently only HTTP, which must attach an/// `MCP-Protocol-Version` header from 2025-06-18 onward) can pick it up.fn set_protocol_version(&self, _version: &str) {}++ /// The authentication challenge from the last `401 Unauthorized` response+ /// this transport gave up on, if any (currently only set by the HTTP+ /// transport).+ ///+ /// The challenge is recorded right before the failed send tears down the+ /// client's output loop. Observers of the client's shutdown read it from+ /// here, so a 401 can initiate the OAuth flow even when it arrived on a+ /// notification, with no request in flight to carry a typed error.+ fn auth_challenge(&self) -> Option<WwwAuthenticate> {+ None+ }}diff --git a/crates/context_server/src/transport/http.rs b/crates/context_server/src/transport/http.rsindex bf374586b35..aa47a73fc38 100644--- a/crates/context_server/src/transport/http.rs+++ b/crates/context_server/src/transport/http.rs@@ -58,6 +58,10 @@ pub struct HttpTransport {/// When set, the transport attaches `Authorization: Bearer` headers and/// handles 401 responses with token refresh + retry.token_provider: Option<Arc<dyn OAuthTokenProvider>>,+ /// The challenge from the last 401 this transport gave up on; cleared at+ /// the start of each send so it always describes the most recent attempt.+ /// See [`Transport::auth_challenge`].+ auth_challenge: SyncMutex<Option<WwwAuthenticate>>,}impl HttpTransport {@@ -92,6 +96,7 @@ impl HttpTransport {error_rx,headers,token_provider,+ auth_challenge: SyncMutex::new(None),}}@@ -133,8 +138,21 @@ impl HttpTransport {Ok(request_builder.body(AsyncBody::from(message.to_vec()))?)}+ /// Record the challenge so it remains observable after the failed send+ /// tears down the client (see [`Transport::auth_challenge`]), and build+ /// the typed error for the send itself.+ fn auth_required(&self, www_authenticate: WwwAuthenticate) -> anyhow::Error {+ *self.auth_challenge.lock() = Some(www_authenticate.clone());+ TransportError::AuthRequired { www_authenticate }.into()+ }+/// Send a message and handle the response based on content type.async fn send_message(&self, message: String) -> Result<()> {+ // The same server instance can be restarted over this transport; a+ // challenge recorded by a previous client generation must not be+ // observed by the current one.+ *self.auth_challenge.lock() = None;+let is_notification =!message.contains("\"id\":") || message.contains("notifications/initialized");@@ -174,13 +192,13 @@ impl HttpTransport {// If still 401 after refresh, give up.if response.status().as_u16() == 401 {- return Err(TransportError::AuthRequired { www_authenticate }.into());+ return Err(self.auth_required(www_authenticate));}} else {- return Err(TransportError::AuthRequired { www_authenticate }.into());+ return Err(self.auth_required(www_authenticate));}} else {- return Err(TransportError::AuthRequired { www_authenticate }.into());+ return Err(self.auth_required(www_authenticate));}}@@ -335,6 +353,10 @@ impl Transport for HttpTransport {fn set_protocol_version(&self, version: &str) {*self.protocol_version.lock() = Some(version.to_string());}++ fn auth_challenge(&self) -> Option<WwwAuthenticate> {+ self.auth_challenge.lock().clone()+ }}impl Drop for HttpTransport {diff --git a/crates/project/src/context_server_store.rs b/crates/project/src/context_server_store.rsindex ef5077d53a2..bbd53e1e733 100644--- a/crates/project/src/context_server_store.rs+++ b/crates/project/src/context_server_store.rs@@ -8,7 +8,7 @@ use std::time::Duration;use anyhow::{Context as _, Result};use collections::{HashMap, HashSet};use context_server::oauth::{self, McpOAuthTokenProvider, OAuthDiscovery, OAuthSession};-use context_server::transport::{HttpTransport, TransportError};+use context_server::transport::HttpTransport;use context_server::{ContextServer, ContextServerCommand, ContextServerId};use credentials_provider::CredentialsProvider;use futures::future::Either;@@ -93,6 +93,9 @@ enum ContextServerState {Running {server: Arc<ContextServer>,configuration: Arc<ContextServerConfiguration>,+ /// Initiates the OAuth flow if the transport shuts down on an+ /// authentication challenge; cancelled by any state transition.+ _transport_watch: Task<()>,},Stopped {server: Arc<ContextServer>,@@ -708,9 +711,12 @@ impl ContextServerStore {let new_state = match server.clone().start(cx).await {Ok(_) => {debug_assert!(server.client().is_some());+ let _transport_watch =+ Self::watch_transport_shutdown(this.clone(), server.clone(), cx);ContextServerState::Running {server,configuration,+ _transport_watch,}}Err(err) => resolve_start_failure(&id, err, server, configuration, cx).await,@@ -733,6 +739,97 @@ impl ContextServerStore {);}+ /// Watches a running server's transport and initiates the OAuth flow if it+ /// shuts down on an authentication challenge.+ ///+ /// MCP servers may accept `initialize` unauthenticated and only send a 401+ /// with a `WWW-Authenticate` challenge on a later request or notification.+ /// The HTTP transport records the challenge, and the failed send tears+ /// down the client's output loop. Observing that shutdown — rather than+ /// relying on some request to carry a typed error back to a caller — is+ /// what lets any post-initialize 401 move the server into `AuthRequired`+ /// instead of leaving it `Running` with a dead client.+ fn watch_transport_shutdown(+ this: WeakEntity<Self>,+ server: Arc<ContextServer>,+ cx: &mut AsyncApp,+ ) -> Task<()> {+ let Some(shutdown) = server+ .client()+ .and_then(|client| client.wait_for_shutdown())+ else {+ return Task::ready(());+ };+ cx.spawn(async move |cx| {+ let Some(www_authenticate) = shutdown.await else {+ // Non-auth transport deaths leave the server state untouched,+ // as they did before this watch existed.+ return;+ };+ this.update(cx, |this, cx| {+ this.handle_auth_challenge(server, www_authenticate, cx);+ })+ .log_err();+ })+ }++ fn handle_auth_challenge(+ &mut self,+ server: Arc<ContextServer>,+ www_authenticate: oauth::WwwAuthenticate,+ cx: &mut Context<Self>,+ ) {+ let id = server.id();++ // Act only if this exact server is still the one we consider running.+ // If the state has changed since the challenge was recorded, whoever+ // changed it owns the lifecycle now.+ let Some(ContextServerState::Running {+ server: running_server,+ configuration,+ ..+ }) = self.servers.get(&id)+ else {+ return;+ };+ if !Arc::ptr_eq(running_server, &server) {+ return;+ }+ let configuration = configuration.clone();++ log::info!("{id} received 401 after initialization; initiating OAuth authorization");++ // The 401 already tore down the client's output loop. Stop the dead+ // client, then resolve auth using the captured `WWW-Authenticate` — do+ // not restart via `run_server`, as a fresh `initialize` would succeed+ // and lose the challenge.+ server.stop().log_err();++ let task = cx.spawn({+ let id = id.clone();+ let server = server.clone();+ let configuration = configuration.clone();+ async move |this, cx| {+ let new_state =+ resolve_auth_required(&id, &www_authenticate, server, configuration, cx).await;+ this.update(cx, |this, cx| {+ this.update_server_state(id.clone(), new_state, cx)+ })+ .log_err();+ }+ });++ self.update_server_state(+ id,+ ContextServerState::Starting {+ configuration,+ _task: task,+ server,+ },+ cx,+ );+ }+fn remove_server(&mut self, id: &ContextServerId, cx: &mut Context<Self>) -> Result<()> {let state = self.servers@@ -1686,43 +1783,34 @@ async fn resolve_start_failure(configuration: Arc<ContextServerConfiguration>,cx: &AsyncApp,) -> ContextServerState {- let www_authenticate = err.downcast_ref::<TransportError>().map(|e| match e {- TransportError::AuthRequired { www_authenticate } => www_authenticate.clone(),- });-- if www_authenticate.is_some() && configuration.has_static_auth_header() {- log::warn!("{id} received 401 with a static Authorization header configured");- return ContextServerState::Error {- configuration,- server,- error: "Server returned 401 Unauthorized. Check your configured Authorization header."- .into(),- };- }-- let server_url = match configuration.as_ref() {- ContextServerConfiguration::Http { url, .. } if !configuration.has_static_auth_header() => {- url.clone()- }- _ => {- if www_authenticate.is_some() {- log::error!("{id} got OAuth 401 on a non-HTTP transport or with static auth");- } else {- log::error!("{id} context server failed to start: {err}");- }- return ContextServerState::Error {- configuration,- server,- error: err.to_string().into(),- };- }- };+ // Read the challenge from the transport rather than downcasting `err`: it+ // is recorded before the failed send's error propagates, so a 401 is+ // recognized even when another error (e.g. the request timeout) wins the+ // race to become the reported startup failure.+ let www_authenticate = server.auth_challenge();// When the error is NOT a 401 but there is a cached OAuth session in the// keychain, the session is likely stale/expired and caused the failure// (e.g. timeout because the server rejected the token silently). Clear it// so the next start attempt can get a clean 401 and trigger the auth flow.+ // If there is no such session this is an ordinary startup error.if www_authenticate.is_none() {+ let server_url = match configuration.as_ref() {+ ContextServerConfiguration::Http { url, .. }+ if !configuration.has_static_auth_header() =>+ {+ url.clone()+ }+ _ => {+ log::error!("{id} context server failed to start: {err}");+ return ContextServerState::Error {+ configuration,+ server,+ error: err.to_string().into(),+ };+ }+ };+let credentials_provider = cx.update(|cx| zed_credentials_provider::global(cx));match ContextServerStore::load_session(&credentials_provider, &server_url, cx).await {Ok(Some(_)) => {@@ -1751,6 +1839,46 @@ async fn resolve_start_failure(let www_authenticate = www_authenticate.as_ref().unwrap_or(&default_www_authenticate);++ resolve_auth_required(id, www_authenticate, server, configuration, cx).await+}++/// Runs OAuth discovery for a server that returned a 401 and produces the+/// appropriate state (`AuthRequired`, `ClientSecretRequired`, or `Error`).+///+/// Shared by the startup path ([`resolve_start_failure`]) and the+/// post-initialize path ([`ContextServerStore::handle_auth_challenge`]) so+/// that a 401 at any point — not only during `initialize` — can initiate the+/// OAuth flow.+async fn resolve_auth_required(+ id: &ContextServerId,+ www_authenticate: &oauth::WwwAuthenticate,+ server: Arc<ContextServer>,+ configuration: Arc<ContextServerConfiguration>,+ cx: &AsyncApp,+) -> ContextServerState {+ if configuration.has_static_auth_header() {+ log::warn!("{id} received 401 with a static Authorization header configured");+ return ContextServerState::Error {+ configuration,+ server,+ error: "Server returned 401 Unauthorized. Check your configured Authorization header."+ .into(),+ };+ }++ let server_url = match configuration.as_ref() {+ ContextServerConfiguration::Http { url, .. } => url.clone(),+ _ => {+ log::error!("{id} got OAuth 401 on a non-HTTP transport");+ return ContextServerState::Error {+ configuration,+ server,+ error: "Server returned 401 Unauthorized on a non-HTTP transport".into(),+ };+ }+ };+let http_client = cx.update(|cx| cx.http_client());match context_server::oauth::discover(&http_client, &server_url, www_authenticate).await {diff --git a/crates/project/tests/integration/context_server_store.rs b/crates/project/tests/integration/context_server_store.rsindex 090baacf032..a91cdd2ea81 100644--- a/crates/project/tests/integration/context_server_store.rs+++ b/crates/project/tests/integration/context_server_store.rs@@ -914,6 +914,421 @@ async fn test_remote_context_server(cx: &mut TestAppContext) {cx.run_until_parked();}+// A server may accept `initialize` unauthenticated (returns 200) yet only send+// `WWW-Authenticate` on a later request such as `tools/list` / `tools/call`.+// That post-initialize 401 must initiate the OAuth flow instead of surfacing as+// an opaque request failure while the server stays "Running".+#[gpui::test]+async fn test_http_server_authenticates_on_post_init_401(cx: &mut TestAppContext) {+ use context_server::transport::TransportError;++ const SERVER_ID: &str = "auth-server";+ let server_id = ContextServerId(SERVER_ID.into());++ set_fake_mcp_http_client(cx, |message| {+ if message.contains("\"method\":\"initialize\"") {+ Ok(initialize_response())+ } else if message.contains("notifications/initialized") {+ Ok(notification_accepted_response())+ } else {+ Ok(unauthorized_response())+ }+ });++ let (_fs, project) = setup_context_server_test(cx, json!({ "code.rs": "" }), vec![]).await;+ let store = project.read_with(cx, |project, _| project.context_server_store());++ set_http_context_server_configuration(&server_id, cx);++ {+ let _server_events = assert_server_events(+ &store,+ vec![+ (server_id.clone(), ContextServerStatus::Starting),+ (server_id.clone(), ContextServerStatus::Running),+ ],+ cx,+ );+ cx.run_until_parked();+ }++ let client = store.read_with(cx, |store, _| {+ store+ .get_running_server(&server_id)+ .expect("server should be running")+ .client()+ .expect("running server should have a client")+ });++ {+ let _server_events = assert_server_events(+ &store,+ vec![+ (server_id.clone(), ContextServerStatus::Starting),+ (server_id.clone(), ContextServerStatus::AuthRequired),+ ],+ cx,+ );++ // The 401 tears down the client, and the request that carried it fails+ // with the typed error.+ let error = client+ .request::<context_server::types::requests::ListTools>(())+ .await+ .expect_err("request challenged with a 401 should fail");+ assert!(+ matches!(+ error.downcast_ref::<TransportError>(),+ Some(TransportError::AuthRequired { .. })+ ),+ "expected an AuthRequired error, got: {error}"+ );++ cx.run_until_parked();+ }++ cx.update(|cx| {+ assert_eq!(+ store.read(cx).status_for_server(&server_id),+ Some(ContextServerStatus::AuthRequired),+ "server should require authentication after a post-initialize 401"+ );+ });+}++// The first 401 may even arrive on a notification (`notifications/initialized`+// here): the send fails with no request in flight to carry a typed error back,+// and the client is dead by the time anything notices. Watching the transport+// shutdown must still move the server into `AuthRequired`.+#[gpui::test]+async fn test_http_server_authenticates_on_notification_401(cx: &mut TestAppContext) {+ const SERVER_ID: &str = "auth-server";+ let server_id = ContextServerId(SERVER_ID.into());++ set_fake_mcp_http_client(cx, |message| {+ if message.contains("\"method\":\"initialize\"") {+ Ok(initialize_response())+ } else {+ Ok(unauthorized_response())+ }+ });++ let (_fs, project) = setup_context_server_test(cx, json!({ "code.rs": "" }), vec![]).await;+ let store = project.read_with(cx, |project, _| project.context_server_store());++ set_http_context_server_configuration(&server_id, cx);++ {+ let _server_events = assert_server_events(+ &store,+ vec![+ (server_id.clone(), ContextServerStatus::Starting),+ (server_id.clone(), ContextServerStatus::Running),+ (server_id.clone(), ContextServerStatus::Starting),+ (server_id.clone(), ContextServerStatus::AuthRequired),+ ],+ cx,+ );+ cx.run_until_parked();+ }++ cx.update(|cx| {+ assert_eq!(+ store.read(cx).status_for_server(&server_id),+ Some(ContextServerStatus::AuthRequired),+ "server should require authentication after a 401 on a notification"+ );+ });+}++// A transport failure that is not an authentication challenge must not touch+// the server's state: no spurious auth flow, and (as before the transport+// watch existed) the server stays `Running`.+#[gpui::test]+async fn test_http_server_ignores_non_auth_transport_failure(cx: &mut TestAppContext) {+ const SERVER_ID: &str = "flaky-server";+ let server_id = ContextServerId(SERVER_ID.into());++ set_fake_mcp_http_client(cx, |message| {+ if message.contains("\"method\":\"initialize\"") {+ Ok(initialize_response())+ } else if message.contains("notifications/initialized") {+ Ok(notification_accepted_response())+ } else {+ Err(anyhow::anyhow!("connection reset"))+ }+ });++ let (_fs, project) = setup_context_server_test(cx, json!({ "code.rs": "" }), vec![]).await;+ let store = project.read_with(cx, |project, _| project.context_server_store());++ set_http_context_server_configuration(&server_id, cx);++ {+ let _server_events = assert_server_events(+ &store,+ vec![+ (server_id.clone(), ContextServerStatus::Starting),+ (server_id.clone(), ContextServerStatus::Running),+ ],+ cx,+ );+ cx.run_until_parked();++ let client = store.read_with(cx, |store, _| {+ store+ .get_running_server(&server_id)+ .expect("server should be running")+ .client()+ .expect("running server should have a client")+ });++ client+ .request::<context_server::types::requests::ListTools>(())+ .await+ .expect_err("request should fail when the transport errors");++ cx.run_until_parked();+ // Dropping the events guard asserts no further status change happened.+ }++ cx.update(|cx| {+ assert_eq!(+ store.read(cx).status_for_server(&server_id),+ Some(ContextServerStatus::Running),+ "a non-auth transport failure should not change the server state"+ );+ });+}++// A server may also require authentication on `initialize` itself. The+// challenge is read from the transport slot rather than the returned error, so+// the 401 is recognized even if another error (e.g. the request timeout) wins+// the race to become the reported startup failure.+#[gpui::test]+async fn test_http_server_authenticates_on_initialize_401(cx: &mut TestAppContext) {+ const SERVER_ID: &str = "auth-server";+ let server_id = ContextServerId(SERVER_ID.into());++ set_fake_mcp_http_client(cx, |_message| Ok(unauthorized_response()));++ let (_fs, project) = setup_context_server_test(cx, json!({ "code.rs": "" }), vec![]).await;+ let store = project.read_with(cx, |project, _| project.context_server_store());++ set_http_context_server_configuration(&server_id, cx);++ {+ let _server_events = assert_server_events(+ &store,+ vec![+ (server_id.clone(), ContextServerStatus::Starting),+ (server_id.clone(), ContextServerStatus::AuthRequired),+ ],+ cx,+ );+ cx.run_until_parked();+ }++ cx.update(|cx| {+ assert_eq!(+ store.read(cx).status_for_server(&server_id),+ Some(ContextServerStatus::AuthRequired),+ "server should require authentication after a 401 on initialize"+ );+ });+}++// Restarting a server reuses its transport (e.g. via the MCP settings page),+// so a challenge recorded by a previous client generation must not leak into+// the next one: after a successful restart, a non-auth transport failure must+// not trip a spurious auth flow on the stale challenge.+#[gpui::test]+async fn test_http_server_restart_clears_stale_auth_challenge(cx: &mut TestAppContext) {+ use std::sync::atomic::{AtomicBool, Ordering};++ const SERVER_ID: &str = "auth-server";+ let server_id = ContextServerId(SERVER_ID.into());++ let restarted = Arc::new(AtomicBool::new(false));+ set_fake_mcp_http_client(cx, {+ let restarted = restarted.clone();+ move |message| {+ if message.contains("\"method\":\"initialize\"") {+ Ok(initialize_response())+ } else if message.contains("notifications/initialized") {+ Ok(notification_accepted_response())+ } else if restarted.load(Ordering::SeqCst) {+ Err(anyhow::anyhow!("connection reset"))+ } else {+ Ok(unauthorized_response())+ }+ }+ });++ let (_fs, project) = setup_context_server_test(cx, json!({ "code.rs": "" }), vec![]).await;+ let store = project.read_with(cx, |project, _| project.context_server_store());++ set_http_context_server_configuration(&server_id, cx);+ cx.run_until_parked();++ // A post-initialize 401 records a challenge on the transport and moves the+ // server into AuthRequired.+ let client = store.read_with(cx, |store, _| {+ store+ .get_running_server(&server_id)+ .expect("server should be running")+ .client()+ .expect("running server should have a client")+ });+ client+ .request::<context_server::types::requests::ListTools>(())+ .await+ .expect_err("request challenged with a 401 should fail");+ // Drop our handle so the dead client fully goes away, as it does in+ // production once the store has stopped it: a lingering client would+ // compete with its successor for the reused transport's response channel.+ drop(client);+ cx.run_until_parked();+ cx.update(|cx| {+ assert_eq!(+ store.read(cx).status_for_server(&server_id),+ Some(ContextServerStatus::AuthRequired),+ );+ });++ // The user restarts the same server instance instead of authenticating,+ // and the server no longer challenges.+ restarted.store(true, Ordering::SeqCst);+ store.update(cx, |store, cx| {+ let server = store.get_server(&server_id).expect("server should exist");+ store.start_server(server, cx);+ });+ cx.run_until_parked();+ cx.update(|cx| {+ assert_eq!(+ store.read(cx).status_for_server(&server_id),+ Some(ContextServerStatus::Running),+ );+ });++ let client = store.read_with(cx, |store, _| {+ store+ .get_running_server(&server_id)+ .expect("server should be running")+ .client()+ .expect("running server should have a client")+ });+ client+ .request::<context_server::types::requests::ListTools>(())+ .await+ .expect_err("request should fail when the transport errors");+ cx.run_until_parked();++ cx.update(|cx| {+ assert_eq!(+ store.read(cx).status_for_server(&server_id),+ Some(ContextServerStatus::Running),+ "a stale challenge from a previous client generation must not trigger auth"+ );+ });+}++fn set_http_context_server_configuration(server_id: &ContextServerId, cx: &mut TestAppContext) {+ set_context_server_configuration(+ vec![(+ server_id.0.clone(),+ settings::ContextServerSettingsContent::Http {+ enabled: true,+ url: "https://mcp.example.com/mcp".to_string(),+ headers: Default::default(),+ timeout: None,+ oauth: None,+ },+ )],+ cx,+ );+}++/// A fake HTTP client that serves the OAuth discovery documents (CIMD-capable,+/// so no dynamic client registration is needed) and routes MCP endpoint POSTs+/// to `respond_to_mcp_message` by the JSON-RPC message in the request body.+fn set_fake_mcp_http_client(+ cx: &mut TestAppContext,+ respond_to_mcp_message: impl Fn(&str) -> Result<Response<http_client::AsyncBody>>+ + Send+ + Sync+ + 'static,+) {+ let respond_to_mcp_message = Arc::new(respond_to_mcp_message);+ let client = FakeHttpClient::create(move |request| {+ let respond_to_mcp_message = respond_to_mcp_message.clone();+ async move {+ let uri = request.uri().to_string();+ let discovery_document = if uri.contains("oauth-protected-resource") {+ Some(json!({+ "resource": "https://mcp.example.com",+ "authorization_servers": ["https://auth.example.com"],+ "scopes_supported": ["mcp:read"]+ }))+ } else if uri.contains("oauth-authorization-server") {+ Some(json!({+ "issuer": "https://auth.example.com",+ "authorization_endpoint": "https://auth.example.com/authorize",+ "token_endpoint": "https://auth.example.com/token",+ "code_challenge_methods_supported": ["S256"],+ "client_id_metadata_document_supported": true+ }))+ } else {+ None+ };+ if let Some(document) = discovery_document {+ return Ok(json_response(document));+ }++ let mut body = request.into_body();+ let mut message = String::new();+ futures::AsyncReadExt::read_to_string(&mut body, &mut message).await?;+ respond_to_mcp_message(&message)+ }+ });+ cx.update(|cx| cx.set_http_client(client));+}++fn json_response(body: serde_json::Value) -> Response<http_client::AsyncBody> {+ Response::builder()+ .status(200)+ .header("Content-Type", "application/json")+ .body(http_client::AsyncBody::from(body.to_string()))+ .unwrap()+}++fn initialize_response() -> Response<http_client::AsyncBody> {+ json_response(json!({+ "jsonrpc": "2.0",+ "id": 0,+ "result": {+ "protocolVersion": "2024-11-05",+ "capabilities": {},+ "serverInfo": { "name": "test-server", "version": "1.0.0" }+ }+ }))+}++fn notification_accepted_response() -> Response<http_client::AsyncBody> {+ Response::builder()+ .status(202)+ .body(http_client::AsyncBody::empty())+ .unwrap()+}++fn unauthorized_response() -> Response<http_client::AsyncBody> {+ Response::builder()+ .status(401)+ .header("WWW-Authenticate", "Bearer")+ .body(http_client::AsyncBody::empty())+ .unwrap()+}+struct ServerEvents {received_event_count: Rc<RefCell<usize>>,expected_event_count: usize,