Lightweight coding agent that runs in your terminal
Rust
Retire rejected MCP OAuth refresh tokens (#54079)
Matthew Zeng4ae6016a9388
diff --git a/codex-rs/core/tests/suite/mcp_oauth_refresh_tests.rs b/codex-rs/core/tests/suite/mcp_oauth_refresh_tests.rsindex 6f7d1a5618..c0207b95ee 100644--- a/codex-rs/core/tests/suite/mcp_oauth_refresh_tests.rs+++ b/codex-rs/core/tests/suite/mcp_oauth_refresh_tests.rs@@ -8,12 +8,16 @@ use std::sync::Arc;use codex_config::DEFAULT_MCP_SERVER_ENVIRONMENT_ID;use codex_config::McpServerConfig;+use codex_config::types::AuthKeyringBackendKind;use codex_config::types::OAuthCredentialsStoreMode;use codex_features::Feature;use codex_protocol::items::McpToolCallStatus;use codex_protocol::items::TurnItem;use codex_protocol::mcp::CallToolResult;use codex_protocol::protocol::EventMsg;+use codex_protocol::protocol::McpStartupFailureReason;+use codex_protocol::protocol::McpStartupStatus;+use codex_rmcp_client::stored_oauth_credentials;use core_test_support::apps_test_server::AppsTestServer;use core_test_support::responses;use core_test_support::skip_if_no_network;@@ -27,6 +31,7 @@ use test_case::test_case;use wiremock::Mock;use wiremock::ResponseTemplate;use wiremock::matchers::body_partial_json;+use wiremock::matchers::body_string_contains;use wiremock::matchers::method;use wiremock::matchers::path;@@ -35,6 +40,119 @@ enum ConfigRefreshPath {Mcp,}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+#[serial(codex_home)]+async fn rejected_refresh_requires_reauthentication_after_runtime_rebuild() -> anyhow::Result<()> {+ skip_if_no_network!(Ok(()));++ let responses_server = responses::start_mock_server().await;+ let mcp_server = responses::start_mock_server().await;+ let http_server = AppsTestServer::mount(&mcp_server).await?;+ let server_name = "rejected_refresh";+ let server_url = format!("{}/api/codex/ps/mcp", http_server.chatgpt_base_url);+ Mock::given(method("GET"))+ .and(path(+ "/.well-known/oauth-authorization-server/api/codex/ps/mcp",+ ))+ .respond_with(ResponseTemplate::new(200).set_body_json(json!({+ "issuer": server_url,+ "authorization_endpoint": format!("{}/oauth/authorize", mcp_server.uri()),+ "token_endpoint": format!("{}/oauth/token", mcp_server.uri()),+ })))+ .mount(&mcp_server)+ .await;+ Mock::given(method("POST"))+ .and(path("/oauth/token"))+ .and(body_string_contains(+ "refresh_token=synthetic-refresh-token",+ ))+ .respond_with(ResponseTemplate::new(400).set_body_json(json!({"error": "invalid_grant"})))+ .expect(1)+ .mount(&mcp_server)+ .await;+ let server_config: McpServerConfig = serde_json::from_value(json!({+ "url": server_url,+ "environment_id": DEFAULT_MCP_SERVER_ENVIRONMENT_ID,+ }))?;+ let credential_name = server_config.oauth_credential_name(server_name);+ let home = Arc::new(tempfile::tempdir()?);+ let _codex_home_guard = EnvVarGuard::set("CODEX_HOME", home.path().as_os_str());+ write_fallback_oauth_tokens(+ credential_name.as_ref(),+ &server_url,+ "test-client-id",+ "synthetic-access-token",+ "synthetic-refresh-token",+ OAuthCredentialExpiry::Expired,+ )+ .await?;+ // Another binary may have saved the same credential under a different computed key.+ let credentials_path = home.path().join(".credentials.json");+ let saved: serde_json::Map<String, serde_json::Value> =+ serde_json::from_slice(&std::fs::read(&credentials_path)?)?;+ let entry = saved.into_values().next().expect("seeded file entry");+ std::fs::write(+ &credentials_path,+ serde_json::to_vec(&json!({"!legacy-key": entry}))?,+ )?;+ let mut expected = stored_oauth_credentials(+ credential_name.as_ref(),+ &server_url,+ OAuthCredentialsStoreMode::File,+ AuthKeyringBackendKind::default(),+ )?+ .expect("seeded credentials");+ expected.token_response.0.set_refresh_token(None);++ // Rebuilding the agent must observe durable retirement, not retry the rejected token.+ for _ in 0..2 {+ let server_config = server_config.clone();+ let fixture = test_codex()+ .with_home(Arc::clone(&home))+ .with_config(move |config| {+ config+ .features+ .enable(Feature::McpOAuthRefreshCoordination)+ .expect("test config should allow coordinated OAuth refresh");+ config.mcp_oauth_credentials_store_mode = OAuthCredentialsStoreMode::File;+ config+ .mcp_servers+ .set([(server_name.to_string(), server_config)].into())+ .expect("test config should allow the OAuth server");+ })+ // The OAuth provider stays on the host when the executor is remote.+ .build_with_remote_and_local_env(&responses_server)+ .await?;+ let mut failures = Vec::new();+ wait_for_event(&fixture.codex, |event| {+ if let EventMsg::McpStartupUpdate(update) = event+ && update.server == server_name+ && let McpStartupStatus::Failed { reason, .. } = &update.status+ {+ failures.push(*reason);+ }+ matches!(event, EventMsg::McpStartupComplete(_))+ })+ .await;+ assert_eq!(+ failures,+ vec![Some(McpStartupFailureReason::ReauthenticationRequired)]+ );+ assert_eq!(+ stored_oauth_credentials(+ credential_name.as_ref(),+ &server_url,+ OAuthCredentialsStoreMode::File,+ AuthKeyringBackendKind::default(),+ )?,+ Some(expected.clone()),+ );+ fixture.codex.shutdown_and_wait().await?;+ }+ mcp_server.verify().await;+ Ok(())+}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn http_auth_challenge_reaches_agent_tool_call_events_without_replay() -> anyhow::Result<()> {skip_if_no_network!(Ok(()));diff --git a/codex-rs/rmcp-client/src/oauth.rs b/codex-rs/rmcp-client/src/oauth.rsindex a0773a768e..f80cd6eb47 100644--- a/codex-rs/rmcp-client/src/oauth.rs+++ b/codex-rs/rmcp-client/src/oauth.rs@@ -881,12 +881,14 @@ struct FallbackTokenEntry {fn load_oauth_tokens_from_file(server_name: &str, url: &str) -> Result<Option<StoredOAuthTokens>> {let _store_lock = OAuthStoreLock::acquire_for_read(OAuthStore::File)?;load_oauth_tokens_from_file_with_lock_held(server_name, url)+ .map(|entry| entry.map(|(_, tokens)| tokens))}+/// Retains the matched entry's key. The caller must hold the File aggregate-store lock.fn load_oauth_tokens_from_file_with_lock_held(server_name: &str,url: &str,-) -> Result<Option<StoredOAuthTokens>> {+) -> Result<Option<(String, StoredOAuthTokens)>> {let Some(store) = read_fallback_file_unlocked()? else {return Ok(None);};@@ -939,7 +941,7 @@ fn load_oauth_tokens_from_file_with_lock_held(};refresh_expires_in_from_timestamp(&mut stored);- return Ok(Some(stored));+ return Ok(Some((stored_key.clone(), stored)));}Ok(None)diff --git a/codex-rs/rmcp-client/src/oauth/credential_store.rs b/codex-rs/rmcp-client/src/oauth/credential_store.rsindex c191e6936a..d7e6bc5e90 100644--- a/codex-rs/rmcp-client/src/oauth/credential_store.rs+++ b/codex-rs/rmcp-client/src/oauth/credential_store.rs@@ -12,6 +12,9 @@//! so replacement logins still cause a rebuild.//! Synchronous store operations run off the Tokio workers so caller deadlines remain pollable.//! Blocking mutations retain the caller's transaction guard even if their await is cancelled.+//! Definitive refresh rejection removes only refresh capability, retaining the existing record+//! format and access token. Shared direct-keyring entries are retired only in this runtime until+//! cross-home locking exists. A local rejected snapshot also prevents reuse after a write failure.use std::sync::Arc;use std::sync::Weak;@@ -19,6 +22,7 @@ use std::sync::Weak;use anyhow::Context;use anyhow::Result;use codex_config::McpServerOAuthConfig;+use codex_config::types::AuthKeyringBackendKind;use codex_keyring_store::DefaultKeyringStore;use codex_keyring_store::KeyringStore;use futures::future::BoxFuture;@@ -42,6 +46,7 @@ use super::WrappedOAuthTokenResponse;use super::normalized_oauth_credentials;use super::refresh_expires_in_from_timestamp;use super::refresh_transaction::REFRESH_REQUEST_TIMEOUT;+use super::resolved_store::Backend;use super::token_needs_refresh;use super::validate_refresh_token_issuer;@@ -60,6 +65,7 @@ struct OAuthCredentialStoreInner<K> {keyring: K,oauth_config: Option<McpServerOAuthConfig>,last_credentials: Mutex<Option<StoredOAuthTokens>>,+ rejected_credentials: Mutex<Option<StoredOAuthTokens>>,refresh_guard: Mutex<Weak<RefreshCredentialLock>>,}@@ -80,6 +86,7 @@ impl<K: KeyringStore + Clone + 'static> OAuthCredentialStore<K> {keyring,oauth_config,last_credentials: Mutex::new(Some(tokens)),+ rejected_credentials: Mutex::new(None),refresh_guard: Mutex::new(Weak::new()),}),held_refresh_guard: None,@@ -146,6 +153,11 @@ impl<K: KeyringStore + Clone + 'static> OAuthCredentialStore<K> {.map_err(credential_store_error)?.map_err(credential_store_error)?.ok_or(AuthError::AuthorizationRequired)?;+ if normalized_oauth_credentials(Some(&tokens))+ == *self.inner.rejected_credentials.lock().await+ {+ return Err(AuthError::AuthorizationRequired);+ }self.validate_connection(&tokens)?;*self.inner.last_credentials.lock().await = Some(tokens);*self.inner.refresh_guard.lock().await = Arc::downgrade(&guard);@@ -288,6 +300,102 @@ impl<K: KeyringStore + Clone + 'static> CredentialStore for OAuthCredentialStore})}+ fn on_refresh_token_rejected<'life0, 'life1, 'async_trait>(+ &'life0 self,+ credentials: &'life1 StoredCredentials,+ ) -> BoxFuture<'async_trait, Result<(), AuthError>>+ where+ 'life0: 'async_trait,+ 'life1: 'async_trait,+ Self: 'async_trait,+ {+ Box::pin(async move {+ let guard = self+ .inner+ .refresh_guard+ .lock()+ .await+ .upgrade()+ .context("OAuth credential mutation requires an active refresh guard")+ .map_err(credential_store_error)?;+ let credentials = credentials.clone();+ let inner = Arc::clone(&self.inner);+ // Own both cache retirement and persistence: cancellation must not leave a reusable+ // cached token after the durable mutation, or release the guard before either finishes.+ tokio::spawn(async move {+ let Some(expected) =+ normalized_oauth_credentials(inner.last_credentials.lock().await.as_ref())+ else {+ return Ok(());+ };+ let mut attempted = credentials+ .token_response+ .ok_or(AuthError::AuthorizationRequired)?;+ attempted.set_expires_in(None);+ if credentials.client_id != expected.client_id+ || credentials.issuer != expected.issuer+ || WrappedOAuthTokenResponse(attempted) != expected.token_response+ {+ return Ok(());+ }+ *inner.rejected_credentials.lock().await = Some(expected.clone());+ let mut retired = expected.clone();+ retired.token_response.0.set_refresh_token(None);+ *inner.last_credentials.lock().await = Some(retired.clone());+ if inner.store.backend == Backend::Keyring(AuthKeyringBackendKind::Direct)+ && !inner.server_name.starts_with("ema-idp:")+ {+ // Ordinary direct-keyring entries are shared across CODEX_HOMEs, but their+ // refresh locks are not. Do not risk overwriting another home's newer login.+ // Enterprise entries include the home in their key and remain protected.+ warn!(+ server_name = %inner.server_name,+ "rejected MCP OAuth refresh token retired only in this connection; shared direct-keyring storage lacks cross-home coordination"+ );+ return Ok(());+ }+ let store_inner = Arc::clone(&inner);+ let result = tokio::task::spawn_blocking(move || -> Result<()> {+ let _guard = guard;+ // The aggregate-store transaction also excludes legacy persistors that+ // do not participate in the per-credential refresh guard.+ store_inner.store.retire_refresh_token_if_matches(+ &store_inner.keyring,+ &store_inner.server_name,+ &store_inner.url,+ &expected,+ )+ })+ .await+ .context("OAuth rejected credential mutation task failed")+ .map_err(credential_store_error)+ .and_then(|result| result.map_err(credential_store_error));+ // This task can outlive its caller, so report failures here without logging+ // backend error text that may contain credential material.+ if result.is_err() {+ warn!(+ server_name = %inner.server_name,+ "failed to persist rejected MCP OAuth refresh token retirement"+ );+ }+ result+ })+ .await+ // RMCP logs callback errors. Neither backend diagnostics nor task panic text+ // may cross that boundary, even though the owned task reports failure safely.+ .unwrap_or_else(|_| {+ Err(AuthError::CredentialStoreError(+ "OAuth rejection task failed".to_string(),+ ))+ })+ .map_err(|_| {+ AuthError::CredentialStoreError(+ "failed to retire rejected MCP OAuth refresh token".to_string(),+ )+ })+ })+ }+fn acquire_refresh_guard<'life0, 'async_trait>(&'life0 self,) -> BoxFuture<'async_trait, Result<Option<CredentialRefreshGuard>, AuthError>>diff --git a/codex-rs/rmcp-client/src/oauth/resolved_store.rs b/codex-rs/rmcp-client/src/oauth/resolved_store.rsindex bdd29b58f9..f141c9cd74 100644--- a/codex-rs/rmcp-client/src/oauth/resolved_store.rs+++ b/codex-rs/rmcp-client/src/oauth/resolved_store.rs@@ -24,8 +24,13 @@ use super::load_oauth_tokens_from_file;use super::load_oauth_tokens_from_file_with_lock_held;use super::load_oauth_tokens_from_keyring;use super::load_oauth_tokens_from_secrets_keyring_with_lock_held;+use super::normalized_oauth_credentials;+use super::read_fallback_file_unlocked;+use super::save_oauth_tokens_to_direct_keyring;use super::save_oauth_tokens_to_file;+use super::save_oauth_tokens_to_secrets_keyring_with_lock_held;use super::save_oauth_tokens_with_keyring;+use super::write_fallback_file;/// Concrete credential store resolved for one MCP OAuth client lifecycle.///@@ -129,6 +134,7 @@ impl ResolvedOAuthCredentialStore {Backend::File => {let _store_lock = OAuthStoreLock::try_acquire_for_read(OAuthStore::File)?;load_oauth_tokens_from_file_with_lock_held(server_name, url)+ .map(|entry| entry.map(|(_, tokens)| tokens)).context("failed to probe OAuth tokens from resolved file storage")}Backend::Keyring(AuthKeyringBackendKind::Direct) => {@@ -192,6 +198,105 @@ impl ResolvedOAuthCredentialStore {result}+ /// Retires a rejected refresh token only while its durable snapshot still matches.+ ///+ /// File and Secrets keep one exclusive aggregate lock across the comparison and write,+ /// including against legacy writers that do not take the caller's refresh guard. Direct+ /// keyring callers must hold that guard and use a home-scoped enterprise credential.+ pub(crate) fn retire_refresh_token_if_matches<K: KeyringStore + Clone + 'static>(+ self,+ keyring_store: &K,+ server_name: &str,+ url: &str,+ expected: &StoredOAuthTokens,+ ) -> Result<()> {+ let mut observation = telemetry::resolved(self, Operation::Load);+ let mut _store_lock = None;+ let mut file_key = None;+ let current = (|| -> Result<_> {+ _store_lock = match self.backend {+ Backend::File => Some(OAuthStoreLock::acquire_for_write(OAuthStore::File)?),+ Backend::Keyring(AuthKeyringBackendKind::Secrets) => {+ Some(OAuthStoreLock::acquire_for_write(OAuthStore::Secrets)?)+ }+ Backend::Keyring(AuthKeyringBackendKind::Direct) => None,+ };+ match self.backend {+ Backend::File => Ok(+ load_oauth_tokens_from_file_with_lock_held(server_name, url)?.map(+ |(key, tokens)| {+ file_key = Some(key);+ tokens+ },+ ),+ ),+ Backend::Keyring(AuthKeyringBackendKind::Secrets) => {+ load_oauth_tokens_from_secrets_keyring_with_lock_held(+ keyring_store,+ server_name,+ url,+ )+ .map_err(anyhow::Error::from)+ }+ Backend::Keyring(AuthKeyringBackendKind::Direct) => load_oauth_tokens_from_keyring(+ keyring_store,+ AuthKeyringBackendKind::Direct,+ server_name,+ url,+ )+ .map_err(anyhow::Error::from),+ }+ })();+ observation.record_load_attempt(telemetry::store(self), ¤t);+ if matches!(self.backend, Backend::Keyring(_))+ && let Err(error) = ¤t+ {+ telemetry::record_secure_error(&mut observation, error.as_ref());+ }+ drop(observation);+ let current = current?;+ if normalized_oauth_credentials(current.as_ref())+ != normalized_oauth_credentials(Some(expected))+ {+ return Ok(());+ }+ let mut retired = expected.clone();+ retired.token_response.0.set_refresh_token(None);+ let mut observation = telemetry::resolved(self, Operation::Save);+ let result = match self.backend {+ Backend::File => {+ let mut store = read_fallback_file_unlocked()?.context("OAuth file disappeared")?;+ // Reuse the key we compared: another binary may compute a different key.+ let key = file_key.context("missing loaded OAuth file key")?;+ store+ .get_mut(&key)+ .context("OAuth file entry disappeared")?+ .refresh_token = None;+ write_fallback_file(&store)+ }+ Backend::Keyring(AuthKeyringBackendKind::Secrets) => {+ let serialized =+ serde_json::to_string(&retired).context("failed to serialize OAuth tokens")?;+ save_oauth_tokens_to_secrets_keyring_with_lock_held(+ keyring_store,+ server_name,+ &retired,+ &serialized,+ )+ }+ Backend::Keyring(AuthKeyringBackendKind::Direct) => {+ save_oauth_tokens_to_direct_keyring(keyring_store, server_name, &retired)+ }+ };+ observation.record_save_attempt(telemetry::store(self), &result);+ if matches!(self.backend, Backend::Keyring(_))+ && let Err(error) = &result+ {+ telemetry::record_secure_error(&mut observation, error.as_ref());+ }+ result+ }+/// Deletes credentials only from this already-resolved authority.pub(crate) fn delete<K: KeyringStore + Clone + 'static>(self,diff --git a/codex-rs/rmcp-client/src/oauth/tests/credential_store_tests.rs b/codex-rs/rmcp-client/src/oauth/tests/credential_store_tests.rsindex 575ed835cd..02dc54a270 100644--- a/codex-rs/rmcp-client/src/oauth/tests/credential_store_tests.rs+++ b/codex-rs/rmcp-client/src/oauth/tests/credential_store_tests.rs@@ -25,6 +25,7 @@ use crate::oauth::compute_store_key;use crate::oauth::load_oauth_tokens_from_file;use crate::oauth::normalized_oauth_credentials;use crate::oauth::save_oauth_tokens_to_file;+use crate::oauth::save_oauth_tokens_to_file_with_lock_held;use crate::oauth::store_lock::OAuthStore;use crate::oauth::store_lock::OAuthStoreLock;@@ -289,3 +290,98 @@ async fn storage_roundtrip_preserves_absolute_and_unknown_expiry() -> Result<()>}Ok(())}++#[tokio::test(flavor = "current_thread")]+async fn cancelled_rejection_retains_guard_and_preserves_replacement() -> Result<()> {+ let _env = TempCodexHome::new();+ let initial = sample_tokens();+ save_oauth_tokens_to_file(&initial)?;+ let store = OAuthCredentialStore::new(+ initial.clone(),+ ResolvedOAuthCredentialStore::file(),+ MockKeyringStore::default(),+ /*oauth_config*/ None,+ );+ let credentials = store.load().await?.unwrap();+ assert!(matches!(+ store.on_refresh_token_rejected(&credentials).await,+ Err(AuthError::CredentialStoreError(error)) if error.contains("active refresh guard")+ ));+ let guard = store.acquire_transaction_guard().await?;+ let aggregate_lock = OAuthStoreLock::acquire_for_write(OAuthStore::File)?;+ let mut mutation = store.on_refresh_token_rejected(&credentials);+ assert!(futures::poll!(&mut mutation).is_pending());+ drop(mutation);+ drop(guard);+ let mut contender = Box::pin(RefreshCredentialLock::acquire_for_server(+ &initial.server_name,+ &initial.url,+ ));+ assert!(futures::poll!(&mut contender).is_pending());+ let mut replacement = initial.clone();+ replacement+ .token_response+ .0+ .set_refresh_token(Some(RefreshToken::new("replacement-refresh".into())));+ // A legacy writer may finish while retirement is waiting for the aggregate lock.+ save_oauth_tokens_to_file_with_lock_held(&replacement)?;+ drop(aggregate_lock);+ let _guard = tokio::time::timeout(Duration::from_secs(/*secs*/ 5), contender).await??;+ let mut expected = initial.clone();+ expected.token_response.0.set_refresh_token(None);+ let durable = load_oauth_tokens_from_file(&initial.server_name, &initial.url)?.unwrap();+ assert_tokens_match_without_expiry(&durable, &replacement);+ assert_eq!(+ store.stored_credentials().await,+ normalized_oauth_credentials(Some(&expected))+ );+ Ok(())+}++#[tokio::test(flavor = "current_thread")]+async fn keyring_rejection_respects_credential_scope() -> Result<()> {+ for kind in [+ AuthKeyringBackendKind::Direct,+ AuthKeyringBackendKind::Secrets,+ ] {+ let _env = TempCodexHome::new();+ let initial = sample_tokens();+ let keyring = MockKeyringStore::default();+ let authority = ResolvedOAuthCredentialStore::keyring(kind);+ authority.save(&keyring, &initial.server_name, &initial)?;+ let store = OAuthCredentialStore::new(+ initial.clone(),+ authority,+ keyring.clone(),+ /*oauth_config*/ None,+ );+ let guard = store.acquire_transaction_guard().await?;+ store+ .on_refresh_token_rejected(&store.load().await?.unwrap())+ .await?;+ let mut retired = initial.clone();+ retired.token_response.0.set_refresh_token(None);+ let expected_durable = match kind {+ AuthKeyringBackendKind::Direct => &initial,+ AuthKeyringBackendKind::Secrets => &retired,+ };+ assert_tokens_match_without_expiry(+ &authority+ .load(&keyring, &initial.server_name, &initial.url)?+ .unwrap(),+ expected_durable,+ );+ assert_eq!(+ store.stored_credentials().await,+ normalized_oauth_credentials(Some(&retired))+ );+ drop(guard);+ if kind == AuthKeyringBackendKind::Direct {+ assert!(matches!(+ store.acquire_transaction_guard().await,+ Err(AuthError::AuthorizationRequired)+ ));+ }+ }+ Ok(())+}diff --git a/codex-rs/rmcp-client/src/oauth/tests/persistor_tests.rs b/codex-rs/rmcp-client/src/oauth/tests/persistor_tests.rsindex e938bcec48..a8b2eb499e 100644--- a/codex-rs/rmcp-client/src/oauth/tests/persistor_tests.rs+++ b/codex-rs/rmcp-client/src/oauth/tests/persistor_tests.rs@@ -29,6 +29,7 @@ use tracing::Subscriber;use tracing::span::Attributes;use tracing::span::Record;use tracing::subscriber::Interest;+use tracing_test::traced_test;use wiremock::Mock;use wiremock::MockServer;use wiremock::ResponseTemplate;@@ -53,6 +54,7 @@ use crate::oauth::compute_expires_at_millis;use crate::oauth::compute_store_key;use crate::oauth::delete_oauth_tokens;use crate::oauth::load_oauth_tokens_from_file;+use crate::oauth::normalized_oauth_credentials;use crate::oauth::refresh_lock::RefreshCredentialLock;use crate::oauth::save_oauth_tokens;use crate::oauth::save_oauth_tokens_to_file;@@ -465,6 +467,58 @@ async fn rejected_refresh_token_requires_reauthorization() -> Result<()> {Ok(())}+#[tokio::test(flavor = "current_thread")]+#[traced_test]+async fn rejection_callback_failure_keeps_reauthentication_and_redacts_diagnostics() -> Result<()> {+ let (env, server, initial) = test_context().await?;+ save_oauth_tokens_to_file(&initial)?;+ let (auth_manager, store) = coordinated_manager_for(&initial).await?;+ let credentials_path = env.path().join(".credentials.json");+ Mock::given(method("POST"))+ .and(path("/oauth/token"))+ .respond_with(move |_: &wiremock::Request| {+ // The provider rejects after the guarded reread. Make retirement fail with a+ // deserialization error containing a sentinel credential value.+ std::fs::write(+ &credentials_path,+ r#"{"invalid-entry":"credential-backend-secret"}"#,+ )+ .expect("corrupt the synthetic credential store");+ ResponseTemplate::new(400).set_body_json(serde_json::json!({"error": "invalid_grant"}))+ })+ .expect(1)+ .mount(&server)+ .await;+ let error = OAuthRuntime::Coordinated {+ auth_manager,+ store: store.clone(),+ }+ .refresh_if_needed()+ .await+ .expect_err("rejected credentials must still require reauthentication");+ assert!(is_authentication_required_error(&error));+ let mut expected = initial.clone();+ expected.token_response.0.set_refresh_token(None);+ assert_eq!(+ store.stored_credentials().await,+ normalized_oauth_credentials(Some(&expected))+ );+ assert!(logs_contain(+ "failed to persist rejected MCP OAuth refresh token retirement"+ ));+ assert!(logs_contain("Failed to handle rejected refresh token"));+ assert!(!logs_contain("credential-backend-secret"));+ // A failed durable retirement must not let this runtime reuse the same credential.+ std::fs::remove_file(env.path().join(".credentials.json"))?;+ save_oauth_tokens_to_file(&initial)?;+ assert!(matches!(+ store.acquire_transaction_guard().await,+ Err(AuthError::AuthorizationRequired)+ ));+ server.verify().await;+ Ok(())+}+#[tokio::test(flavor = "current_thread")]async fn changed_issuer_requires_reauthorization_before_refresh() -> Result<()> {let (_env, server, mut initial) = test_context().await?;