Lightweight coding agent that runs in your terminal
Rust
Add explicit gateway login control and authentication status (#47170)
alexsong-oaif4389de2790a
diff --git a/codex-rs/login/BUILD.bazel b/codex-rs/login/BUILD.bazelindex 561176b3ed..78eea8c3dc 100644--- a/codex-rs/login/BUILD.bazel+++ b/codex-rs/login/BUILD.bazel@@ -8,5 +8,9 @@ codex_rust_crate("src/assets/success_legacy.html",],crate_name = "codex_login",+ test_shard_counts = {+ # Gateway credential tests exercise real encryption and run serially on Windows.+ "login-unit-tests": 4,+ },unit_test_timeout = "long",)diff --git a/codex-rs/login/src/gateway_auth.rs b/codex-rs/login/src/gateway_auth.rsindex bf9842a80d..00871113ed 100644--- a/codex-rs/login/src/gateway_auth.rs+++ b/codex-rs/login/src/gateway_auth.rs@@ -1,4 +1,4 @@-//! Owns gateway credentials and coordinates refresh and browser login through shared OAuth operations.+//! Owns gateway credentials, token refresh, and policy-controlled browser authorization.//! Credential I/O runs off the async worker and writes retain the store lock through cancellation.//! Rotated credentials survive caller cancellation and remain pending until persistence succeeds.@@ -34,11 +34,18 @@ use url::Url;#[path = "gateway_auth_callback.rs"]mod callback;+#[path = "gateway_auth_login.rs"]+mod login;#[path = "gateway_auth_storage.rs"]mod storage;#[path = "gateway_auth_token.rs"]mod token;+pub use login::GatewayAuthStatus;+pub use login::GatewayAuthStatusChange;+pub use login::GatewayLoginControl;+pub use login::subscribe_gateway_auth_status;+use callback::CallbackListener;use storage::GatewayAuthStorage;use token::StoredToken;@@ -47,6 +54,15 @@ use token::TokenResponse;const REFRESH_SKEW_SECONDS: i64 = 30;const HTTP_TIMEOUT: Duration = Duration::from_secs(/*secs*/ 20);+/// Gateway authentication states that require user action rather than request retries.+#[derive(Clone, Copy, Debug, PartialEq, Eq, thiserror::Error)]+pub enum GatewayAuthError {+ #[error("Gateway sign-in required. Choose Sign in or Reconnect, then retry your request")]+ LoginRequired,+ #[error("Gateway authentication is in progress; retry after sign-in")]+ LoginInProgress,+}+/// Public-client OAuth settings for a model provider.#[derive(Clone, PartialEq, Eq)]pub struct GatewayAuthConfig {@@ -61,6 +77,7 @@ pub struct GatewayAuthConfig {/// Resolves and persists an OAuth access token for a model provider.#[derive(Clone)]pub struct GatewayAuthManager {+ control: Arc<GatewayLoginControl>,state: Arc<GatewayAuthState>,}@@ -83,7 +100,7 @@ impl RefreshPolicy {enum RefreshOutcome {AccessToken(String),- Authorize,+ LoginRequired,}struct GatewayAuthState {@@ -92,14 +109,20 @@ struct GatewayAuthState {storage: GatewayAuthStorage,http_client: HttpClient,cached_token: Arc<Mutex<GatewayAuthCache>>,+ // Reserve explicit login independently of background credential reads and refreshes.+ login_attempt: Arc<Mutex<()>>,+ status: tokio::sync::watch::Sender<Option<login::GatewayAuthStatusSnapshot>>,+ status_tx: tokio::sync::broadcast::Sender<GatewayAuthStatusChange>,}-#[derive(Default)]+#[derive(Clone, Default, PartialEq, Eq)]struct GatewayAuthCache {token: Option<StoredToken>,// Retain rotated credentials across a failed save. The prior persisted token remains// available for comparison so retrying cannot overwrite a newer external login.pending: Option<StoredToken>,+ // A failed recovery requires replacement credentials, even before local expiry.+ login_required: Option<StoredToken>,}impl GatewayAuthManager {@@ -121,57 +144,121 @@ impl GatewayAuthManager {).map_err(|_| io::Error::other("failed to create provider OAuth HTTP client"))?;Ok(Self {+ control: GatewayLoginControl::for_host(&codex_home, http_client_factory),state: Arc::new(GatewayAuthState {config,+ status_tx: login::status_sender_for_host(&codex_home, http_client_factory),storage: GatewayAuthStorage::new(codex_home.clone(), keyring),codex_home,http_client,cached_token: Arc::new(Mutex::new(GatewayAuthCache::default())),+ login_attempt: Arc::new(Mutex::new(())),+ status: tokio::sync::watch::channel(/*init*/ None).0,}),})}- /// Returns a cached access token or refreshes/authorizes when it is no longer usable.+ /// Returns a usable token, refreshing or starting browser login according to the host policy.pub async fn resolve_access_token(&self) -> io::Result<String> {- self.resolve(RefreshPolicy::WhenExpired).await+ self.resolve_with_browser(RefreshPolicy::WhenExpired, login::open_browser)+ .await}/// Recovers after a request rejects `rejected_access_token`, reusing a usable replacement- /// from storage or refreshing/authorizing when necessary. Pass the access token used by the- /// failed request; callers must bound retries and decide whether the request is safe to replay.+ /// from storage or refreshing/authorizing according to the host policy.+ /// Pass the token used by the failed request; callers must bound retries and decide+ /// whether the request is safe to replay.pub async fn refresh_access_token(&self, rejected_access_token: &str) -> io::Result<String> {- self.resolve(RefreshPolicy::AfterRejection(- rejected_access_token.to_owned(),- ))+ self.resolve_with_browser(+ RefreshPolicy::AfterRejection(rejected_access_token.to_owned()),+ login::open_browser,+ ).await}- async fn resolve(&self, policy: RefreshPolicy) -> io::Result<String> {+ async fn resolve_with_browser(+ &self,+ policy: RefreshPolicy,+ open_browser: impl FnOnce(&Url),+ ) -> io::Result<String> {validate_config(&self.state.config)?;- let mut cached = Arc::clone(&self.state.cached_token).lock_owned().await;- if cached.token.is_none() && cached.pending.is_none() {+ let mut cached = self.lock_cached_token().await?;+ let terminal_status = self.state.status.borrow().as_ref().is_some_and(|snapshot| {+ matches!(+ snapshot.status,+ GatewayAuthStatus::NotReady | GatewayAuthStatus::Failed { .. }+ )+ });+ // A cached token may predate the failed login. Only persisted replacements can clear it.+ if cached.pending.is_none()+ && (cached.token.is_none() || terminal_status || cached.login_required.is_some())+ {cached.token = self.load_token_async().await?;}+ if cached.pending.is_none()+ && cached.login_required.is_some()+ && cached.token == cached.login_required+ {+ if !self+ .control+ .explicit_login+ .load(std::sync::atomic::Ordering::Relaxed)+ {+ return self.authorize_with_browser(&mut cached, open_browser).await;+ }+ return Err(self.login_required_error(cached.token.as_ref()));+ }if cached.pending.is_none()&& matches!(policy, RefreshPolicy::WhenExpired)&& let Some(token) = cached.token.as_ref()&& token_is_usable(token){- return Ok(token.access_token.clone());+ let terminal_matches = self.state.status.borrow().as_ref().is_some_and(|snapshot| {+ matches!(+ snapshot.status,+ GatewayAuthStatus::NotReady | GatewayAuthStatus::Failed { .. }+ ) && snapshot.credential.as_ref() == Some(token)+ });+ if !terminal_matches {+ self.publish_status(GatewayAuthStatus::Succeeded, Some(token));+ }+ let access_token = token.access_token.clone();+ cached.login_required = None;+ return Ok(access_token);}// The provider may rotate its token before the HTTP response arrives. Keep the// refresh, persistence, and cache update alive if the caller drops this future.let manager = self.clone();let (mut cached, result) = tokio::spawn(async move {- let result = manager.refresh(&mut cached, &policy).await;+ let result = match manager.refresh(&mut cached, &policy).await {+ Err(error) => Err(error),+ Ok(RefreshOutcome::AccessToken(access_token)) => {+ cached.login_required = None;+ manager.publish_status(GatewayAuthStatus::Succeeded, cached.token.as_ref());+ Ok(access_token)+ }+ Ok(RefreshOutcome::LoginRequired) => {+ cached.login_required = cached.token.clone();+ Err(manager.login_required_error(cached.token.as_ref()))+ }+ };(cached, result)}).await.map_err(|_| io::Error::other("provider OAuth refresh task failed"))?;- match result? {- RefreshOutcome::AccessToken(access_token) => Ok(access_token),- RefreshOutcome::Authorize => self.authorize(&mut cached).await,+ if result.as_ref().is_err_and(|error| {+ error+ .get_ref()+ .and_then(|source| source.downcast_ref::<GatewayAuthError>())+ == Some(&GatewayAuthError::LoginRequired)+ }) && !self+ .control+ .explicit_login+ .load(std::sync::atomic::Ordering::Relaxed)+ {+ return self.authorize_with_browser(&mut cached, open_browser).await;}+ result}async fn persist_pending(@@ -196,6 +283,7 @@ impl GatewayAuthManager {.map_err(|_| io::Error::other("provider OAuth credential save task failed"))??;let access_token = token.access_token.clone();cached.token = cached.pending.take();+ cached.login_required = None;Ok(access_token)}@@ -253,7 +341,7 @@ impl GatewayAuthManager {) =>{// Some public clients receive refresh tokens despite being unable to use- // that grant. Reauthorize after explicit rejection without disabling refresh.+ // that grant. Require browser login after rejection without disabling refresh.// Also recover updates from clients that predate the credential lock.if self.load_token_async().await? == cached.token {break;@@ -279,7 +367,7 @@ impl GatewayAuthManager {return Ok(RefreshOutcome::AccessToken(token.access_token.clone()));}}- Ok(RefreshOutcome::Authorize)+ Ok(RefreshOutcome::LoginRequired)}fn credential_id(&self) -> String {@@ -327,16 +415,6 @@ impl GatewayAuthManager {self.state.storage.save(&self.credential_id(), &value)}- async fn authorize(&self, cached: &mut GatewayAuthCache) -> io::Result<String> {- self.authorize_with_browser(cached, |authorization_url| {- eprintln!("Authorize the model provider by opening this URL:\n{authorization_url}\n");- if webbrowser::open(authorization_url.as_str()).is_err() {- eprintln!("Browser launch failed; open the URL above manually.");- }- })- .await- }-async fn authorize_with_browser(&self,cached: &mut GatewayAuthCache,@@ -390,7 +468,9 @@ impl GatewayAuthManager {)})?;cached.pending = Some(response.into_stored(/*previous_refresh_token*/ None)?);- self.persist_pending(cached, &credential_lock).await+ let access_token = self.persist_pending(cached, &credential_lock).await?;+ self.publish_status(GatewayAuthStatus::Succeeded, cached.token.as_ref());+ Ok(access_token)}fn oauth(&self) -> OAuthClient<'_> {diff --git a/codex-rs/login/src/gateway_auth_login.rs b/codex-rs/login/src/gateway_auth_login.rsnew file mode 100644index 0000000000..d6840c3f44--- /dev/null+++ b/codex-rs/login/src/gateway_auth_login.rs@@ -0,0 +1,377 @@+//! Coordinates gateway login, readiness, and status notifications.+//! Reports login progress before credential I/O and success only after persistence.+//! Readiness I/O leaves the cache unlocked and preserves newer state.++use super::*;+use std::future::Future;+use std::sync::OnceLock;+use std::sync::atomic::AtomicBool;+use std::sync::atomic::Ordering;+use tokio::sync::OwnedMutexGuard;+use tokio::sync::broadcast;++/// Readiness and browser authorization progress for a gateway credential.+#[derive(Clone, Debug, PartialEq, Eq)]+pub enum GatewayAuthStatus {+ NotReady,+ Started,+ Succeeded,+ Failed { message: String },+}++// Keep terminal status tied to its credential and retain successful credential expiry for busy reads.+// Deliberately omit Debug: this snapshot contains credentials.+#[derive(Clone)]+pub(super) struct GatewayAuthStatusSnapshot {+ pub(super) status: GatewayAuthStatus,+ pub(super) credential: Option<StoredToken>,+}++/// A credential status change scoped to the configured OAuth account.+#[derive(Clone, Debug)]+pub struct GatewayAuthStatusChange {+ pub config: GatewayAuthConfig,+ pub status: GatewayAuthStatus,+}++/// Browser policy shared by gateway managers with the same home and network configuration.+#[derive(Debug)]+pub struct GatewayLoginControl {+ pub(super) explicit_login: AtomicBool,+ status_tx: broadcast::Sender<GatewayAuthStatusChange>,+}++impl GatewayLoginControl {+ /// Returns the control shared across this runtime's provider configurations.+ pub fn for_runtime(runtime: &crate::AuthRuntimeConfig) -> Arc<Self> {+ Self::for_host(+ &runtime.codex_home,+ runtime.auth_route_config.http_client_factory(),+ )+ }++ pub(super) fn for_host(codex_home: &std::path::Path, factory: &HttpClientFactory) -> Arc<Self> {+ type Controls = Vec<(PathBuf, HttpClientFactory, Arc<GatewayLoginControl>)>;+ static CONTROLS: OnceLock<std::sync::Mutex<Controls>> = OnceLock::new();+ let mut controls = CONTROLS+ .get_or_init(std::sync::Mutex::default)+ .lock()+ .unwrap_or_else(std::sync::PoisonError::into_inner);+ // Keep subscriptions alive between manager lifetimes, including before a gateway is configured.+ controls.retain(|(_, _, control)| {+ Arc::strong_count(control) > 1+ || control.status_tx.strong_count() > 1+ || control.status_tx.receiver_count() > 0+ });+ if let Some((_, _, control)) = controls+ .iter()+ .find(|(home, routes, _)| home == codex_home && routes == factory)+ {+ return Arc::clone(control);+ }+ let control = Arc::new(Self {+ explicit_login: AtomicBool::new(/*v*/ false),+ status_tx: broadcast::channel(/*capacity*/ 16).0,+ });+ controls.push((+ codex_home.to_path_buf(),+ factory.clone(),+ Arc::clone(&control),+ ));+ control+ }++ /// Requires caller-initiated browser login, including during app-server startup.+ pub fn require_explicit_login(&self) {+ self.explicit_login.store(/*val*/ true, Ordering::Relaxed);+ }++ /// Restores automatic browser authorization for legacy clients after initialization.+ pub fn allow_automatic_login(&self) {+ self.explicit_login.store(/*val*/ false, Ordering::Relaxed);+ }+}++/// Subscribes to gateway status changes for this home and network configuration.+/// The subscription also covers managers created after configuration changes.+pub fn subscribe_gateway_auth_status(+ runtime: &crate::AuthRuntimeConfig,+) -> broadcast::Receiver<GatewayAuthStatusChange> {+ GatewayLoginControl::for_runtime(runtime)+ .status_tx+ .subscribe()+}++pub(super) fn status_sender_for_host(+ codex_home: &std::path::Path,+ factory: &HttpClientFactory,+) -> broadcast::Sender<GatewayAuthStatusChange> {+ GatewayLoginControl::for_host(codex_home, factory)+ .status_tx+ .clone()+}++impl GatewayAuthManager {+ /// Returns the OAuth account configuration used to scope status notifications.+ pub fn config(&self) -> &GatewayAuthConfig {+ &self.state.config+ }++ /// Returns whether the status changed and a notification was published.+ pub(super) fn publish_status(+ &self,+ status: GatewayAuthStatus,+ credential: Option<&StoredToken>,+ ) -> bool {+ let credential = match status {+ GatewayAuthStatus::NotReady+ | GatewayAuthStatus::Failed { .. }+ | GatewayAuthStatus::Succeeded => credential.cloned(),+ GatewayAuthStatus::Started => None,+ };+ let mut changed = false;+ self.state.status.send_if_modified(|previous| {+ changed = previous+ .as_ref()+ .is_none_or(|previous| previous.status != status);+ if !changed+ && previous+ .as_ref()+ .is_some_and(|previous| previous.credential == credential)+ {+ return false;+ }+ *previous = Some(GatewayAuthStatusSnapshot {+ status: status.clone(),+ credential,+ });+ if changed {+ let _ = self.state.status_tx.send(GatewayAuthStatusChange {+ config: self.state.config.clone(),+ status: status.clone(),+ });+ }+ true+ });+ changed+ }++ pub(super) fn login_required_error(&self, credential: Option<&StoredToken>) -> io::Error {+ // Requests must re-prompt even after an earlier NotReady notification was dismissed.+ // Passive readiness reads continue to use the deduplicated publisher above.+ if !self.publish_status(GatewayAuthStatus::NotReady, credential) {+ let _ = self.state.status_tx.send(GatewayAuthStatusChange {+ config: self.state.config.clone(),+ status: GatewayAuthStatus::NotReady,+ });+ }+ io::Error::new(+ io::ErrorKind::PermissionDenied,+ GatewayAuthError::LoginRequired,+ )+ }++ pub(super) async fn lock_cached_token(&self) -> io::Result<OwnedMutexGuard<GatewayAuthCache>> {+ let mut status = self.state.status.subscribe();+ let lock = Arc::clone(&self.state.cached_token).lock_owned();+ tokio::pin!(lock);+ loop {+ if status+ .borrow_and_update()+ .as_ref()+ .is_some_and(|snapshot| snapshot.status == GatewayAuthStatus::Started)+ {+ return Err(io::Error::new(+ io::ErrorKind::WouldBlock,+ GatewayAuthError::LoginInProgress,+ ));+ }+ tokio::select! {+ biased;+ _ = status.changed() => {}+ guard = &mut lock => return Ok(guard),+ }+ }+ }++ /// Reads readiness without refreshing credentials, opening a browser, or waiting for login.+ pub async fn status(&self) -> io::Result<GatewayAuthStatus> {+ let manager = self.clone();+ tokio::task::spawn_blocking(move || manager.status_blocking())+ .await+ .map_err(|_| io::Error::other("provider OAuth readiness task failed"))?+ }++ fn status_blocking(&self) -> io::Result<GatewayAuthStatus> {+ let mut status_changes = self.state.status.subscribe();+ let previous_cache = {+ let Ok(cached) = self.state.cached_token.try_lock() else {+ return Ok(self.snapshot_status());+ };+ if status_changes+ .borrow_and_update()+ .as_ref()+ .is_some_and(|snapshot| snapshot.status == GatewayAuthStatus::Started)+ {+ return Ok(GatewayAuthStatus::Started);+ }+ cached.clone()+ };+ // Keyring I/O may stall even after the caller drops this readiness request.+ // Leave the cache available to inference and concurrent login/refresh work.+ let stored = self.load_token();+ let Ok(mut cached) = self.state.cached_token.try_lock() else {+ return Ok(self.snapshot_status());+ };+ if *cached != previous_cache+ || status_changes.has_changed().unwrap_or(/*default*/ true)+ {+ return Ok(self.snapshot_status());+ }+ let snapshot = status_changes.borrow().clone();+ let stored = stored?;+ let terminal = snapshot.as_ref().filter(|snapshot| {+ matches!(+ snapshot.status,+ GatewayAuthStatus::NotReady | GatewayAuthStatus::Failed { .. }+ )+ });+ if stored.as_ref().is_some_and(token_is_usable)+ && (cached.pending.is_none() || stored != cached.token)+ && stored != cached.login_required+ && terminal.is_none_or(|snapshot| stored != snapshot.credential)+ {+ // Only a persisted replacement supersedes a failed-save baseline or rejected token.+ cached.token = stored;+ cached.pending = None;+ cached.login_required = None;+ self.publish_status(GatewayAuthStatus::Succeeded, cached.token.as_ref());+ return Ok(GatewayAuthStatus::Succeeded);+ }+ if let Some(snapshot) = terminal {+ return Ok(snapshot.status.clone());+ }+ self.publish_status(GatewayAuthStatus::NotReady, stored.as_ref());+ Ok(GatewayAuthStatus::NotReady)+ }++ fn snapshot_status(&self) -> GatewayAuthStatus {+ let mut status = GatewayAuthStatus::NotReady;+ // Check and downgrade atomically so an expired observation cannot overwrite+ // a completed refresh or newly started login.+ self.state.status.send_if_modified(|snapshot| {+ let Some(snapshot) = snapshot else {+ return false;+ };+ let expired = snapshot.status == GatewayAuthStatus::Succeeded+ && !snapshot.credential.as_ref().is_some_and(token_is_usable);+ if expired {+ snapshot.status = GatewayAuthStatus::NotReady;+ let _ = self.state.status_tx.send(GatewayAuthStatusChange {+ config: self.state.config.clone(),+ status: GatewayAuthStatus::NotReady,+ });+ }+ status = snapshot.status.clone();+ expired+ });+ status+ }++ /// Starts browser authorization using a caller-provided URL handoff and cancellation future.+ /// Completion means the credential was saved and is visible to existing request consumers.+ pub async fn login_with_browser(+ &self,+ cancel: impl Future<Output = ()>,+ open_browser: impl FnOnce(&Url),+ ) -> io::Result<()> {+ validate_config(&self.state.config)?;+ let _login_attempt = Arc::clone(&self.state.login_attempt)+ .try_lock_owned()+ .map_err(|_| {+ io::Error::new(io::ErrorKind::WouldBlock, GatewayAuthError::LoginInProgress)+ })?;+ tokio::pin!(cancel);+ let mut cached = tokio::select! {+ biased;+ cached = Arc::clone(&self.state.cached_token).lock_owned() => cached,+ _ = &mut cancel => return Err(io::Error::new(+ io::ErrorKind::Interrupted,+ "Gateway sign-in was canceled",+ )),+ };+ let mut guard = LoginStatusGuard {+ manager: self,+ credential: cached.token.clone(),+ completed: false,+ };+ self.publish_status(GatewayAuthStatus::Started, /*credential*/ None);+ let result = tokio::select! {+ biased;+ _ = &mut cancel => Err(io::Error::new(io::ErrorKind::Interrupted, "Gateway sign-in was canceled")),+ result = async {+ // A blocking read may outlive cancellation; it must not retain the login locks.+ guard.credential = self.load_token_async().await?;+ self.authorize_with_browser(&mut cached, open_browser).await.map(|_| ())+ } => result,+ }+ .map_err(|error| {+ // Issuer errors may echo arbitrary credentials. Only retain safe text in the+ // returned error and shared status, which is broadcast and can be debug-printed.+ let message = if error.kind() == io::ErrorKind::Interrupted {+ "Gateway sign-in was canceled"+ } else {+ "Gateway sign-in failed; check the gateway configuration and credential store."+ };+ io::Error::new(error.kind(), message)+ });+ if result.is_ok() {+ // Success describes the newly saved credential, not the pre-login baseline.+ guard.credential = cached.token.clone();+ }+ guard.finish(&result);+ result+ }+}++struct LoginStatusGuard<'a> {+ manager: &'a GatewayAuthManager,+ credential: Option<StoredToken>,+ completed: bool,+}++impl LoginStatusGuard<'_> {+ fn finish<T>(&mut self, result: &io::Result<T>) {+ self.manager.publish_status(+ match result {+ Ok(_) => GatewayAuthStatus::Succeeded,+ Err(error) => GatewayAuthStatus::Failed {+ message: error.to_string(),+ },+ },+ self.credential.as_ref(),+ );+ self.completed = true;+ }+}++impl Drop for LoginStatusGuard<'_> {+ fn drop(&mut self) {+ if !self.completed {+ self.manager.publish_status(+ GatewayAuthStatus::Failed {+ message: "Gateway sign-in was canceled".to_string(),+ },+ self.credential.as_ref(),+ );+ }+ }+}++// The legacy CLI/TUI flow hands browser authorization directly to the user.+pub(super) fn open_browser(url: &Url) {+ eprintln!("Authorize the model provider by opening this URL:\n{url}\n");+ if webbrowser::open(url.as_str()).is_err() {+ eprintln!("Browser launch failed; open the URL above manually.");+ }+}diff --git a/codex-rs/login/src/gateway_auth_login_tests.rs b/codex-rs/login/src/gateway_auth_login_tests.rsnew file mode 100644index 0000000000..bb1e5a1319--- /dev/null+++ b/codex-rs/login/src/gateway_auth_login_tests.rs@@ -0,0 +1,520 @@+//! Explicit browser login shares credentials with request consumers and remains cancellable.++use super::*;+use crate::GatewayAuthError;+use crate::GatewayAuthStatus;+use pretty_assertions::assert_eq;+use tokio::sync::Notify;++#[tokio::test]+async fn status_subscriptions_survive_gateway_changes_and_are_isolated_by_home() {+ let server = MockServer::start().await;+ let home = tempfile::tempdir().unwrap();+ let runtime = crate::AuthRuntimeConfig {+ codex_home: home.path().to_path_buf(),+ auth_route_config: transport_default_auth_route_config(),+ };+ // Subscribe before any manager exists, as app-server does without gateway configuration.+ let mut events = crate::subscribe_gateway_auth_status(&runtime);+ crate::GatewayLoginControl::for_runtime(&runtime).require_explicit_login();+ let keyring = Arc::new(MockKeyringStore::default());+ let (other_manager, _other_home) = client(config(&server), keyring.clone());+ other_manager.resolve_access_token().await.unwrap_err();+ assert!(matches!(+ events.try_recv(),+ Err(tokio::sync::broadcast::error::TryRecvError::Empty)+ ));++ for client_id in ["first-gateway", "replacement-gateway"] {+ let mut gateway = config(&server);+ gateway.client_id = client_id.to_string();+ let manager = GatewayAuthManager::new(+ gateway.clone(),+ home.path().to_path_buf(),+ runtime.auth_route_config.http_client_factory(),+ keyring.clone(),+ )+ .unwrap();+ manager.resolve_access_token().await.unwrap_err();+ let event = tokio::time::timeout(Duration::from_secs(/*secs*/ 2), events.recv())+ .await+ .unwrap()+ .unwrap();+ assert_eq!(+ (event.config, event.status),+ (gateway, GatewayAuthStatus::NotReady)+ );+ // The next gateway must reach the same subscriber after the last manager is dropped.+ drop(manager);+ }+ assert!(server.received_requests().await.unwrap().is_empty());+}++#[tokio::test]+async fn cancel_releases_callback_while_reads_and_requests_stay_responsive() {+ let server = MockServer::start().await;+ let (manager, _home) = client(config(&server), Arc::new(MockKeyringStore::default()));+ let observer = manager.clone();+ let mut events = manager.state.status_tx.subscribe();+ let cancel = Notify::new();+ let (url_tx, url_rx) = tokio::sync::oneshot::channel();+ let login = manager.login_with_browser(cancel.notified(), |url| {+ let redirect = url+ .query_pairs()+ .find(|(key, _)| key == "redirect_uri")+ .unwrap()+ .1+ .into_owned();+ url_tx.send(url::Url::parse(&redirect).unwrap()).unwrap();+ });+ let check = async {+ let callback = url_rx.await.unwrap();+ assert_eq!(observer.status().await.unwrap(), GatewayAuthStatus::Started);+ assert_eq!(+ observer.resolve_access_token().await.unwrap_err().kind(),+ std::io::ErrorKind::WouldBlock+ );+ cancel.notify_one();+ callback+ };+ let (result, callback) = tokio::join!(login, check);+ assert_eq!(result.unwrap_err().kind(), std::io::ErrorKind::Interrupted);+ let failed = GatewayAuthStatus::Failed {+ message: "Gateway sign-in was canceled".to_string(),+ };+ assert_eq!(observer.status().await.unwrap(), failed);+ assert_eq!(+ events.recv().await.unwrap().status,+ GatewayAuthStatus::Started+ );+ assert_eq!(events.recv().await.unwrap().status, failed);+ tokio::time::timeout(Duration::from_secs(/*secs*/ 2), async {+ loop {+ if let Ok(listener) = TcpListener::bind(("127.0.0.1", callback.port().unwrap())) {+ break listener;+ }+ tokio::time::sleep(Duration::from_millis(/*millis*/ 10)).await;+ }+ })+ .await+ .unwrap();+}++#[tokio::test]+async fn credential_read_failure_finishes_login_status() {+ let server = MockServer::start().await;+ let (manager, home) = client(config(&server), Arc::new(MockKeyringStore::default()));+ let path = home.path().join("secrets/gateway_oauth.age");+ std::fs::create_dir_all(&path).unwrap();+ let mut events = manager.state.status_tx.subscribe();+ let error = manager+ .login_with_browser(std::future::pending(), |_| panic!("unexpected browser"))+ .await+ .unwrap_err();+ let message = "Gateway sign-in failed; check the gateway configuration and credential store.";+ assert_eq!(error.to_string(), message);+ assert_eq!(+ events.try_recv().unwrap().status,+ GatewayAuthStatus::Started+ );+ let failed = GatewayAuthStatus::Failed {+ message: message.into(),+ };+ assert_eq!(events.try_recv().unwrap().status, failed);+ std::fs::remove_dir(&path).unwrap();+ assert_eq!(manager.status().await.unwrap(), failed);+ let cancel = Notify::new();+ let error = manager+ .login_with_browser(cancel.notified(), |_| cancel.notify_one())+ .await+ .unwrap_err();+ assert_eq!(error.kind(), std::io::ErrorKind::Interrupted);+}++#[tokio::test]+async fn rejected_credentials_stay_not_ready_until_replaced() {+ let server = MockServer::start().await;+ let keyring = Arc::new(MockKeyringStore::default());+ let (manager, _home) = client(config(&server), keyring.clone());+ let mut events = manager.state.status_tx.subscribe();+ save_token(+ &manager,+ "rejected",+ Some("revoked-refresh"),+ Utc::now().timestamp() + 3600,+ );+ Mock::given(method("POST"))+ .and(path("/token"))+ .and(body_string_contains("grant_type=refresh_token"))+ .respond_with(+ ResponseTemplate::new(/*s*/ 400).set_body_json(json!({"error": "invalid_grant"})),+ )+ .expect(/*r*/ 1)+ .mount(&server)+ .await;+ assert_eq!(+ manager+ .refresh_access_token("rejected")+ .await+ .unwrap_err()+ .kind(),+ std::io::ErrorKind::PermissionDenied+ );+ assert_eq!(manager.status().await.unwrap(), GatewayAuthStatus::NotReady);+ assert_eq!(+ events.try_recv().unwrap().status,+ GatewayAuthStatus::NotReady+ );+ for _ in 0..2 {+ assert_eq!(+ manager.resolve_access_token().await.unwrap_err().kind(),+ std::io::ErrorKind::PermissionDenied+ );+ assert_eq!(+ events.try_recv().unwrap().status,+ GatewayAuthStatus::NotReady+ );+ assert_eq!(manager.status().await.unwrap(), GatewayAuthStatus::NotReady);+ assert!(matches!(+ events.try_recv(),+ Err(tokio::sync::broadcast::error::TryRecvError::Empty)+ ));+ }+ // Canceling a new login must not make the previously rejected credential reusable.+ manager+ .login_with_browser(std::future::ready(()), |_| panic!("unexpected browser"))+ .await+ .unwrap_err();+ assert_eq!(+ manager.resolve_access_token().await.unwrap_err().kind(),+ std::io::ErrorKind::PermissionDenied+ );+ save_token(+ &manager,+ "replacement",+ Some("new-refresh"),+ Utc::now().timestamp() + 3600,+ );+ assert_eq!(+ manager.status().await.unwrap(),+ GatewayAuthStatus::Succeeded+ );+ assert_eq!(manager.resolve_access_token().await.unwrap(), "replacement");++ // A rejected token with no refresh token also requires replacement credentials.+ save_token(+ &manager,+ "no-refresh",+ /*refresh_token*/ None,+ Utc::now().timestamp() + 3600,+ );+ assert_eq!(+ manager+ .refresh_access_token("no-refresh")+ .await+ .unwrap_err()+ .kind(),+ std::io::ErrorKind::PermissionDenied+ );+ assert_eq!(+ manager.resolve_access_token().await.unwrap_err().kind(),+ std::io::ErrorKind::PermissionDenied+ );+ Mock::given(method("POST"))+ .and(path("/token"))+ .and(body_string_contains("grant_type=authorization_code"))+ .respond_with(ResponseTemplate::new(/*s*/ 200).set_body_json(json!({+ "access_token": "signed-in", "expires_in": 3600,+ })))+ .expect(/*r*/ 1)+ .mount(&server)+ .await;+ manager+ .login_with_browser(std::future::pending(), complete_browser_authorization)+ .await+ .unwrap();+ let cache_lock = Arc::clone(&manager.state.cached_token).lock_owned().await;+ assert_eq!(+ manager.status().await.unwrap(),+ GatewayAuthStatus::Succeeded+ );+ drop(cache_lock);+ assert_eq!(manager.resolve_access_token().await.unwrap(), "signed-in");+}++#[tokio::test]+async fn dropping_login_clears_in_progress_status() {+ let server = MockServer::start().await;+ let (manager, _home) = client(config(&server), Arc::new(MockKeyringStore::default()));+ let observer = manager.clone();+ let (started_tx, started_rx) = tokio::sync::oneshot::channel();+ let login = tokio::spawn(async move {+ manager+ .login_with_browser(std::future::pending(), |_| {+ let _ = started_tx.send(());+ })+ .await+ });+ started_rx.await.unwrap();+ assert_eq!(observer.status().await.unwrap(), GatewayAuthStatus::Started);+ login.abort();+ assert!(login.await.unwrap_err().is_cancelled());+ assert_eq!(+ observer.status().await.unwrap(),+ GatewayAuthStatus::Failed {+ message: "Gateway sign-in was canceled".to_string()+ }+ );+}++#[tokio::test]+async fn expired_readiness_stays_not_ready_while_refresh_is_blocked() {+ for read_before_refresh in [false, true] {+ let server = MockServer::start().await;+ let (manager, home) = client(config(&server), Arc::new(MockKeyringStore::default()));+ let expired = StoredToken {+ access_token: "expired".into(),+ refresh_token: Some("refresh".into()),+ expires_at: Some(Utc::now().timestamp() - 1),+ };+ manager.save_token(&expired).unwrap();+ // Seed the last successful observation with a credential that has since expired.+ manager.publish_status(GatewayAuthStatus::Succeeded, Some(&expired));+ let mut events = manager.state.status_tx.subscribe();+ Mock::given(method("POST"))+ .and(path("/token"))+ .and(body_string_contains("grant_type=refresh_token"))+ .respond_with(ResponseTemplate::new(/*s*/ 200).set_body_json(json!({+ "access_token": "renewed", "expires_in": 3600,+ })))+ .expect(/*r*/ 1)+ .mount(&server)+ .await;+ if read_before_refresh {+ assert_eq!(manager.status().await.unwrap(), GatewayAuthStatus::NotReady);+ }+ // Block the real refresh on the cross-process store lock after it takes the cache lock.+ let store_lock = super::super::storage::lock_credentials(home.path())+ .await+ .unwrap();+ let refresh = manager.resolve_access_token();+ tokio::pin!(refresh);+ tokio::select! {+ result = &mut refresh => panic!("refresh unexpectedly completed: {result:?}"),+ ready = tokio::time::timeout(Duration::from_secs(/*secs*/ 5), async {+ while manager.state.cached_token.try_lock().is_ok() {+ tokio::task::yield_now().await;+ }+ }) => ready.expect("refresh holds cache lock"),+ }+ assert_eq!(manager.status().await.unwrap(), GatewayAuthStatus::NotReady);+ assert_eq!(manager.status().await.unwrap(), GatewayAuthStatus::NotReady);+ assert_eq!(+ events.try_recv().unwrap().status,+ GatewayAuthStatus::NotReady+ );+ assert!(matches!(+ events.try_recv(),+ Err(tokio::sync::broadcast::error::TryRecvError::Empty)+ ));+ assert!(server.received_requests().await.unwrap().is_empty());+ drop(store_lock);+ assert_eq!(refresh.await.unwrap(), "renewed");+ // A busy cache must still report a newly refreshed, unexpired credential as usable.+ let cache_lock = Arc::clone(&manager.state.cached_token).lock_owned().await;+ assert_eq!(+ manager.status().await.unwrap(),+ GatewayAuthStatus::Succeeded+ );+ drop(cache_lock);+ assert_eq!(+ events.try_recv().unwrap().status,+ GatewayAuthStatus::Succeeded+ );+ assert_eq!(+ manager.status().await.unwrap(),+ GatewayAuthStatus::Succeeded+ );+ }+}++#[tokio::test]+async fn external_credentials_recover_missing_and_failed_readiness() {+ let server = MockServer::start().await;+ for failed_login in [false, true] {+ let keyring = Arc::new(MockKeyringStore::default());+ let (manager, _home) = client(config(&server), keyring.clone());+ let expected = if failed_login {+ // The failed attempt starts with an existing usable token. It must not immediately+ // look successful again just because that same token is still on disk.+ save_token(+ &manager,+ "old",+ /*refresh_token*/ None,+ Utc::now().timestamp() + 3600,+ );+ assert_eq!(manager.resolve_access_token().await.unwrap(), "old");+ save_token(+ &manager,+ "baseline",+ /*refresh_token*/ None,+ Utc::now().timestamp() + 3600,+ );+ let cancel = Notify::new();+ manager+ .login_with_browser(cancel.notified(), |_| cancel.notify_one())+ .await+ .unwrap_err();+ GatewayAuthStatus::Failed {+ message: "Gateway sign-in was canceled".into(),+ }+ } else {+ manager.resolve_access_token().await.unwrap_err();+ GatewayAuthStatus::NotReady+ };+ assert_eq!(manager.status().await.unwrap(), expected);+ if failed_login {+ // An older cached token must not be mistaken for a new external login.+ assert_eq!(manager.resolve_access_token().await.unwrap(), "baseline");+ assert_eq!(manager.status().await.unwrap(), expected);+ }+ save_token(+ &manager,+ "expired",+ /*refresh_token*/ None,+ Utc::now().timestamp() - 1,+ );+ assert_eq!(manager.status().await.unwrap(), expected);+ save_token(+ &manager,+ "replacement",+ /*refresh_token*/ None,+ Utc::now().timestamp() + 3600,+ );+ if !failed_login {+ // A request may load the replacement before the next readiness read.+ assert_eq!(manager.resolve_access_token().await.unwrap(), "replacement");+ }+ assert_eq!(+ manager.status().await.unwrap(),+ GatewayAuthStatus::Succeeded+ );+ assert_eq!(manager.resolve_access_token().await.unwrap(), "replacement");+ }+ assert!(server.received_requests().await.unwrap().is_empty());+}++#[tokio::test]+async fn login_waits_for_background_credentials_and_can_cancel_while_queued() {+ let server = MockServer::start().await;+ let (manager, _home) = client(config(&server), Arc::new(MockKeyringStore::default()));+ for cancel_while_queued in [true, false] {+ // The credential mutex is also held by background resolution and refresh.+ let cache_lock = Arc::clone(&manager.state.cached_token).lock_owned().await;+ let cancel = tokio::sync::Notify::new();+ let (url_tx, mut url_rx) = tokio::sync::oneshot::channel();+ let login = manager.login_with_browser(cancel.notified(), |_| {+ let _ = url_tx.send(());+ });+ tokio::pin!(login);+ tokio::select! {+ biased;+ result = &mut login => panic!("login must wait for credentials: {result:?}"),+ _ = std::future::ready(()) => {}+ }+ assert!(matches!(+ url_rx.try_recv(),+ Err(tokio::sync::oneshot::error::TryRecvError::Empty)+ ));+ let duplicate = manager+ .login_with_browser(std::future::pending(), |_| panic!("duplicate browser"))+ .await+ .unwrap_err();+ assert_eq!(+ duplicate+ .get_ref()+ .and_then(|error| error.downcast_ref::<GatewayAuthError>())+ .copied(),+ Some(GatewayAuthError::LoginInProgress),+ );+ if cancel_while_queued {+ cancel.notify_one();+ let error = tokio::time::timeout(Duration::from_secs(/*secs*/ 2), &mut login)+ .await+ .unwrap()+ .unwrap_err();+ assert_eq!(error.kind(), std::io::ErrorKind::Interrupted);+ assert_eq!(manager.status().await.unwrap(), GatewayAuthStatus::NotReady);+ drop(cache_lock);+ } else {+ drop(cache_lock);+ let check = async {+ url_rx.await.unwrap();+ assert_eq!(manager.status().await.unwrap(), GatewayAuthStatus::Started);+ cancel.notify_one();+ };+ let (result, ()) = tokio::join!(login, check);+ assert_eq!(result.unwrap_err().kind(), std::io::ErrorKind::Interrupted);+ }+ }+ assert!(server.received_requests().await.unwrap().is_empty());+}++#[tokio::test]+async fn legacy_policy_authorizes_missing_and_rejected_credentials() {+ for reauthorize in [false, true] {+ let server = MockServer::start().await;+ let (manager, _home) = client(config(&server), Arc::new(MockKeyringStore::default()));+ if reauthorize {+ save_token(+ &manager,+ "rejected",+ Some("revoked"),+ Utc::now().timestamp() - 1,+ );+ Mock::given(method("POST"))+ .and(body_string_contains("grant_type=refresh_token"))+ .respond_with(+ ResponseTemplate::new(/*s*/ 400)+ .set_body_json(json!({"error": "invalid_grant"})),+ )+ .expect(/*r*/ 1)+ .mount(&server)+ .await;+ }+ Mock::given(method("POST"))+ .and(body_string_contains("grant_type=authorization_code"))+ .respond_with(+ ResponseTemplate::new(/*s*/ 200)+ .set_body_json(json!({"access_token": "signed-in"})),+ )+ .expect(/*r*/ 1)+ .mount(&server)+ .await;+ assert_eq!(+ manager+ .resolve_with_browser(super::super::RefreshPolicy::WhenExpired, |_| panic!(+ "explicit mode opened browser"+ ))+ .await+ .unwrap_err()+ .kind(),+ std::io::ErrorKind::PermissionDenied+ );+ manager.control.allow_automatic_login();+ assert_eq!(+ manager+ .resolve_with_browser(+ super::super::RefreshPolicy::WhenExpired,+ complete_browser_authorization+ )+ .await+ .unwrap(),+ "signed-in"+ );+ assert_eq!(+ manager.status().await.unwrap(),+ GatewayAuthStatus::Succeeded+ );+ }+}diff --git a/codex-rs/login/src/gateway_auth_storage_tests.rs b/codex-rs/login/src/gateway_auth_storage_tests.rsnew file mode 100644index 0000000000..0548940fb4--- /dev/null+++ b/codex-rs/login/src/gateway_auth_storage_tests.rs@@ -0,0 +1,204 @@+//! Login cancellation and readiness stay responsive during blocked credential reads.++use super::*;+use codex_keyring_store::CredentialStoreError;+use codex_keyring_store::KeyringStore;+use pretty_assertions::assert_eq;+use std::sync::Mutex;+use std::sync::atomic::AtomicBool;+use std::sync::atomic::Ordering;++#[derive(Debug)]+struct BlockingKeyring {+ inner: MockKeyringStore,+ async_thread: std::thread::ThreadId,+ check_thread: AtomicBool,+ gate: Mutex<+ Option<(+ tokio::sync::oneshot::Sender<()>,+ std::sync::mpsc::Receiver<()>,+ )>,+ >,+}++impl BlockingKeyring {+ fn check_thread(&self) {+ if self.check_thread.load(Ordering::Relaxed) {+ assert_ne!(std::thread::current().id(), self.async_thread);+ }+ }+}++impl KeyringStore for BlockingKeyring {+ fn load(&self, service: &str, account: &str) -> Result<Option<String>, CredentialStoreError> {+ self.check_thread();+ let gate = self.gate.lock().unwrap().take();+ if let Some((entered, release)) = gate {+ entered.send(()).unwrap();+ release+ .recv_timeout(Duration::from_secs(/*secs*/ 30))+ .unwrap();+ }+ self.inner.load(service, account)+ }++ fn save(&self, service: &str, account: &str, value: &str) -> Result<(), CredentialStoreError> {+ self.check_thread();+ self.inner.save(service, account, value)+ }++ fn delete(&self, service: &str, account: &str) -> Result<bool, CredentialStoreError> {+ self.check_thread();+ self.inner.delete(service, account)+ }+}++fn blocking_client() -> (GatewayAuthManager, tempfile::TempDir, Arc<BlockingKeyring>) {+ let home = tempfile::tempdir().unwrap();+ let keyring = Arc::new(BlockingKeyring {+ inner: MockKeyringStore::default(),+ async_thread: std::thread::current().id(),+ check_thread: AtomicBool::new(/*v*/ false),+ gate: Mutex::new(/*t*/ None),+ });+ let manager = GatewayAuthManager::new(+ loopback_config(),+ home.path().to_path_buf(),+ transport_default_auth_route_config().http_client_factory(),+ keyring.clone(),+ )+ .unwrap();+ (manager, home, keyring)+}++#[tokio::test]+async fn readiness_does_not_block_cached_requests_or_overwrite_newer_credentials() {+ let (manager, _home, keyring) = blocking_client();+ save_token(&manager, "old", /*refresh_token*/ None, i64::MAX);+ assert_eq!(manager.resolve_access_token().await.unwrap(), "old");+ keyring.check_thread.store(/*val*/ true, Ordering::Relaxed);+ let (entered_tx, entered_rx) = tokio::sync::oneshot::channel();+ let (release_tx, release_rx) = std::sync::mpsc::channel();+ *keyring.gate.lock().unwrap() = Some((entered_tx, release_rx));+ let observer = manager.clone();+ let readiness = tokio::spawn(async move { observer.status().await });+ tokio::time::timeout(Duration::from_secs(/*secs*/ 2), entered_rx)+ .await+ .unwrap()+ .unwrap();+ // The status read has captured the old encrypted file and is blocked in keyring I/O.+ assert_eq!(+ tokio::time::timeout(+ Duration::from_secs(/*secs*/ 2),+ manager.resolve_access_token()+ )+ .await+ .unwrap()+ .unwrap(),+ "old"+ );+ let writer = manager.clone();+ tokio::task::spawn_blocking(move || {+ save_token(+ &writer,+ "replacement",+ /*refresh_token*/ None,+ i64::MAX,+ );+ })+ .await+ .unwrap();+ assert_eq!(+ tokio::time::timeout(+ // Refresh decrypts the persisted replacement; only cached requests must be immediate.+ Duration::from_secs(/*secs*/ 10),+ manager.refresh_access_token("old"),+ )+ .await+ .unwrap()+ .unwrap(),+ "replacement"+ );+ release_tx.send(()).unwrap();+ assert_eq!(+ readiness.await.unwrap().unwrap(),+ crate::GatewayAuthStatus::Succeeded+ );+ assert_eq!(manager.resolve_access_token().await.unwrap(), "replacement");+}++#[tokio::test]+async fn cancel_during_keyring_read_releases_login_and_cached_credentials() {+ let (manager, _home, keyring) = blocking_client();+ save_token(&manager, "existing", /*refresh_token*/ None, i64::MAX);+ assert_eq!(manager.resolve_access_token().await.unwrap(), "existing");+ let mut events = manager.state.status_tx.subscribe();+ keyring.check_thread.store(/*val*/ true, Ordering::Relaxed);+ let (entered_tx, entered_rx) = tokio::sync::oneshot::channel();+ let (release_tx, release_rx) = std::sync::mpsc::channel();+ *keyring.gate.lock().unwrap() = Some((entered_tx, release_rx));+ let cancel = Arc::new(tokio::sync::Notify::new());+ let login_manager = manager.clone();+ let login_cancel = Arc::clone(&cancel);+ let login = tokio::spawn(async move {+ login_manager+ .login_with_browser(login_cancel.notified(), |_| panic!("unexpected browser"))+ .await+ });+ tokio::time::timeout(Duration::from_secs(/*secs*/ 2), entered_rx)+ .await+ .unwrap()+ .unwrap();+ let error = tokio::time::timeout(+ Duration::from_secs(/*secs*/ 2),+ manager.resolve_access_token(),+ )+ .await+ .expect("requests must not wait for login credential I/O")+ .unwrap_err();+ assert_eq!(+ error+ .get_ref()+ .and_then(|error| error.downcast_ref::<crate::GatewayAuthError>()),+ Some(&crate::GatewayAuthError::LoginInProgress),+ );+ assert_eq!(+ manager.status().await.unwrap(),+ crate::GatewayAuthStatus::Started+ );+ assert_eq!(+ events.try_recv().unwrap().status,+ crate::GatewayAuthStatus::Started+ );+ cancel.notify_one();+ let error = tokio::time::timeout(Duration::from_secs(/*secs*/ 2), login)+ .await+ .unwrap()+ .unwrap()+ .unwrap_err();+ assert_eq!(error.kind(), std::io::ErrorKind::Interrupted);+ assert_eq!(+ events.try_recv().unwrap().status,+ crate::GatewayAuthStatus::Failed {+ message: "Gateway sign-in was canceled".into(),+ }+ );+ // Both request consumers and a new login must proceed before the keyring read returns.+ assert_eq!(+ tokio::time::timeout(+ // Failed status makes the request reread and decrypt the stored credential.+ Duration::from_secs(/*secs*/ 10),+ manager.resolve_access_token()+ )+ .await+ .unwrap()+ .unwrap(),+ "existing"+ );+ let error = manager+ .login_with_browser(std::future::ready(()), |_| panic!("unexpected browser"))+ .await+ .unwrap_err();+ assert_eq!(error.kind(), std::io::ErrorKind::Interrupted);+ release_tx.send(()).unwrap();+}diff --git a/codex-rs/login/src/gateway_auth_tests.rs b/codex-rs/login/src/gateway_auth_tests.rsindex e3b2dd4b49..53a68e8383 100644--- a/codex-rs/login/src/gateway_auth_tests.rs+++ b/codex-rs/login/src/gateway_auth_tests.rs@@ -23,6 +23,12 @@ use super::StoredToken;use super::callback::CallbackListener;use crate::test_support::transport_default_auth_route_config;+#[path = "gateway_auth_login_tests.rs"]+mod login_tests;++#[path = "gateway_auth_storage_tests.rs"]+mod storage_tests;+fn client(config: GatewayAuthConfig,keyring: Arc<MockKeyringStore>,@@ -35,6 +41,7 @@ fn client(keyring,).expect("gateway auth manager");+ manager.control.require_explicit_login();(manager, home)}@@ -414,7 +421,13 @@ async fn query_credentials_are_not_exposed_by_echoed_errors_or_truncated_requestjson!({"error_description": format!("Unknown input: {secret}")}),),)- .expect(/*r*/ 1)+ .expect(+ if matches!(location, QueryLocation::AuthorizationEndpoint) {+ 2+ } else {+ 1+ },+ ).mount(&server).await;let mut oauth = config(&server);@@ -440,6 +453,27 @@ async fn query_credentials_are_not_exposed_by_echoed_errors_or_truncated_requestassert!(message.contains("returned HTTP 503"));assert!(message.contains("provider response details omitted"));assert!(!message.contains("query-secret"));+ if matches!(location, QueryLocation::AuthorizationEndpoint) {+ let mut events = manager.state.status_tx.subscribe();+ let error = manager+ .login_with_browser(std::future::pending(), complete_browser_authorization)+ .await+ .unwrap_err();+ let message =+ "Gateway sign-in failed; check the gateway configuration and credential store.";+ assert_eq!(error.to_string(), message);+ let failed = crate::GatewayAuthStatus::Failed {+ message: message.into(),+ };+ assert_eq!(manager.status().await.unwrap(), failed);+ assert_eq!(+ events.try_recv().unwrap().status,+ crate::GatewayAuthStatus::Started+ );+ let event = events.try_recv().unwrap();+ assert_eq!(event.status, failed);+ assert!(!format!("{error:?} {event:?}").contains("query-secret"));+ }}}@@ -644,36 +678,6 @@ async fn ignores_mismatched_callback_state_even_for_provider_errors() {);}-#[tokio::test]-async fn cancelled_callback_wait_releases_its_configured_port() {- let available_port = TcpListener::bind("127.0.0.1:0").expect("available callback port");- let port = available_port- .local_addr()- .expect("callback address")- .port();- drop(available_port);- let listener =- CallbackListener::new(Some(port), "expected-state".to_string()).expect("callback listener");-- let callback_wait = tokio::spawn(async move {- let mut listener = listener;- listener.wait().await- });- callback_wait.abort();- let _ = callback_wait.await;-- tokio::time::timeout(Duration::from_secs(/*secs*/ 2), async {- loop {- if TcpListener::bind(("127.0.0.1", port)).is_ok() {- break;- }- tokio::task::yield_now().await;- }- })- .await- .expect("cancelled callback released its listener");-}-#[tokio::test]async fn rejects_insecure_or_credentialed_endpoints() {let keyring = Arc::new(MockKeyringStore::default());@@ -707,86 +711,114 @@ fn accepts_ipv4_and_ipv6_loopback_endpoints() {}#[tokio::test]-async fn cancelled_refresh_still_persists_and_caches_rotated_credentials() {+async fn cancelled_refresh_still_records_rotated_or_rejected_credentials() {use tokio::io::AsyncBufReadExt;use tokio::io::AsyncReadExt;use tokio::io::AsyncWriteExt;- let listener = tokio::net::TcpListener::bind("127.0.0.1:0")- .await- .expect("token listener");- let endpoint = format!(- "http://{}/token",- listener.local_addr().expect("token address")- );- let (accepted, received) = tokio::sync::oneshot::channel();- let (release, response_ready) = tokio::sync::oneshot::channel();- let server = tokio::spawn(async move {- let (mut stream, _) = listener.accept().await.expect("token request");- let mut reader = tokio::io::BufReader::new(&mut stream);- let mut content_length = 0;- loop {- let mut line = String::new();- assert!(- reader.read_line(&mut line).await.expect("request header") > 0,- "incomplete request headers"- );- if line == "\r\n" {- break;- }- if let Some(length) = line.to_ascii_lowercase().strip_prefix("content-length:") {- content_length = length.trim().parse().expect("body length");- }- }- reader- .read_exact(&mut vec![0; content_length])+ for rejected in [false, true] {+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await- .expect("complete grant");- accepted.send(()).expect("provider accepted rotation");- response_ready- .await- .expect("caller cancelled before response");- let body =- json!({"access_token": "new-access", "refresh_token": "new-refresh"}).to_string();- stream+ .expect("token listener");+ let endpoint = format!(+ "http://{}/token",+ listener.local_addr().expect("token address")+ );+ let (accepted, received) = tokio::sync::oneshot::channel();+ let (release, response_ready) = tokio::sync::oneshot::channel();+ let server = tokio::spawn(async move {+ let (mut stream, _) = listener.accept().await.expect("token request");+ let mut reader = tokio::io::BufReader::new(&mut stream);+ let mut content_length = 0;+ loop {+ let mut line = String::new();+ assert!(+ reader.read_line(&mut line).await.expect("request header") > 0,+ "incomplete request headers"+ );+ if line == "\r\n" {+ break;+ }+ if let Some(length) = line.to_ascii_lowercase().strip_prefix("content-length:") {+ content_length = length.trim().parse().expect("body length");+ }+ }+ reader+ .read_exact(&mut vec![0; content_length])+ .await+ .expect("complete grant");+ accepted.send(()).expect("provider accepted rotation");+ response_ready+ .await+ .expect("caller cancelled before response");+ let (status, body) = if rejected {+ (+ "400 Bad Request",+ json!({"error": "invalid_grant"}).to_string(),+ )+ } else {+ (+ "200 OK",+ json!({"access_token": "new-access", "refresh_token": "new-refresh"})+ .to_string(),+ )+ };+ stream.write_all(format!(- "HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",+ "HTTP/1.1 {status}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",body.len()).as_bytes(),).await.expect("rotated credentials");- });- let keyring = Arc::new(MockKeyringStore::default());- let mut oauth = loopback_config();- oauth.token_url = endpoint;- let (manager, _home) = client(oauth, keyring.clone());- save_token(- &manager,- "old-access",- Some("old-refresh"),- Utc::now().timestamp() - 1,- );- let caller = manager.clone();- let task = tokio::spawn(async move { caller.resolve_access_token().await });- received.await.expect("accepted refresh");- task.abort();- assert!(task.await.expect_err("cancelled caller").is_cancelled());- release.send(()).expect("release response");- server.await.expect("token response task");- // Taking the same cache lock waits for the detached transaction to finish persisting.- let cached = manager.state.cached_token.lock().await;- let expected = json!({"access_token": "new-access", "refresh_token": "new-refresh"});- assert_eq!(- serde_json::to_value(cached.token.as_ref()).expect("cached token"),- expected- );- assert_eq!(- serde_json::to_value(manager.load_token().expect("persisted token"))- .expect("stored credential"),- expected- );+ });+ let keyring = Arc::new(MockKeyringStore::default());+ let mut oauth = loopback_config();+ oauth.token_url = endpoint;+ let (manager, _home) = client(oauth, keyring.clone());+ save_token(+ &manager,+ "old-access",+ Some("old-refresh"),+ Utc::now().timestamp() + 3600,+ );+ let caller = manager.clone();+ let task = tokio::spawn(async move { caller.refresh_access_token("old-access").await });+ received.await.expect("accepted refresh");+ task.abort();+ assert!(task.await.expect_err("cancelled caller").is_cancelled());+ release.send(()).expect("release response");+ server.await.expect("token response task");+ // Taking the same cache lock waits for the detached transaction to finish persisting.+ let cached = Arc::clone(&manager.state.cached_token).lock_owned().await;+ if rejected {+ drop(cached);+ assert_eq!(+ manager.status().await.unwrap(),+ crate::GatewayAuthStatus::NotReady+ );+ assert_eq!(+ manager.resolve_access_token().await.unwrap_err().kind(),+ std::io::ErrorKind::PermissionDenied+ );+ } else {+ let expected = json!({"access_token": "new-access", "refresh_token": "new-refresh"});+ assert_eq!(+ serde_json::to_value(cached.token.as_ref()).expect("cached token"),+ expected+ );+ assert_eq!(+ serde_json::to_value(manager.load_token().expect("persisted token"))+ .expect("stored credential"),+ expected+ );+ assert_eq!(+ manager.status().await.unwrap(),+ crate::GatewayAuthStatus::Succeeded+ );+ }+ }}#[tokio::test]@@ -824,7 +856,7 @@ async fn only_explicit_refresh_grant_rejections_request_reauthorization() {match (status, error_code) {(400, Some("invalid_grant" | "unauthorized_client" | "unsupported_grant_type")) => {- assert!(matches!(result, Ok(super::RefreshOutcome::Authorize)));+ assert!(matches!(result, Ok(super::RefreshOutcome::LoginRequired)));}_ => {let message = result@@ -889,7 +921,7 @@ async fn invalid_grant_recovers_external_credentials_with_a_bounded_retry() {.refresh(&mut cached, &super::RefreshPolicy::WhenExpired).await.expect("bounded recovery"),- super::RefreshOutcome::Authorize+ super::RefreshOutcome::LoginRequired));} else {let expected = if retry_status.is_some() {diff --git a/codex-rs/login/src/lib.rs b/codex-rs/login/src/lib.rsindex 931bd1657a..abbbf1d897 100644--- a/codex-rs/login/src/lib.rs+++ b/codex-rs/login/src/lib.rs@@ -76,4 +76,9 @@ pub use outbound_proxy::AuthRouteConfig;pub use token_data::TokenData;pub use gateway_auth::GatewayAuthConfig;+pub use gateway_auth::GatewayAuthError;pub use gateway_auth::GatewayAuthManager;+pub use gateway_auth::GatewayAuthStatus;+pub use gateway_auth::GatewayAuthStatusChange;+pub use gateway_auth::GatewayLoginControl;+pub use gateway_auth::subscribe_gateway_auth_status;diff --git a/codex-rs/model-provider/src/combined_auth.rs b/codex-rs/model-provider/src/combined_auth.rsindex d1cd2d3979..513d82836c 100644--- a/codex-rs/model-provider/src/combined_auth.rs+++ b/codex-rs/model-provider/src/combined_auth.rs@@ -8,6 +8,7 @@ use codex_api::AuthHeadersFuture;use codex_api::AuthProvider;use codex_api::AuthProviderFuture;use codex_api::SharedAuthProvider;+use codex_login::GatewayAuthError;use codex_login::GatewayAuthManager;use codex_model_provider_info::GatewayOAuthConfig;use codex_model_provider_info::GatewayOAuthDelivery;@@ -34,13 +35,19 @@ pub(crate) async fn compose_auth(.as_ref().map_err(|error| CodexErr::InvalidRequest(error.clone()))?;let token = manager.resolve_access_token().await.map_err(|error| {- // Issuer errors may echo arbitrary credentials from configured URLs. Keep the- // diagnostic safe and bounded for callers that return it as tool output.- std::io::Error::new(- error.kind(),- "Gateway OAuth authentication failed; check the gateway configuration and credential store.",- )- })?;+ if let Some(login_error) = error+ .get_ref()+ .and_then(|source| source.downcast_ref::<GatewayAuthError>())+ {+ return CodexErr::InvalidRequest(login_error.to_string());+ }+ // Issuer errors may echo arbitrary credentials from configured URLs. Keep the+ // diagnostic safe and bounded, preserving retries for transient failures.+ CodexErr::Io(std::io::Error::new(+ error.kind(),+ "Gateway OAuth authentication failed; check the gateway configuration and credential store.",+ ))+ })?;let (name, value) = gateway_header(config, &token)?;if resolved.auth.to_auth_headers().contains_key(&name) {return Err(CodexErr::InvalidRequest(diff --git a/codex-rs/model-provider/src/shared_state_tests.rs b/codex-rs/model-provider/src/shared_state_tests.rsindex 09caa4cf87..e58edd0ef8 100644--- a/codex-rs/model-provider/src/shared_state_tests.rs+++ b/codex-rs/model-provider/src/shared_state_tests.rs@@ -236,6 +236,7 @@ async fn gateway_refresh_preserves_primary_auth_and_hides_issuer_errors() {Ok(_) => panic!("issuer failure should fail auth"),Err(error) => error,};+ assert!(error.retry_delay(/*retry_count*/ 1).is_some());assert_eq!(error.to_string(),"Gateway OAuth authentication failed; check the gateway configuration and credential store."@@ -524,3 +525,60 @@ async fn gateway_setup_errors_are_reported_when_authentication_is_requested() {));assert!(server.received_requests().await.unwrap().is_empty());}++#[tokio::test]+async fn gateway_login_states_stop_request_retries() {+ let server = MockServer::start().await;+ let home = tempfile::tempdir().unwrap();+ let primary = AuthManager::from_auth_for_testing_with_home(+ CodexAuth::from_api_key("primary-token"),+ home.path().to_path_buf(),+ );+ let info = ModelProviderInfo {+ gateway_oauth: Some(GatewayOAuthConfig {+ authorization_url: format!("{}/authorize", server.uri()),+ token_url: format!("{}/token", server.uri()),+ client_id: "client".into(),+ resource: None,+ scopes: vec![],+ redirect_port: None,+ delivery: GatewayOAuthDelivery::Header {+ name: "x-gateway-auth".into(),+ scheme: "Bearer".into(),+ },+ }),+ ..ModelProviderInfo::create_openai_provider(Some(server.uri()))+ };+ let login_control = codex_login::GatewayLoginControl::for_runtime(&primary.runtime_config());+ login_control.require_explicit_login();+ let provider = create_model_provider(info, Some(primary));+ let gateway = provider.gateway_auth_manager().unwrap().unwrap();+ let error = provider.api_auth().await.err().expect("login required");+ assert_eq!(+ (error.to_string(), error.retry_delay(/*retry_count*/ 1)),+ (+ codex_login::GatewayAuthError::LoginRequired.to_string(),+ None+ ),+ );+ let cancel = tokio::sync::Notify::new();+ let (url_tx, url_rx) = tokio::sync::oneshot::channel();+ let login = gateway.login_with_browser(cancel.notified(), |_| {+ let _ = url_tx.send(());+ });+ let check = async {+ url_rx.await.unwrap();+ let error = provider.api_auth().await.err().expect("login in progress");+ assert_eq!(+ (error.to_string(), error.retry_delay(/*retry_count*/ 1)),+ (+ codex_login::GatewayAuthError::LoginInProgress.to_string(),+ None+ ),+ );+ cancel.notify_one();+ };+ let (result, ()) = tokio::join!(login, check);+ assert_eq!(result.unwrap_err().kind(), std::io::ErrorKind::Interrupted);+ assert!(server.received_requests().await.unwrap().is_empty());+}