Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
serialize Codex OAuth refresh
Raine Virta4178fdeecb30
diff --git a/src/providers/codex/auth/manager.rs b/src/providers/codex/auth/manager.rsindex 2226e14..89493ac 100644--- a/src/providers/codex/auth/manager.rs+++ b/src/providers/codex/auth/manager.rs@@ -1,5 +1,8 @@-use std::sync::{Arc, Mutex};-use std::time::{SystemTime, UNIX_EPOCH};+use std::sync::Arc;+#[cfg(test)]+use std::sync::Mutex;+use std::time::{Duration, SystemTime, UNIX_EPOCH};+use tokio::sync::Mutex as AsyncMutex;use super::constants::{CLIENT_ID, ISSUER, REFRESH_MARGIN_MS};use super::jwt::{TokenResponse, extract_account_id, validate_token_response};@@ -8,14 +11,30 @@ use crate::auth::AuthStorage;pub struct CodexAuthManager<S: AuthStorage<StoredAuth>> {pub store: CodexTokenStore<S>,- cached: Arc<Mutex<Option<StoredAuth>>>,+ #[cfg(test)]+ test_auth: Arc<Mutex<Option<StoredAuth>>>,+ refresh_lock: Arc<AsyncMutex<()>>,+ refresh_client: reqwest::Client,+ token_endpoint: String,}impl<S: AuthStorage<StoredAuth>> CodexAuthManager<S> {pub fn new(store: CodexTokenStore<S>) -> Self {+ Self::new_with_token_endpoint(store, format!("{ISSUER}/oauth/token"))+ }++ fn new_with_token_endpoint(store: CodexTokenStore<S>, token_endpoint: String) -> Self {Self {store,- cached: Arc::new(Mutex::new(None)),+ #[cfg(test)]+ test_auth: Arc::new(Mutex::new(None)),+ refresh_lock: Arc::new(AsyncMutex::new(())),+ refresh_client: reqwest::Client::builder()+ .connect_timeout(Duration::from_secs(15))+ .timeout(Duration::from_secs(30))+ .build()+ .expect("failed to create Codex OAuth refresh client"),+ token_endpoint,}}@@ -26,77 +45,89 @@ impl<S: AuthStorage<StoredAuth>> CodexAuthManager<S> {.as_millis() as u64}- pub fn get_auth(&self) -> Result<StoredAuth, anyhow::Error> {- let cached = {- let guard = self.cached.lock().map_err(|e| anyhow::anyhow!("{e}"))?;- guard.clone()- };- let stored = match cached {- Some(ref auth) => auth.clone(),- None => {- let loaded = self.store.load_auth()?;- match loaded {- Some(auth) => {- let mut guard = self.cached.lock().map_err(|e| anyhow::anyhow!("{e}"))?;- *guard = Some(auth.clone());- auth- }- None => {- anyhow::bail!("Not authenticated. Run: claude-code-proxy codex auth login");- }- }- }- };+ pub async fn get_auth(&self) -> Result<StoredAuth, anyhow::Error> {+ let stored = self.load_auth()?.ok_or_else(|| {+ anyhow::anyhow!("Not authenticated. Run: claude-code-proxy codex auth login")+ })?;if stored.expires > Self::now_ms() + REFRESH_MARGIN_MS {return Ok(stored);}- self.refresh_now(&stored)+ self.refresh(false, None).await}- pub fn force_refresh(&self) -> Result<StoredAuth, anyhow::Error> {- let stored = {- let guard = self.cached.lock().map_err(|e| anyhow::anyhow!("{e}"))?;- guard.clone()- };- let stored = match stored {- Some(auth) => auth,- None => {- let loaded = self.store.load_auth()?;- loaded.ok_or_else(|| anyhow::anyhow!("Not authenticated"))?- }- };- self.refresh_now(&stored)+ pub async fn force_refresh(&self, rejected_access: &str) -> Result<StoredAuth, anyhow::Error> {+ self.refresh(true, Some(rejected_access)).await+ }++ fn load_auth(&self) -> Result<Option<StoredAuth>, anyhow::Error> {+ #[cfg(test)]+ if let Some(auth) = self+ .test_auth+ .lock()+ .map_err(|e| anyhow::anyhow!("{e}"))?+ .clone()+ {+ return Ok(Some(auth));+ }++ self.store.load_auth()}- fn refresh_now(&self, current: &StoredAuth) -> Result<StoredAuth, anyhow::Error> {+ async fn refresh(+ &self,+ force: bool,+ rejected_access: Option<&str>,+ ) -> Result<StoredAuth, anyhow::Error> {+ let _refresh_guard = self.refresh_lock.lock().await;++ // Reload from durable storage after acquiring the single-flight lock.+ // Another request may have rotated and persisted the token while this+ // caller was waiting.+ let current = self+ .load_auth()?+ .ok_or_else(|| anyhow::anyhow!("Not authenticated"))?;++ if (!force && current.expires > Self::now_ms() + REFRESH_MARGIN_MS)+ || rejected_access.is_some_and(|access| current.access != access)+ {+ return Ok(current);+ }++ self.refresh_now(¤t).await+ }++ async fn refresh_now(&self, current: &StoredAuth) -> Result<StoredAuth, anyhow::Error> {if current.refresh.is_empty() {anyhow::bail!("No refresh token stored; re-authenticate");}- let client = reqwest::blocking::Client::new();let form = [("client_id", CLIENT_ID.to_string()),("grant_type", "refresh_token".to_string()),("refresh_token", current.refresh.clone()),];- let resp = client- .post(format!("{ISSUER}/oauth/token"))+ let resp = self+ .refresh_client+ .post(&self.token_endpoint).form(&form).send()+ .await.map_err(|e| anyhow::anyhow!("refresh network error: {e}"))?;let status = resp.status().as_u16();if status == 401 || status == 403 {+ if let Some(latest) = self.store.load_auth()?+ && latest != *current{- let mut guard = self.cached.lock().map_err(|e| anyhow::anyhow!("{e}"))?;- *guard = None;+ return Ok(latest);}- let _ = self.store.clear_auth();+ self.store.clear_auth()?;let err_msg = resp.text()+ .await.unwrap_or_else(|_| "Token refresh unauthorized".to_string());anyhow::bail!("{err_msg}");}@@ -107,6 +138,7 @@ impl<S: AuthStorage<StoredAuth>> CodexAuthManager<S> {let tokens: TokenResponse = resp.json()+ .await.map_err(|e| anyhow::anyhow!("failed to parse token response: {e}"))?;validate_token_response(&tokens)?;let account_id = extract_account_id(&tokens).or_else(|| current.account_id.clone());@@ -118,10 +150,6 @@ impl<S: AuthStorage<StoredAuth>> CodexAuthManager<S> {account_id,};self.store.save_auth(next.clone())?;- {- let mut guard = self.cached.lock().map_err(|e| anyhow::anyhow!("{e}"))?;- *guard = Some(next.clone());- }Ok(next)}@@ -139,37 +167,33 @@ impl<S: AuthStorage<StoredAuth>> CodexAuthManager<S> {account_id,};self.store.save_auth(auth.clone())?;- {- let mut guard = self.cached.lock().map_err(|e| anyhow::anyhow!("{e}"))?;- *guard = Some(auth.clone());- }Ok(auth)}- pub fn set_cached(&self, auth: StoredAuth) {- if let Ok(mut guard) = self.cached.lock() {+ #[cfg(test)]+ pub fn set_test_auth(&self, auth: StoredAuth) {+ if let Ok(mut guard) = self.test_auth.lock() {*guard = Some(auth);}}-- pub fn reset_cache(&self) {- if let Ok(mut guard) = self.cached.lock() {- *guard = None;- }- }}#[cfg(test)]mod tests {use super::*;use crate::auth::InMemoryAuthStore;+ use std::io::{Read, Write};+ use std::net::TcpListener;+ use std::sync::Arc;+ use std::sync::atomic::{AtomicUsize, Ordering};+ use std::thread;fn test_store() -> CodexTokenStore<InMemoryAuthStore<StoredAuth>> {CodexTokenStore::new(InMemoryAuthStore::new())}- #[test]- fn get_auth_returns_stored() {+ #[tokio::test]+ async fn get_auth_returns_stored() {let store = test_store();let auth = StoredAuth {access: "test_access".into(),@@ -179,22 +203,166 @@ mod tests {};store.save_auth(auth.clone()).unwrap();let manager = CodexAuthManager::new(store);- let result = manager.get_auth().unwrap();+ let result = manager.get_auth().await.unwrap();assert_eq!(result.access, "test_access");assert_eq!(result.account_id.as_deref(), Some("acct_1"));}- #[test]- fn get_auth_fails_when_no_auth() {+ #[tokio::test]+ async fn get_auth_fails_when_no_auth() {let store = test_store();let manager = CodexAuthManager::new(store);- assert!(manager.get_auth().is_err());+ assert!(manager.get_auth().await.is_err());assert!(manager.get_auth()+ .await.unwrap_err().to_string().contains("Not authenticated"));}++ #[tokio::test(flavor = "multi_thread")]+ async fn concurrent_expired_auth_refreshes_once() {+ let listener = TcpListener::bind("127.0.0.1:0").unwrap();+ let addr = listener.local_addr().unwrap();+ let refreshes = Arc::new(AtomicUsize::new(0));+ let server_refreshes = refreshes.clone();+ let server = thread::spawn(move || {+ let (mut stream, _) = listener.accept().unwrap();+ let mut request = [0u8; 4096];+ let read = stream.read(&mut request).unwrap();+ assert!(read > 0);+ assert!(String::from_utf8_lossy(&request[..read]).contains("refresh_token=stale"));+ server_refreshes.fetch_add(1, Ordering::SeqCst);++ let body = br#"{"access_token":"rotated","refresh_token":"rotated-refresh","expires_in":3600}"#;+ let response = format!(+ "HTTP/1.1 200 OK\r\ncontent-type: application/json\r\ncontent-length: {}\r\nconnection: close\r\n\r\n",+ body.len()+ );+ stream.write_all(response.as_bytes()).unwrap();+ stream.write_all(body).unwrap();+ });++ let store = test_store();+ store+ .save_auth(StoredAuth {+ access: "expired".into(),+ refresh: "stale".into(),+ expires: 0,+ account_id: Some("acct_1".into()),+ })+ .unwrap();+ let manager = Arc::new(CodexAuthManager::new_with_token_endpoint(+ store,+ format!("http://{addr}/oauth/token"),+ ));+ let (first, second) = tokio::join!(manager.get_auth(), manager.get_auth());+ let results = [first.unwrap(), second.unwrap()];+ server.join().unwrap();++ assert_eq!(refreshes.load(Ordering::SeqCst), 1);+ assert!(results.iter().all(|auth| auth.access == "rotated"));+ assert!(results.iter().all(|auth| auth.refresh == "rotated-refresh"));+ }++ #[tokio::test]+ async fn stale_401_reuses_already_rotated_auth() {+ let store = test_store();+ store+ .save_auth(StoredAuth {+ access: "rotated".into(),+ refresh: "rotated-refresh".into(),+ expires: u64::MAX,+ account_id: Some("acct_1".into()),+ })+ .unwrap();+ let manager = CodexAuthManager::new_with_token_endpoint(+ store,+ "http://127.0.0.1:1/should-not-be-called".into(),+ );++ let auth = manager.force_refresh("rejected").await.unwrap();+ assert_eq!(auth.access, "rotated");+ assert_eq!(auth.refresh, "rotated-refresh");+ }++ #[tokio::test]+ async fn unauthorized_refresh_preserves_changed_refresh_token() {+ let listener = TcpListener::bind("127.0.0.1:0").unwrap();+ let addr = listener.local_addr().unwrap();+ let backing = InMemoryAuthStore::new();+ let server_backing = backing.clone();+ let server = thread::spawn(move || {+ let (mut stream, _) = listener.accept().unwrap();+ let mut request = [0u8; 4096];+ assert!(stream.read(&mut request).unwrap() > 0);+ server_backing+ .save(StoredAuth {+ access: "same-access".into(),+ refresh: "replacement-refresh".into(),+ expires: u64::MAX,+ account_id: Some("acct_1".into()),+ })+ .unwrap();+ let body = b"rejected refresh token";+ let response = format!(+ "HTTP/1.1 401 Unauthorized\r\ncontent-length: {}\r\nconnection: close\r\n\r\n",+ body.len()+ );+ stream.write_all(response.as_bytes()).unwrap();+ stream.write_all(body).unwrap();+ });++ let store = CodexTokenStore::new(backing);+ store+ .save_auth(StoredAuth {+ access: "same-access".into(),+ refresh: "rejected-refresh".into(),+ expires: 0,+ account_id: Some("acct_1".into()),+ })+ .unwrap();+ let manager =+ CodexAuthManager::new_with_token_endpoint(store, format!("http://{addr}/oauth/token"));++ let auth = manager.get_auth().await.unwrap();+ server.join().unwrap();+ assert_eq!(auth.access, "same-access");+ assert_eq!(auth.refresh, "replacement-refresh");+ assert_eq!(manager.store.load_auth().unwrap(), Some(auth));+ }++ #[tokio::test]+ async fn durable_rotation_and_logout_are_observed_by_shared_manager() {+ let store = test_store();+ store+ .save_auth(StoredAuth {+ access: "first".into(),+ refresh: "first-refresh".into(),+ expires: u64::MAX,+ account_id: Some("acct_1".into()),+ })+ .unwrap();+ let manager = CodexAuthManager::new(store);+ assert_eq!(manager.get_auth().await.unwrap().access, "first");++ manager+ .store+ .save_auth(StoredAuth {+ access: "rotated".into(),+ refresh: "rotated-refresh".into(),+ expires: u64::MAX,+ account_id: Some("acct_2".into()),+ })+ .unwrap();+ let rotated = manager.get_auth().await.unwrap();+ assert_eq!(rotated.access, "rotated");+ assert_eq!(rotated.account_id.as_deref(), Some("acct_2"));++ manager.store.clear_auth().unwrap();+ assert!(manager.get_auth().await.is_err());+ }}diff --git a/src/providers/codex/client.rs b/src/providers/codex/client.rsindex 91d12cb..f55c412 100644--- a/src/providers/codex/client.rs+++ b/src/providers/codex/client.rs@@ -281,7 +281,7 @@ impl CodexHttpClient {use super::continuation::clear_continuation;use crate::config::CodexTransport;- let mut auth = self.auth_manager.get_auth().map_err(|e| CodexError {+ let mut auth = self.auth_manager.get_auth().await.map_err(|e| CodexError {status: 401,message: "Auth error".to_string(),detail: Some(e.to_string()),@@ -297,6 +297,7 @@ impl CodexHttpClient {super::websocket::invalidate_codex_websocket_pool_key(key);}+ let mut auth_refresh_attempted = false;for transport_attempt in 0..=3u32 {let result = match transport {CodexTransport::Http => {@@ -377,10 +378,14 @@ impl CodexHttpClient {}};- if should_refresh_after_unauthorized(&result, transport_attempt) {- match self.auth_manager.force_refresh() {+ if should_refresh_after_unauthorized(&result, auth_refresh_attempted) {+ auth_refresh_attempted = true;+ match self.auth_manager.force_refresh(&auth.access).await {Ok(new_auth) => {auth = new_auth;+ if let Some(key) = pool_key {+ super::websocket::invalidate_codex_websocket_pool_key(key);+ }continue;}Err(e) => {@@ -513,7 +518,7 @@ impl CodexHttpClient {ctx: &RequestContext,continuation: Option<&super::continuation::ContinuationCandidate>,) -> Result<super::websocket::CodexWebSocketEventReceiver, CodexError> {- let auth = self.auth_manager.get_auth().map_err(|e| CodexError {+ let auth = self.auth_manager.get_auth().await.map_err(|e| CodexError {status: 401,message: "Auth error".to_string(),detail: Some(e.to_string()),@@ -868,9 +873,9 @@ fn is_retryable_reqwest_error(err: &reqwest::Error) -> bool {fn should_refresh_after_unauthorized(result: &Result<CodexResponse, CodexError>,- transport_attempt: u32,+ auth_refresh_attempted: bool,) -> bool {- if transport_attempt != 0 {+ if auth_refresh_attempted {return false;}match result {@@ -1367,13 +1372,13 @@ mod tests {origin: CodexErrorOrigin::WebSocket,});- assert!(should_refresh_after_unauthorized(&http_unauthorized, 0));+ assert!(should_refresh_after_unauthorized(&http_unauthorized, false));assert!(should_refresh_after_unauthorized(&websocket_unauthorized,- 0+ false));- assert!(!should_refresh_after_unauthorized(&forbidden, 0));- assert!(!should_refresh_after_unauthorized(&http_unauthorized, 1));+ assert!(!should_refresh_after_unauthorized(&forbidden, false));+ assert!(!should_refresh_after_unauthorized(&http_unauthorized, true));}#[test]diff --git a/src/providers/codex/mod.rs b/src/providers/codex/mod.rsindex f641888..132f12a 100644--- a/src/providers/codex/mod.rs+++ b/src/providers/codex/mod.rs@@ -46,7 +46,9 @@ use self::translate::stream::translate_stream_bytes_with_traffic;// Provider// ----------------------------------------------------------------------------pub struct CodexProvider;+pub struct CodexProvider {+ client: Arc<CodexHttpClient>,+}impl Default for CodexProvider {fn default() -> Self {@@ -56,7 +58,9 @@ impl Default for CodexProvider {impl CodexProvider {pub fn new() -> Self {- Self+ Self {+ client: Arc::new(CodexHttpClient::new()),+ }}}@@ -132,7 +136,7 @@ impl Provider for CodexProvider {);// Post to upstream with continuation- let client = Arc::new(CodexHttpClient::new());+ let client = self.client.clone();if let Some(monitor) = ctx.monitor.as_ref() {monitor.upstream_started(&ctx.req_id);}