Skip to content

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.rs
index 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(&current).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.rs
index 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.rs
index 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);
}