Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
implement codex browser oauth and device auth with tests
Raine Virta827dd2261a33
diff --git a/Cargo.lock b/Cargo.lockindex bb31f48..8c69f00 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -308,10 +308,12 @@ dependencies = ["once_cell","predicates","prost",+ "rand 0.8.6","regex-lite","reqwest","serde","serde_json",+ "sha2","tempfile","thiserror 2.0.18","time",@@ -1539,6 +1541,17 @@ dependencies = ["digest",]+[[package]]+name = "sha2"+version = "0.10.9"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"+dependencies = [+ "cfg-if",+ "cpufeatures",+ "digest",+]+[[package]]name = "sharded-slab"version = "0.1.7"diff --git a/Cargo.toml b/Cargo.tomlindex 3034ef5..11b994d 100644--- a/Cargo.toml+++ b/Cargo.toml@@ -27,6 +27,8 @@ uuid = { version = "1", features = ["v4", "serde"] }time = { version = "0.3", features = ["formatting"] }reqwest = { version = "0.12", default-features = false, features = ["json", "stream", "rustls-tls", "blocking", "http2"] }base64 = "0.22"+rand = "0.8"+sha2 = "0.10"hostname = "0.4"once_cell = "1.20"regex-lite = "0.1"diff --git a/src/providers/codex/auth/browser_login.rs b/src/providers/codex/auth/browser_login.rsnew file mode 100644index 0000000..7b0cff2--- /dev/null+++ b/src/providers/codex/auth/browser_login.rs@@ -0,0 +1,586 @@+use std::collections::HashMap;+use std::io::{Read, Write};+use std::net::{TcpListener, TcpStream};+use std::time::Duration;++use super::constants::{ISSUER, OAUTH_PORT};+use super::jwt::TokenResponse;+use super::pkce::{+ PkceCodes, build_authorize_url, exchange_code_for_tokens, generate_pkce, generate_state,+};++const BROWSER_LOGIN_TIMEOUT: Duration = Duration::from_secs(300);++// ---------------------------------------------------------------------------+// Config+// ---------------------------------------------------------------------------++pub struct BrowserLoginConfig {+ pub issuer: String,+ pub port: u16,+ pub timeout: Duration,+}++impl BrowserLoginConfig {+ pub fn new(issuer: impl Into<String>) -> Self {+ Self {+ issuer: issuer.into(),+ port: OAUTH_PORT,+ timeout: BROWSER_LOGIN_TIMEOUT,+ }+ }++ fn redirect_uri(&self) -> String {+ format!("http://localhost:{}/auth/callback", self.port)+ }+}++// ---------------------------------------------------------------------------+// Query parsing helpers+// ---------------------------------------------------------------------------++fn parse_query(query: &str) -> HashMap<String, String> {+ let mut params = HashMap::new();+ for (key, value) in url::form_urlencoded::parse(query.as_bytes()) {+ params.insert(key.into_owned(), value.into_owned());+ }+ params+}++fn extract_request_path_and_query(stream: &mut TcpStream) -> Option<(String, String)> {+ let mut buf = [0; 4096];+ let n = stream.read(&mut buf).ok()?;+ let request = String::from_utf8_lossy(&buf[..n]);++ // Parse first line: GET /path?query HTTP/1.1+ let first_line = request.lines().next()?;+ let mut parts = first_line.split_whitespace();+ let _method = parts.next()?;+ let path_and_query = parts.next()?;++ let mut split = path_and_query.splitn(2, '?');+ let path = split.next().unwrap_or("").to_string();+ let query = split.next().unwrap_or("").to_string();++ Some((path, query))+}++fn write_response(stream: &mut TcpStream, status: u16, content_type: &str, body: &str) {+ let status_line = match status {+ 200 => "200 OK",+ 400 => "400 Bad Request",+ 404 => "404 Not Found",+ 500 => "500 Internal Server Error",+ _ => "500 Internal Server Error",+ };+ let response = format!(+ "HTTP/1.1 {status_line}\r\nContent-Length: {}\r\nContent-Type: {content_type}\r\nConnection: close\r\n\r\n{body}",+ body.len(),+ );+ let _ = stream.write_all(response.as_bytes());+ let _ = stream.flush();+}++// ---------------------------------------------------------------------------+// Main browser login flow+// ---------------------------------------------------------------------------++pub fn run_browser_login() -> Result<TokenResponse, anyhow::Error> {+ let config = BrowserLoginConfig::new(ISSUER);+ run_browser_login_with_config(&config)+}++pub fn run_browser_login_with_config(+ config: &BrowserLoginConfig,+) -> Result<TokenResponse, anyhow::Error> {+ let pkce = generate_pkce();+ let state = generate_state();+ let redirect_uri = config.redirect_uri();+ let auth_url = build_authorize_url(&config.issuer, &redirect_uri, &pkce, &state)?;++ let listener = TcpListener::bind(format!("127.0.0.1:{}", config.port))+ .map_err(|e| anyhow::anyhow!("Failed to bind to port {}: {e}", config.port))?;++ listener+ .set_nonblocking(true)+ .map_err(|e| anyhow::anyhow!("Failed to set non-blocking: {e}"))?;++ println!("Open this URL in your browser to authorize:\n\n {auth_url}\n");++ let deadline = std::time::Instant::now() + config.timeout;++ loop {+ if std::time::Instant::now() >= deadline {+ anyhow::bail!("OAuth timeout");+ }++ match listener.accept() {+ Ok((mut stream, _)) => {+ match handle_callback(&mut stream, &config.issuer, &redirect_uri, &pkce, &state) {+ Ok(tokens) => return Ok(tokens),+ Err(e) => return Err(e),+ }+ }+ Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {+ std::thread::sleep(Duration::from_millis(100));+ }+ Err(e) => {+ anyhow::bail!("Server error: {e}");+ }+ }+ }+}++fn handle_callback(+ stream: &mut TcpStream,+ issuer: &str,+ redirect_uri: &str,+ pkce: &PkceCodes,+ state: &str,+) -> Result<TokenResponse, anyhow::Error> {+ let (path, query) = match extract_request_path_and_query(stream) {+ Some(pair) => pair,+ None => {+ write_response(stream, 400, "text/plain", "Bad request");+ anyhow::bail!("Bad request");+ }+ };++ if path != "/auth/callback" {+ write_response(stream, 404, "text/plain", "Not found");+ anyhow::bail!("Not found");+ }++ let params = parse_query(&query);++ if let Some(error) = params.get("error") {+ write_response(stream, 400, "text/plain", &format!("Auth failed: {error}"));+ anyhow::bail!("{error}");+ }++ let code = match params.get("code") {+ Some(c) => c.clone(),+ None => {+ write_response(stream, 400, "text/plain", "Auth failed: Invalid callback");+ anyhow::bail!("Invalid callback");+ }+ };++ let received_state = params.get("state").cloned().unwrap_or_default();+ if received_state != state {+ write_response(stream, 400, "text/plain", "Auth failed: Invalid callback");+ anyhow::bail!("Invalid callback: state mismatch");+ }++ match exchange_code_for_tokens(issuer, &code, pkce, redirect_uri) {+ Ok(tokens) => {+ write_response(+ stream,+ 200,+ "text/html",+ "<html><body><h1>Authorization Successful</h1><p>You can close this window.</p></body></html>",+ );+ Ok(tokens)+ }+ Err(e) => {+ write_response(stream, 500, "text/plain", &e.to_string());+ Err(e)+ }+ }+}++// ---------------------------------------------------------------------------+// Tests+// ---------------------------------------------------------------------------++#[cfg(test)]+mod tests {+ use super::*;+ use std::sync::Arc;+ use std::sync::atomic::{AtomicBool, Ordering};++ /// A minimal TCP-based mock auth server for browser login tests.+ struct MockBrowserLoginAuthServer {+ url: String,+ #[allow(dead_code)]+ shutdown: Arc<AtomicBool>,+ }++ impl MockBrowserLoginAuthServer {+ fn new() -> Self {+ let shutdown = Arc::new(AtomicBool::new(false));+ let sd = shutdown.clone();+ let url: Arc<std::sync::Mutex<Option<String>>> = Arc::new(std::sync::Mutex::new(None));+ let url_clone = url.clone();++ std::thread::spawn(move || {+ let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("bind");+ let addr = listener.local_addr().unwrap();+ *url_clone.lock().unwrap() = Some(format!("http://{addr}"));++ listener.set_nonblocking(true).expect("nonblocking");++ loop {+ if sd.load(Ordering::Relaxed) {+ return;+ }+ match listener.accept() {+ Ok((mut stream, _)) => {+ let mut buf = [0; 4096];+ let n = match stream.read(&mut buf) {+ Ok(n) if n > 0 => n,+ _ => continue,+ };+ let request = String::from_utf8_lossy(&buf[..n]);++ let response = if request.contains("/oauth/token") {+ // Token exchange - return success+ let body = r#"{"access_token":"bt_at","refresh_token":"bt_rt","expires_in":3600,"id_token":"bt_id"}"#;+ format!(+ "HTTP/1.1 200 OK\r\nContent-Length: {}\r\nContent-Type: application/json\r\nConnection: close\r\n\r\n{body}",+ body.len()+ )+ } else {+ // Authorize endpoint or any other - return 404+ let body = r#"{"error":"not found"}"#;+ format!(+ "HTTP/1.1 404 Not Found\r\nContent-Length: {}\r\nContent-Type: application/json\r\nConnection: close\r\n\r\n{body}",+ body.len()+ )+ };++ let _ = stream.write_all(response.as_bytes());+ let _ = stream.flush();+ }+ Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {+ std::thread::sleep(Duration::from_millis(10));+ }+ Err(_) => break,+ }+ }+ });++ std::thread::sleep(Duration::from_millis(100));+ let url = url.lock().unwrap().clone().unwrap();+ Self { url, shutdown }+ }+ }++ /// Simulate a browser callback request by connecting to our browser login+ /// server and sending a crafted HTTP GET request.+ fn send_callback_request(addr: std::net::SocketAddr, path: &str) -> String {+ let mut stream = std::net::TcpStream::connect(addr).unwrap();+ let request =+ format!("GET {path} HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n");+ let _ = stream.write_all(request.as_bytes());+ let _ = stream.flush();++ let mut buf = vec![0u8; 4096];+ let n = stream.read(&mut buf).unwrap_or(0);+ String::from_utf8_lossy(&buf[..n]).to_string()+ }++ #[test]+ fn browser_login_rejects_wrong_path() {+ // Start a browser login server on a random port+ // Get a free port for the test+ let test_listener = TcpListener::bind("127.0.0.1:0").unwrap();+ let test_port = test_listener.local_addr().unwrap().port();+ drop(test_listener);++ let config = BrowserLoginConfig {+ issuer: "http://fake-issuer".into(),+ port: test_port,+ timeout: Duration::from_millis(100),+ };++ // The server will be listening on the port but since we're sending+ // wrong path, it should fail with "Not found" and keep listening.+ // We'll connect and send a wrong path request first.+ let listener = TcpListener::bind(format!("127.0.0.1:{}", config.port)).unwrap();+ let _ = config; // suppress unused warning++ let _handle = std::thread::spawn(move || {+ listener.set_nonblocking(true).unwrap();+ // Accept one connection and handle it+ loop {+ if let Ok((mut stream, _)) = listener.accept() {+ let _ = handle_callback(+ &mut stream,+ "http://fake-issuer",+ "http://localhost:1455/auth/callback",+ &PkceCodes {+ verifier: "v".into(),+ challenge: "c".into(),+ },+ "test_state",+ );+ break;+ }+ std::thread::sleep(Duration::from_millis(10));+ }+ });++ // Now connect and send a wrong-path request+ let addr: std::net::SocketAddr = format!("127.0.0.1:{}", test_port).parse().unwrap();+ let response = send_callback_request(addr, "/wrong/path");+ assert!(response.contains("404"));+ assert!(response.contains("Not found"));+ }++ #[test]+ fn callback_rejects_wrong_state() {+ let listener = TcpListener::bind("127.0.0.1:0").unwrap();+ let port = listener.local_addr().unwrap().port();+ listener.set_nonblocking(true).unwrap();++ let _handle = std::thread::spawn(move || {+ let pkce = PkceCodes {+ verifier: "v".into(),+ challenge: "c".into(),+ };+ loop {+ if let Ok((mut stream, _)) = listener.accept() {+ let result = handle_callback(+ &mut stream,+ "http://fake-issuer",+ "http://localhost:1455/auth/callback",+ &pkce,+ "expected_state",+ );+ assert!(result.is_err());+ assert!(result.unwrap_err().to_string().contains("Invalid callback"));+ break;+ }+ std::thread::sleep(Duration::from_millis(10));+ }+ });++ let addr: std::net::SocketAddr = format!("127.0.0.1:{}", port).parse().unwrap();+ let response =+ send_callback_request(addr, "/auth/callback?code=test_code&state=wrong_state");+ assert!(response.contains("400"));+ assert!(response.contains("Invalid callback"));+ }++ #[test]+ fn callback_rejects_missing_code() {+ let listener = TcpListener::bind("127.0.0.1:0").unwrap();+ let port = listener.local_addr().unwrap().port();+ listener.set_nonblocking(true).unwrap();++ let _handle = std::thread::spawn(move || {+ let pkce = PkceCodes {+ verifier: "v".into(),+ challenge: "c".into(),+ };+ loop {+ if let Ok((mut stream, _)) = listener.accept() {+ let result = handle_callback(+ &mut stream,+ "http://fake-issuer",+ "http://localhost:1455/auth/callback",+ &pkce,+ "state",+ );+ assert!(result.is_err());+ assert!(result.unwrap_err().to_string().contains("Invalid callback"));+ break;+ }+ std::thread::sleep(Duration::from_millis(10));+ }+ });++ let addr: std::net::SocketAddr = format!("127.0.0.1:{}", port).parse().unwrap();+ let response = send_callback_request(addr, "/auth/callback?state=state");+ assert!(response.contains("400"));+ }++ #[test]+ fn callback_rejects_error_param() {+ let listener = TcpListener::bind("127.0.0.1:0").unwrap();+ let port = listener.local_addr().unwrap().port();+ listener.set_nonblocking(true).unwrap();++ let _handle = std::thread::spawn(move || {+ let pkce = PkceCodes {+ verifier: "v".into(),+ challenge: "c".into(),+ };+ loop {+ if let Ok((mut stream, _)) = listener.accept() {+ let result = handle_callback(+ &mut stream,+ "http://fake-issuer",+ "http://localhost:1455/auth/callback",+ &pkce,+ "state",+ );+ assert!(result.is_err());+ assert!(result.unwrap_err().to_string().contains("access_denied"));+ break;+ }+ std::thread::sleep(Duration::from_millis(10));+ }+ });++ let addr: std::net::SocketAddr = format!("127.0.0.1:{}", port).parse().unwrap();+ let response =+ send_callback_request(addr, "/auth/callback?error=access_denied&state=state");+ assert!(response.contains("400"));+ assert!(response.contains("access_denied"));+ }++ #[test]+ fn callback_success_exchanges_tokens() {+ let auth_server = MockBrowserLoginAuthServer::new();+ let auth_url = auth_server.url.clone();++ let listener = TcpListener::bind("127.0.0.1:0").unwrap();+ let port = listener.local_addr().unwrap().port();+ listener.set_nonblocking(true).unwrap();++ let _handle = std::thread::spawn(move || {+ let pkce = PkceCodes {+ verifier: "test_verifier".into(),+ challenge: "test_challenge".into(),+ };+ loop {+ if let Ok((mut stream, _)) = listener.accept() {+ let result = handle_callback(+ &mut stream,+ &auth_url,+ &format!("http://localhost:{port}/auth/callback"),+ &pkce,+ "expected_state",+ );+ assert!(result.is_ok());+ let tokens = result.unwrap();+ assert_eq!(tokens.access_token, "bt_at");+ assert_eq!(tokens.refresh_token, "bt_rt");+ break;+ }+ std::thread::sleep(Duration::from_millis(10));+ }+ });++ let addr: std::net::SocketAddr = format!("127.0.0.1:{}", port).parse().unwrap();+ send_callback_request(addr, "/auth/callback?code=test_code&state=expected_state");+ // Give the handler thread time to complete+ std::thread::sleep(Duration::from_millis(200));++ // auth_server dropped here, closing the mock server+ drop(auth_server);+ }++ #[test]+ fn callback_exchange_failure_returns_error() {+ // Server that returns a 500 on token exchange+ let shutdown = Arc::new(AtomicBool::new(false));+ let sd = shutdown.clone();+ let url: Arc<std::sync::Mutex<Option<String>>> = Arc::new(std::sync::Mutex::new(None));+ let url_clone = url.clone();++ std::thread::spawn(move || {+ let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("bind");+ let addr = listener.local_addr().unwrap();+ *url_clone.lock().unwrap() = Some(format!("http://{addr}"));++ listener.set_nonblocking(true).expect("nonblocking");++ loop {+ if sd.load(Ordering::Relaxed) {+ return;+ }+ match listener.accept() {+ Ok((mut stream, _)) => {+ let mut buf = [0; 4096];+ let n = match stream.read(&mut buf) {+ Ok(n) if n > 0 => n,+ _ => continue,+ };+ let request = String::from_utf8_lossy(&buf[..n]);++ let body = if request.contains("/oauth/token") {+ r#"{"error":"bad exchange"}"#+ } else {+ r#"{"error":"nf"}"#+ };+ let response = format!(+ "HTTP/1.1 500 Internal Server Error\r\nContent-Length: {}\r\nContent-Type: application/json\r\nConnection: close\r\n\r\n{body}",+ body.len()+ );+ let _ = stream.write_all(response.as_bytes());+ let _ = stream.flush();+ }+ Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {+ std::thread::sleep(Duration::from_millis(10));+ }+ Err(_) => break,+ }+ }+ });++ std::thread::sleep(Duration::from_millis(100));+ let fail_issuer = url.lock().unwrap().clone().unwrap();++ let listener = TcpListener::bind("127.0.0.1:0").unwrap();+ let port = listener.local_addr().unwrap().port();+ listener.set_nonblocking(true).unwrap();++ let fail_issuer_clone = fail_issuer.clone();+ let _handle = std::thread::spawn(move || {+ let pkce = PkceCodes {+ verifier: "v".into(),+ challenge: "c".into(),+ };+ loop {+ if let Ok((mut stream, _)) = listener.accept() {+ let result = handle_callback(+ &mut stream,+ &fail_issuer_clone,+ &format!("http://localhost:{port}/auth/callback"),+ &pkce,+ "expected_state",+ );+ assert!(result.is_err());+ assert!(+ result+ .unwrap_err()+ .to_string()+ .contains("Token exchange failed")+ );+ break;+ }+ std::thread::sleep(Duration::from_millis(10));+ }+ });++ let addr: std::net::SocketAddr = format!("127.0.0.1:{}", port).parse().unwrap();+ send_callback_request(addr, "/auth/callback?code=test_code&state=expected_state");++ std::thread::sleep(Duration::from_millis(200));+ }++ #[test]+ fn browser_login_times_out() {+ // Get a free port nobody is sending callbacks to+ let listener = TcpListener::bind("127.0.0.1:0").unwrap();+ let port = listener.local_addr().unwrap().port();+ drop(listener);++ let config = BrowserLoginConfig {+ issuer: "http://fake-issuer".into(),+ port,+ timeout: Duration::from_millis(100),+ };++ // run_browser_login_with_config will bind to the port and timeout+ let result = run_browser_login_with_config(&config);+ assert!(result.is_err());+ assert!(+ result.unwrap_err().to_string().contains("OAuth timeout"),+ "expected OAuth timeout error"+ );+ }+}diff --git a/src/providers/codex/auth/constants.rs b/src/providers/codex/auth/constants.rsindex 5573cfc..912969d 100644--- a/src/providers/codex/auth/constants.rs+++ b/src/providers/codex/auth/constants.rs@@ -3,3 +3,6 @@ pub const ISSUER: &str = "https://auth.openai.com";pub const CODEX_API_ENDPOINT: &str = "https://chatgpt.com/backend-api/codex/responses";pub const ORIGINATOR: &str = "claude-code-proxy";pub const REFRESH_MARGIN_MS: u64 = 5 * 60 * 1000;+pub const OAUTH_PORT: u16 = 1455;+pub const OAUTH_REDIRECT_URI: &str = "http://localhost:1455/auth/callback";+pub const DEVICE_POLL_SAFETY_MARGIN_MS: u64 = 3000;diff --git a/src/providers/codex/auth/device.rs b/src/providers/codex/auth/device.rsnew file mode 100644index 0000000..aa90892--- /dev/null+++ b/src/providers/codex/auth/device.rs@@ -0,0 +1,751 @@+use std::time::{Duration, Instant};++use super::constants::{CLIENT_ID, DEVICE_POLL_SAFETY_MARGIN_MS, ISSUER};+use super::jwt::TokenResponse;++const MAX_DEVICE_POLL_WAIT: Duration = Duration::from_secs(300);++// ---------------------------------------------------------------------------+// Sleeper abstraction (injectable for tests)+// ---------------------------------------------------------------------------++pub trait Sleeper: Send + Sync {+ fn sleep(&self, dur: Duration);+}++pub struct StdSleeper;++impl Sleeper for StdSleeper {+ fn sleep(&self, dur: Duration) {+ std::thread::sleep(dur);+ }+}++// ---------------------------------------------------------------------------+// Device init response+// ---------------------------------------------------------------------------++#[derive(Debug, Clone, serde::Deserialize)]+pub struct DeviceInit {+ pub device_auth_id: String,+ pub user_code: String,+ #[serde(default)]+ pub interval: String,+}++// ---------------------------------------------------------------------------+// Device token poll response+// ---------------------------------------------------------------------------++#[derive(Debug, Clone, serde::Deserialize)]+pub struct DeviceTokenPoll {+ pub authorization_code: String,+ pub code_verifier: String,+}++// ---------------------------------------------------------------------------+// Device auth client+// ---------------------------------------------------------------------------++pub struct DeviceAuthClient {+ issuer: String,+ client: reqwest::blocking::Client,+ sleeper: Box<dyn Sleeper>,+ max_wait: Duration,+}++impl DeviceAuthClient {+ pub fn new() -> Self {+ Self::with_issuer(ISSUER)+ }++ pub fn with_issuer(issuer: impl Into<String>) -> Self {+ Self {+ issuer: issuer.into(),+ client: reqwest::blocking::Client::builder()+ .timeout(Duration::from_secs(30))+ .build()+ .unwrap_or_default(),+ sleeper: Box::new(StdSleeper),+ max_wait: MAX_DEVICE_POLL_WAIT,+ }+ }++ #[cfg(test)]+ pub fn with_sleeper(mut self, sleeper: Box<dyn Sleeper>) -> Self {+ self.sleeper = sleeper;+ self+ }++ pub fn init(&self) -> Result<DeviceInit, anyhow::Error> {+ let body = serde_json::json!({ "client_id": CLIENT_ID });+ let resp = self+ .client+ .post(format!("{}/api/accounts/deviceauth/usercode", self.issuer))+ .json(&body)+ .send()+ .map_err(|e| anyhow::anyhow!("Device init network error: {e}"))?;++ let status = resp.status().as_u16();+ if !resp.status().is_success() {+ let text = resp.text().unwrap_or_default();+ anyhow::bail!("Device init failed: {status} {text}");+ }++ let init: DeviceInit = resp+ .json()+ .map_err(|e| anyhow::anyhow!("failed to parse device init response: {e}"))?;+ Ok(init)+ }++ fn poll_token(+ &self,+ device_auth_id: &str,+ user_code: &str,+ ) -> Result<Option<DeviceTokenPoll>, anyhow::Error> {+ let body = serde_json::json!({+ "device_auth_id": device_auth_id,+ "user_code": user_code,+ });+ let resp = self+ .client+ .post(format!("{}/api/accounts/deviceauth/token", self.issuer))+ .json(&body)+ .send()+ .map_err(|e| anyhow::anyhow!("Device poll network error: {e}"))?;++ let status = resp.status().as_u16();+ if resp.status().is_success() {+ let poll: DeviceTokenPoll = resp+ .json()+ .map_err(|e| anyhow::anyhow!("failed to parse device poll response: {e}"))?;+ return Ok(Some(poll));+ }+ if status == 403 || status == 404 {+ return Ok(None);+ }+ let text = resp.text().unwrap_or_default();+ anyhow::bail!("Device poll failed: {status} {text}");+ }++ fn exchange_code(+ &self,+ code: &str,+ code_verifier: &str,+ ) -> Result<TokenResponse, anyhow::Error> {+ let form = [+ ("grant_type", "authorization_code"),+ ("code", code),+ (+ "redirect_uri",+ &format!("{}/deviceauth/callback", self.issuer),+ ),+ ("client_id", CLIENT_ID),+ ("code_verifier", code_verifier),+ ];+ let resp = self+ .client+ .post(format!("{}/oauth/token", self.issuer))+ .form(&form)+ .send()+ .map_err(|e| anyhow::anyhow!("Token exchange network error: {e}"))?;++ let status = resp.status().as_u16();+ if !resp.status().is_success() {+ let text = resp.text().unwrap_or_default();+ anyhow::bail!("Token exchange failed: {status} {text}");+ }++ let tokens: TokenResponse = resp+ .json()+ .map_err(|e| anyhow::anyhow!("failed to parse token exchange response: {e}"))?;+ Ok(tokens)+ }++ fn parse_interval(interval: &str) -> Duration {+ let ms = match interval.parse::<i64>() {+ Ok(v) if v > 0 => v as u64 * 1000,+ Ok(0) => 5000,+ Ok(v) if v < 0 => 1000,+ Ok(_) => 5000,+ Err(_) => 5000,+ };+ Duration::from_millis(ms)+ }++ pub fn run(&self) -> Result<TokenResponse, anyhow::Error> {+ let init = self.init()?;++ println!(+ "\nVisit: {}/codex/device\nEnter code: {}\n",+ self.issuer, init.user_code+ );++ let sleep_dur = Self::parse_interval(&init.interval)+ + Duration::from_millis(DEVICE_POLL_SAFETY_MARGIN_MS);+ let deadline = Instant::now() + self.max_wait;++ loop {+ if Instant::now() >= deadline {+ anyhow::bail!(+ "Device auth timed out after {} seconds",+ self.max_wait.as_secs()+ );+ }++ match self.poll_token(&init.device_auth_id, &init.user_code)? {+ Some(poll) => {+ let tokens =+ self.exchange_code(&poll.authorization_code, &poll.code_verifier)?;+ return Ok(tokens);+ }+ None => {+ self.sleeper.sleep(sleep_dur);+ }+ }+ }+ }+}++impl Default for DeviceAuthClient {+ fn default() -> Self {+ Self::new()+ }+}++// ---------------------------------------------------------------------------+// Tests+// ---------------------------------------------------------------------------++#[cfg(test)]+mod tests {+ use super::*;+ use std::sync::atomic::{AtomicBool, Ordering};+ use std::sync::{Arc, Mutex};++ /// A sleeper that records durations instead of sleeping.+ #[derive(Default)]+ pub(crate) struct MockSleeper {+ pub slept: Mutex<Vec<Duration>>,+ }++ impl Sleeper for MockSleeper {+ fn sleep(&self, dur: Duration) {+ self.slept.lock().unwrap().push(dur);+ }+ }++ /// A minimal HTTP test server for the device auth flow.+ struct MockDeviceServer {+ url: String,+ #[allow(dead_code)]+ shutdown: Arc<AtomicBool>,+ saw_init: Arc<AtomicBool>,+ saw_token_exchange: Arc<AtomicBool>,+ saw_poll: Arc<AtomicBool>,+ }++ enum DeviceScenario {+ SuccessAfterPending,+ InitFailure,+ PollFailure,+ TokenExchangeFailure,+ InitThenTimeout,+ }++ fn json_response(status: u16, body: &str) -> String {+ let reason = match status {+ 200 => "OK",+ 403 => "Forbidden",+ 404 => "Not Found",+ 500 => "Internal Server Error",+ _ => "Unknown",+ };+ format!(+ "HTTP/1.1 {status} {reason}\r\nContent-Length: {}\r\nContent-Type: application/json\r\nConnection: close\r\n\r\n{body}",+ body.len(),+ )+ }++ impl MockDeviceServer {+ fn new(scenario: DeviceScenario) -> Self {+ let saw_init = Arc::new(AtomicBool::new(false));+ let saw_token_exchange = Arc::new(AtomicBool::new(false));+ let saw_poll = Arc::new(AtomicBool::new(false));+ let shutdown = Arc::new(AtomicBool::new(false));++ let si = saw_init.clone();+ let ste = saw_token_exchange.clone();+ let sp = saw_poll.clone();+ let sd = shutdown.clone();+ let url: Arc<std::sync::Mutex<Option<String>>> = Arc::new(std::sync::Mutex::new(None));++ let url_clone = url.clone();+ std::thread::spawn(move || {+ let listener =+ std::net::TcpListener::bind("127.0.0.1:0").expect("bind test server");+ let addr = listener.local_addr().unwrap();+ *url_clone.lock().unwrap() = Some(format!("http://{addr}"));++ listener.set_nonblocking(true).expect("set nonblocking");++ loop {+ if sd.load(Ordering::Relaxed) {+ return;+ }+ match listener.accept() {+ Ok((mut stream, _)) => {+ use std::io::{Read, Write};+ let mut buf = [0; 4096];+ let n = match stream.read(&mut buf) {+ Ok(n) if n > 0 => n,+ _ => continue,+ };+ let request = String::from_utf8_lossy(&buf[..n]);++ let response = match scenario {+ DeviceScenario::SuccessAfterPending => {+ Self::handle_success_after_pending(&request, &si, &sp, &ste)+ }+ DeviceScenario::InitFailure => {+ Self::handle_init_failure(&request, &si)+ }+ DeviceScenario::PollFailure => {+ Self::handle_poll_failure(&request, &si, &sp)+ }+ DeviceScenario::TokenExchangeFailure => {+ Self::handle_token_exchange_failure(&request, &si, &sp, &ste)+ }+ DeviceScenario::InitThenTimeout => {+ Self::handle_init_then_timeout(&request, &si)+ }+ };++ let _ = stream.write_all(response.as_bytes());+ let _ = stream.flush();+ }+ Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {+ std::thread::sleep(Duration::from_millis(10));+ }+ Err(_) => break,+ }+ }+ });++ // Wait for server to be ready+ std::thread::sleep(Duration::from_millis(100));+ let url = url.lock().unwrap().clone().unwrap();++ Self {+ url,+ shutdown,+ saw_init,+ saw_token_exchange,+ saw_poll,+ }+ }++ fn handle_success_after_pending(+ request: &str,+ saw_init: &AtomicBool,+ saw_poll: &AtomicBool,+ saw_exchange: &AtomicBool,+ ) -> String {+ if request.contains("/api/accounts/deviceauth/usercode") {+ saw_init.store(true, Ordering::Relaxed);+ Self::json_response(+ 200,+ r#"{"device_auth_id":"daid_1","user_code":"ABC-123","interval":"2"}"#,+ )+ } else if request.contains("/api/accounts/deviceauth/token") {+ saw_poll.store(true, Ordering::Relaxed);+ Self::json_response(+ 200,+ r#"{"authorization_code":"auth_code_1","code_verifier":"verifier_1"}"#,+ )+ } else if request.contains("/oauth/token") {+ saw_exchange.store(true, Ordering::Relaxed);+ Self::json_response(+ 200,+ r#"{"access_token":"at_1","refresh_token":"rt_1","expires_in":3600,"id_token":"fake_id_token"}"#,+ )+ } else {+ Self::json_response(404, r#"{"error":"not found"}"#)+ }+ }++ fn handle_init_failure(request: &str, saw_init: &AtomicBool) -> String {+ if request.contains("/api/accounts/deviceauth/usercode") {+ saw_init.store(true, Ordering::Relaxed);+ Self::json_response(500, r#"{"error":"server error"}"#)+ } else {+ Self::json_response(404, r#"{"error":"not found"}"#)+ }+ }++ fn handle_poll_failure(+ request: &str,+ saw_init: &AtomicBool,+ saw_poll: &AtomicBool,+ ) -> String {+ if request.contains("/api/accounts/deviceauth/usercode") {+ saw_init.store(true, Ordering::Relaxed);+ Self::json_response(+ 200,+ r#"{"device_auth_id":"daid_1","user_code":"ABC-123","interval":"2"}"#,+ )+ } else if request.contains("/api/accounts/deviceauth/token") {+ saw_poll.store(true, Ordering::Relaxed);+ Self::json_response(500, r#"{"error":"poll error"}"#)+ } else {+ Self::json_response(404, r#"{"error":"not found"}"#)+ }+ }++ fn handle_token_exchange_failure(+ request: &str,+ saw_init: &AtomicBool,+ saw_poll: &AtomicBool,+ saw_exchange: &AtomicBool,+ ) -> String {+ if request.contains("/api/accounts/deviceauth/usercode") {+ saw_init.store(true, Ordering::Relaxed);+ Self::json_response(+ 200,+ r#"{"device_auth_id":"daid_1","user_code":"ABC-123","interval":"2"}"#,+ )+ } else if request.contains("/api/accounts/deviceauth/token") {+ saw_poll.store(true, Ordering::Relaxed);+ Self::json_response(+ 200,+ r#"{"authorization_code":"auth_code_1","code_verifier":"verifier_1"}"#,+ )+ } else if request.contains("/oauth/token") {+ saw_exchange.store(true, Ordering::Relaxed);+ Self::json_response(500, r#"{"error":"exchange failed"}"#)+ } else {+ Self::json_response(404, r#"{"error":"not found"}"#)+ }+ }++ fn handle_init_then_timeout(request: &str, saw_init: &AtomicBool) -> String {+ if request.contains("/api/accounts/deviceauth/usercode") {+ saw_init.store(true, Ordering::Relaxed);+ Self::json_response(+ 200,+ r#"{"device_auth_id":"daid_1","user_code":"ABC-123","interval":"99999"}"#,+ )+ } else {+ // Return 403 to keep polling+ Self::json_response(403, r#"{"error":"pending"}"#)+ }+ }++ fn json_response(status: u16, body: &str) -> String {+ let reason = match status {+ 200 => "OK",+ 403 => "Forbidden",+ 404 => "Not Found",+ 500 => "Internal Server Error",+ _ => "Unknown",+ };+ format!(+ "HTTP/1.1 {status} {reason}\r\nContent-Length: {}\r\nContent-Type: application/json\r\nConnection: close\r\n\r\n{body}",+ body.len(),+ )+ }+ }++ #[test]+ fn device_flow_success_after_pending() {+ let server = MockDeviceServer::new(DeviceScenario::SuccessAfterPending);+ let client = DeviceAuthClient::with_issuer(&server.url);+ let tokens = client.run().unwrap();+ assert_eq!(tokens.access_token, "at_1");+ assert_eq!(tokens.refresh_token, "rt_1");+ assert!(server.saw_init.load(Ordering::Relaxed));+ assert!(server.saw_poll.load(Ordering::Relaxed));+ assert!(server.saw_token_exchange.load(Ordering::Relaxed));+ }++ #[test]+ fn device_flow_reports_init_failure() {+ let server = MockDeviceServer::new(DeviceScenario::InitFailure);+ let err = DeviceAuthClient::with_issuer(&server.url)+ .run()+ .unwrap_err();+ assert!(+ err.to_string().contains("Device init failed"),+ "expected init failure, got: {err}"+ );+ assert!(server.saw_init.load(Ordering::Relaxed));+ }++ #[test]+ fn device_flow_reports_poll_failure() {+ let server = MockDeviceServer::new(DeviceScenario::PollFailure);+ let err = DeviceAuthClient::with_issuer(&server.url)+ .run()+ .unwrap_err();+ assert!(+ err.to_string().contains("Device poll failed"),+ "expected poll failure, got: {err}"+ );+ assert!(server.saw_init.load(Ordering::Relaxed));+ assert!(server.saw_poll.load(Ordering::Relaxed));+ }++ #[test]+ fn device_flow_reports_token_exchange_failure() {+ let server = MockDeviceServer::new(DeviceScenario::TokenExchangeFailure);+ let err = DeviceAuthClient::with_issuer(&server.url)+ .run()+ .unwrap_err();+ assert!(+ err.to_string().contains("Token exchange failed"),+ "expected token exchange failure, got: {err}"+ );+ assert!(server.saw_init.load(Ordering::Relaxed));+ assert!(server.saw_poll.load(Ordering::Relaxed));+ assert!(server.saw_token_exchange.load(Ordering::Relaxed));+ }++ #[test]+ fn device_flow_times_out() {+ let server = MockDeviceServer::new(DeviceScenario::InitThenTimeout);+ let client = DeviceAuthClient {+ issuer: server.url.clone(),+ client: reqwest::blocking::Client::builder()+ .timeout(Duration::from_secs(5))+ .build()+ .unwrap(),+ sleeper: Box::new(MockSleeper::default()),+ max_wait: Duration::from_millis(100),+ };+ let err = client.run().unwrap_err();+ assert!(+ err.to_string().contains("timed out"),+ "expected timeout, got: {err}"+ );+ }++ #[test]+ fn device_flow_polls_403_and_continues() {+ let saw_poll_403 = Arc::new(AtomicBool::new(false));+ let saw_init = Arc::new(AtomicBool::new(false));+ let saw_exchange = Arc::new(AtomicBool::new(false));+ let saw_second_poll = Arc::new(AtomicBool::new(false));+ let shutdown = Arc::new(AtomicBool::new(false));++ let si = saw_init.clone();+ let sp403 = saw_poll_403.clone();+ let sp2 = saw_second_poll.clone();+ let ste = saw_exchange.clone();+ let sd = shutdown.clone();+ let url: Arc<std::sync::Mutex<Option<String>>> = Arc::new(std::sync::Mutex::new(None));+ let url_clone = url.clone();++ let poll_count = Arc::new(std::sync::atomic::AtomicU32::new(0));+ let pc = poll_count.clone();++ std::thread::spawn(move || {+ let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("bind");+ let addr = listener.local_addr().unwrap();+ *url_clone.lock().unwrap() = Some(format!("http://{addr}"));++ listener.set_nonblocking(true).expect("nonblocking");++ loop {+ if sd.load(Ordering::Relaxed) {+ return;+ }+ match listener.accept() {+ Ok((mut stream, _)) => {+ use std::io::{Read, Write};+ let mut buf = [0; 4096];+ let n = match stream.read(&mut buf) {+ Ok(n) if n > 0 => n,+ _ => continue,+ };+ let request = String::from_utf8_lossy(&buf[..n]);++ let response = if request.contains("/api/accounts/deviceauth/usercode") {+ si.store(true, Ordering::Relaxed);+ json_response(+ 200,+ r#"{"device_auth_id":"daid_1","user_code":"ABC-123","interval":"1"}"#,+ )+ } else if request.contains("/api/accounts/deviceauth/token") {+ let count = pc.fetch_add(1, Ordering::Relaxed);+ if count == 0 {+ sp403.store(true, Ordering::Relaxed);+ json_response(403, r#"{"error":"pending"}"#)+ } else {+ sp2.store(true, Ordering::Relaxed);+ json_response(+ 200,+ r#"{"authorization_code":"ac_2","code_verifier":"cv_2"}"#,+ )+ }+ } else if request.contains("/oauth/token") {+ ste.store(true, Ordering::Relaxed);+ json_response(+ 200,+ r#"{"access_token":"at_2","refresh_token":"rt_2","expires_in":3600}"#,+ )+ } else {+ json_response(404, r#"{"error":"nf"}"#)+ };++ let _ = stream.write_all(response.as_bytes());+ let _ = stream.flush();+ }+ Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {+ std::thread::sleep(Duration::from_millis(10));+ }+ Err(_) => break,+ }+ }+ });++ std::thread::sleep(Duration::from_millis(100));+ let url = url.lock().unwrap().clone().unwrap();++ let sleeper = MockSleeper::default();+ let client = DeviceAuthClient {+ issuer: url,+ client: reqwest::blocking::Client::builder()+ .timeout(Duration::from_secs(5))+ .build()+ .unwrap(),+ sleeper: Box::new(sleeper),+ max_wait: Duration::from_secs(30),+ };+ let tokens = client.run().unwrap();+ assert_eq!(tokens.access_token, "at_2");+ assert!(saw_init.load(Ordering::Relaxed));+ assert!(saw_poll_403.load(Ordering::Relaxed));+ assert!(saw_second_poll.load(Ordering::Relaxed));+ assert!(saw_exchange.load(Ordering::Relaxed));+ }++ #[test]+ fn device_flow_retries_404() {+ let saw_init = Arc::new(AtomicBool::new(false));+ let saw_poll_404 = Arc::new(AtomicBool::new(false));+ let saw_exchange = Arc::new(AtomicBool::new(false));+ let shutdown = Arc::new(AtomicBool::new(false));++ let si = saw_init.clone();+ let sp404 = saw_poll_404.clone();+ let ste = saw_exchange.clone();+ let sd = shutdown.clone();+ let url: Arc<std::sync::Mutex<Option<String>>> = Arc::new(std::sync::Mutex::new(None));+ let url_clone = url.clone();++ let poll_count = Arc::new(std::sync::atomic::AtomicU32::new(0));+ let pc = poll_count.clone();++ std::thread::spawn(move || {+ let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("bind");+ let addr = listener.local_addr().unwrap();+ *url_clone.lock().unwrap() = Some(format!("http://{addr}"));++ listener.set_nonblocking(true).expect("nonblocking");++ loop {+ if sd.load(Ordering::Relaxed) {+ return;+ }+ match listener.accept() {+ Ok((mut stream, _)) => {+ use std::io::{Read, Write};+ let mut buf = [0; 4096];+ let n = match stream.read(&mut buf) {+ Ok(n) if n > 0 => n,+ _ => continue,+ };+ let request = String::from_utf8_lossy(&buf[..n]);++ let response = if request.contains("/api/accounts/deviceauth/usercode") {+ si.store(true, Ordering::Relaxed);+ json_response(+ 200,+ r#"{"device_auth_id":"daid_1","user_code":"ABC-123","interval":"1"}"#,+ )+ } else if request.contains("/api/accounts/deviceauth/token") {+ let count = pc.fetch_add(1, Ordering::Relaxed);+ if count == 0 {+ sp404.store(true, Ordering::Relaxed);+ json_response(404, r#"{"error":"nf"}"#)+ } else {+ json_response(+ 200,+ r#"{"authorization_code":"ac_3","code_verifier":"cv_3"}"#,+ )+ }+ } else if request.contains("/oauth/token") {+ ste.store(true, Ordering::Relaxed);+ json_response(+ 200,+ r#"{"access_token":"at_3","refresh_token":"rt_3","expires_in":3600}"#,+ )+ } else {+ json_response(404, r#"{"error":"nf"}"#)+ };++ let _ = stream.write_all(response.as_bytes());+ let _ = stream.flush();+ }+ Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {+ std::thread::sleep(Duration::from_millis(10));+ }+ Err(_) => break,+ }+ }+ });++ std::thread::sleep(Duration::from_millis(100));+ let url = url.lock().unwrap().clone().unwrap();++ let sleeper = MockSleeper::default();+ let client = DeviceAuthClient {+ issuer: url,+ client: reqwest::blocking::Client::builder()+ .timeout(Duration::from_secs(5))+ .build()+ .unwrap(),+ sleeper: Box::new(sleeper),+ max_wait: Duration::from_secs(30),+ };+ let tokens = client.run().unwrap();+ assert_eq!(tokens.access_token, "at_3");+ assert!(saw_init.load(Ordering::Relaxed));+ assert!(saw_poll_404.load(Ordering::Relaxed));+ assert!(saw_exchange.load(Ordering::Relaxed));+ }++ #[test]+ fn device_flow_parse_interval() {+ assert_eq!(+ DeviceAuthClient::parse_interval("5"),+ Duration::from_millis(5000)+ );+ assert_eq!(+ DeviceAuthClient::parse_interval("0"),+ Duration::from_millis(5000)+ );+ assert_eq!(+ DeviceAuthClient::parse_interval("-1"),+ Duration::from_millis(1000)+ );+ assert_eq!(+ DeviceAuthClient::parse_interval("invalid"),+ Duration::from_millis(5000)+ );+ assert_eq!(+ DeviceAuthClient::parse_interval("10"),+ Duration::from_millis(10000)+ );+ }+}diff --git a/src/providers/codex/auth/jwt.rs b/src/providers/codex/auth/jwt.rsindex 697ffcf..e776444 100644--- a/src/providers/codex/auth/jwt.rs+++ b/src/providers/codex/auth/jwt.rs@@ -63,6 +63,19 @@ fn extract_account_id_from_claims(claims: &IdTokenClaims) -> Option<String> {.or_else(|| claims.organizations.as_ref()?.first()?.id.clone().into())}+pub fn validate_token_response(tokens: &TokenResponse) -> anyhow::Result<()> {+ if tokens.access_token.trim().is_empty() {+ anyhow::bail!("token response missing access token");+ }+ if tokens.refresh_token.trim().is_empty() {+ anyhow::bail!("token response missing refresh token");+ }+ if matches!(tokens.expires_in, Some(0)) {+ anyhow::bail!("token response has invalid expiration");+ }+ Ok(())+}+pub fn extract_account_id(tokens: &TokenResponse) -> Option<String> {if let Some(ref id_token) = tokens.id_token&& let Some(claims) = parse_jwt_claims(id_token)@@ -114,4 +127,77 @@ mod tests {};assert_eq!(extract_account_id(&token), None);}++ #[test]+ fn validate_token_response_rejects_empty_access_token() {+ let token = TokenResponse {+ access_token: "".into(),+ refresh_token: "r".into(),+ expires_in: Some(3600),+ id_token: None,+ };+ assert!(validate_token_response(&token).is_err());+ assert!(+ validate_token_response(&token)+ .unwrap_err()+ .to_string()+ .contains("missing access token")+ );+ }++ #[test]+ fn validate_token_response_rejects_empty_refresh_token() {+ let token = TokenResponse {+ access_token: "a".into(),+ refresh_token: "".into(),+ expires_in: Some(3600),+ id_token: None,+ };+ assert!(validate_token_response(&token).is_err());+ assert!(+ validate_token_response(&token)+ .unwrap_err()+ .to_string()+ .contains("missing refresh token")+ );+ }++ #[test]+ fn validate_token_response_rejects_zero_expires_in() {+ let token = TokenResponse {+ access_token: "a".into(),+ refresh_token: "r".into(),+ expires_in: Some(0),+ id_token: None,+ };+ assert!(validate_token_response(&token).is_err());+ assert!(+ validate_token_response(&token)+ .unwrap_err()+ .to_string()+ .contains("invalid expiration")+ );+ }++ #[test]+ fn validate_token_response_accepts_valid() {+ let token = TokenResponse {+ access_token: "a".into(),+ refresh_token: "r".into(),+ expires_in: Some(3600),+ id_token: None,+ };+ assert!(validate_token_response(&token).is_ok());+ }++ #[test]+ fn validate_token_response_accepts_no_expires_in() {+ let token = TokenResponse {+ access_token: "a".into(),+ refresh_token: "r".into(),+ expires_in: None,+ id_token: None,+ };+ assert!(validate_token_response(&token).is_ok());+ }}diff --git a/src/providers/codex/auth/manager.rs b/src/providers/codex/auth/manager.rsindex b1aa066..2226e14 100644--- a/src/providers/codex/auth/manager.rs+++ b/src/providers/codex/auth/manager.rs@@ -2,7 +2,7 @@ use std::sync::{Arc, Mutex};use std::time::{SystemTime, UNIX_EPOCH};use super::constants::{CLIENT_ID, ISSUER, REFRESH_MARGIN_MS};-use super::jwt::{TokenResponse, extract_account_id};+use super::jwt::{TokenResponse, extract_account_id, validate_token_response};use super::token_store::{CodexTokenStore, StoredAuth};use crate::auth::AuthStorage;@@ -108,6 +108,7 @@ impl<S: AuthStorage<StoredAuth>> CodexAuthManager<S> {let tokens: TokenResponse = resp.json().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());let expires = Self::now_ms() + (tokens.expires_in.unwrap_or(3600) * 1000);let next = StoredAuth {@@ -128,6 +129,7 @@ impl<S: AuthStorage<StoredAuth>> CodexAuthManager<S> {&self,tokens: &TokenResponse,) -> Result<StoredAuth, anyhow::Error> {+ validate_token_response(tokens)?;let account_id = extract_account_id(tokens);let expires = Self::now_ms() + (tokens.expires_in.unwrap_or(3600) * 1000);let auth = StoredAuth {diff --git a/src/providers/codex/auth/mod.rs b/src/providers/codex/auth/mod.rsindex 737d908..239f7db 100644--- a/src/providers/codex/auth/mod.rs+++ b/src/providers/codex/auth/mod.rs@@ -1,4 +1,7 @@+pub mod browser_login;pub mod constants;+pub mod device;pub mod jwt;pub mod manager;+pub mod pkce;pub mod token_store;diff --git a/src/providers/codex/auth/pkce.rs b/src/providers/codex/auth/pkce.rsnew file mode 100644index 0000000..5a54859--- /dev/null+++ b/src/providers/codex/auth/pkce.rs@@ -0,0 +1,198 @@+use sha2::{Digest, Sha256};++use super::constants::{CLIENT_ID, ORIGINATOR};++// ---------------------------------------------------------------------------+// PKCE types+// ---------------------------------------------------------------------------++#[derive(Debug, Clone)]+pub struct PkceCodes {+ pub verifier: String,+ pub challenge: String,+}++// ---------------------------------------------------------------------------+// Code generation+// ---------------------------------------------------------------------------++fn base64_url_encode(bytes: &[u8]) -> String {+ use base64::Engine;+ base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(bytes)+}++pub fn generate_pkce() -> PkceCodes {+ let mut verifier_bytes = vec![0u8; 32];+ rand::RngCore::fill_bytes(&mut rand::thread_rng(), &mut verifier_bytes);+ let verifier = base64_url_encode(&verifier_bytes);++ let hash = Sha256::digest(verifier.as_bytes());+ let challenge = base64_url_encode(&hash);++ PkceCodes {+ verifier,+ challenge,+ }+}++pub fn generate_state() -> String {+ let mut state_bytes = vec![0u8; 32];+ rand::RngCore::fill_bytes(&mut rand::thread_rng(), &mut state_bytes);+ base64_url_encode(&state_bytes)+}++// ---------------------------------------------------------------------------+// Authorize URL+// ---------------------------------------------------------------------------++pub fn build_authorize_url(+ issuer: &str,+ redirect_uri: &str,+ pkce: &PkceCodes,+ state: &str,+) -> Result<String, anyhow::Error> {+ let mut url = url::Url::parse(&format!("{issuer}/oauth/authorize"))?;+ url.query_pairs_mut()+ .append_pair("response_type", "code")+ .append_pair("client_id", CLIENT_ID)+ .append_pair("redirect_uri", redirect_uri)+ .append_pair("scope", "openid profile email offline_access")+ .append_pair("code_challenge", &pkce.challenge)+ .append_pair("code_challenge_method", "S256")+ .append_pair("id_token_add_organizations", "true")+ .append_pair("codex_cli_simplified_flow", "true")+ .append_pair("state", state)+ .append_pair("originator", ORIGINATOR);+ Ok(url.to_string())+}++// ---------------------------------------------------------------------------+// Token exchange+// ---------------------------------------------------------------------------++pub fn exchange_code_for_tokens(+ issuer: &str,+ code: &str,+ pkce: &PkceCodes,+ redirect_uri: &str,+) -> Result<crate::providers::codex::auth::jwt::TokenResponse, anyhow::Error> {+ let client = reqwest::blocking::Client::new();+ let form = [+ ("grant_type", "authorization_code"),+ ("code", code),+ ("redirect_uri", redirect_uri),+ ("client_id", CLIENT_ID),+ ("code_verifier", &pkce.verifier),+ ];++ let resp = client+ .post(format!("{issuer}/oauth/token"))+ .form(&form)+ .send()+ .map_err(|e| anyhow::anyhow!("Token exchange network error: {e}"))?;++ let status = resp.status().as_u16();+ if !resp.status().is_success() {+ let text = resp.text().unwrap_or_default();+ anyhow::bail!("Token exchange failed: {status} {text}");+ }++ let tokens = resp+ .json()+ .map_err(|e| anyhow::anyhow!("failed to parse token exchange response: {e}"))?;+ Ok(tokens)+}++// ---------------------------------------------------------------------------+// Tests+// ---------------------------------------------------------------------------++#[cfg(test)]+mod tests {+ use super::*;+ use base64::Engine;++ #[test]+ fn generate_pkce_produces_expected_format() {+ let pkce = generate_pkce();+ // Verifier should be 32 random bytes, base64 URL-encoded without padding+ // = ceil(32*4/3) = 43 characters+ assert_eq!(pkce.verifier.len(), 43);+ // Challenge should be SHA-256 of verifier, base64 URL-encoded without padding+ // SHA-256 is 32 bytes, so same length: 43 characters+ assert_eq!(pkce.challenge.len(), 43);+ // Verifier should be URL-safe base64 (no +, /, or =)+ assert!(!pkce.verifier.contains('+'));+ assert!(!pkce.verifier.contains('/'));+ assert!(!pkce.verifier.contains('='));+ }++ #[test]+ fn generate_pkce_challenge_is_s256_of_verifier() {+ let pkce = generate_pkce();+ let expected_hash = Sha256::digest(pkce.verifier.as_bytes());+ let expected_challenge =+ base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(&expected_hash);+ assert_eq!(pkce.challenge, expected_challenge);+ }++ #[test]+ fn generate_state_produces_url_safe_base64() {+ let state = generate_state();+ assert_eq!(state.len(), 43);+ assert!(!state.contains('+'));+ assert!(!state.contains('/'));+ assert!(!state.contains('='));+ }++ #[test]+ fn authorize_url_contains_codex_params() {+ let pkce = PkceCodes {+ verifier: "verifier".into(),+ challenge: "challenge".into(),+ };+ let url = build_authorize_url(+ "http://issuer",+ "http://localhost:1455/auth/callback",+ &pkce,+ "state",+ )+ .unwrap();+ assert!(url.contains("client_id=app_EMoamEEZ73f0CkXaXp7hrann"));+ assert!(url.contains("redirect_uri=http%3A%2F%2Flocalhost%3A1455%2Fauth%2Fcallback"));+ assert!(url.contains("scope=openid+profile+email+offline_access"));+ assert!(url.contains("code_challenge_method=S256"));+ assert!(url.contains("codex_cli_simplified_flow=true"));+ assert!(url.contains("originator=claude-code-proxy"));+ assert!(url.contains("state=state"));+ }++ #[test]+ fn authorize_url_starts_with_issuer_authorize() {+ let pkce = PkceCodes {+ verifier: "v".into(),+ challenge: "c".into(),+ };+ let url = build_authorize_url(+ "https://auth.openai.com",+ "http://localhost:1455/auth/callback",+ &pkce,+ "s",+ )+ .unwrap();+ assert!(url.starts_with("https://auth.openai.com/oauth/authorize?"));+ }++ #[test]+ fn exchange_code_uses_form_encoding() {+ // Test that the exchange code builds proper form-encoded requests+ // by checking the function compiles and accepts expected params+ // (actual network call not made in this test)+ let pkce = PkceCodes {+ verifier: "test_verifier".into(),+ challenge: "test_challenge".into(),+ };+ // Just verify function signature and types+ let _ = pkce;+ }+}diff --git a/src/providers/codex/auth/token_store.rs b/src/providers/codex/auth/token_store.rsindex 393b898..e3a725a 100644--- a/src/providers/codex/auth/token_store.rs+++ b/src/providers/codex/auth/token_store.rs@@ -13,7 +13,12 @@ pub struct StoredAuth {pub access: String,pub refresh: String,pub expires: u64,- #[serde(default, alias = "accountId", skip_serializing_if = "Option::is_none")]+ #[serde(+ default,+ rename = "accountId",+ alias = "account_id",+ skip_serializing_if = "Option::is_none"+ )]pub account_id: Option<String>,}@@ -177,6 +182,19 @@ mod tests {assert_eq!(auth.account_id.as_deref(), Some("acct"));}+ #[test]+ fn stored_auth_writes_account_id_key() {+ let auth = StoredAuth {+ access: "a".into(),+ refresh: "r".into(),+ expires: 4102444800000,+ account_id: Some("acct_1".into()),+ };+ let value = serde_json::to_value(auth).unwrap();+ assert_eq!(value["accountId"], "acct_1");+ assert!(value.get("account_id").is_none());+ }+#[test]fn stored_auth_roundtrip() {let store = CodexTokenStore::new(InMemoryAuthStore::new());diff --git a/src/providers/codex/mod.rs b/src/providers/codex/mod.rsindex 973420d..ff6137e 100644--- a/src/providers/codex/mod.rs+++ b/src/providers/codex/mod.rs@@ -18,6 +18,9 @@ use crate::config;use crate::provider::{CliHandlers, Provider, RequestContext};use crate::registry;+use self::auth::browser_login::run_browser_login;+use self::auth::device::DeviceAuthClient;+use self::auth::manager::CodexAuthManager;use self::auth::token_store::file_store;use self::client::CodexHttpClient;use self::continuation::{clear_continuation, continuation_candidate};@@ -232,11 +235,29 @@ pub(crate) struct CodexCli;impl CliHandlers for CodexCli {fn login(&self) -> Result<(), anyhow::Error> {- anyhow::bail!("codex: browser login not yet implemented; use device login instead");+ let tokens = run_browser_login()?;+ let store = file_store();+ let manager = CodexAuthManager::new(store);+ let saved = manager.persist_initial_tokens(&tokens)?;+ println!("Auth saved in {}", manager.store.auth_path());+ if let Some(ref aid) = saved.account_id {+ println!("Account: {aid}");+ }+ println!("Authentication complete");+ Ok(())}fn device(&self) -> Result<(), anyhow::Error> {- anyhow::bail!("codex: device login not yet implemented");+ let tokens = DeviceAuthClient::new().run()?;+ let store = file_store();+ let manager = CodexAuthManager::new(store);+ let saved = manager.persist_initial_tokens(&tokens)?;+ println!("Auth saved in {}", manager.store.auth_path());+ if let Some(ref aid) = saved.account_id {+ println!("Account: {aid}");+ }+ println!("Authentication complete");+ Ok(())}fn status(&self) -> Result<(), anyhow::Error> {diff --git a/tests/codex_auth.rs b/tests/codex_auth.rsnew file mode 100644index 0000000..41ae555--- /dev/null+++ b/tests/codex_auth.rs@@ -0,0 +1,81 @@+use assert_cmd::Command;+use predicates::str::contains;+use tempfile::TempDir;++/// Run a codex auth command with a temp config dir that isolates+/// from the real user config. Overrides HOME so the legacy config+/// fallback also resolves within the temp dir.+fn codex_cmd() -> (Command, TempDir) {+ let temp = TempDir::new().unwrap();+ let mut cmd = Command::cargo_bin("claude-code-proxy").unwrap();+ cmd.args(["codex", "auth", "status"]);+ cmd.env("CCP_CONFIG_DIR", temp.path());+ cmd.env("HOME", temp.path());+ (cmd, temp)+}++#[test]+fn codex_auth_status_reads_stored_auth() -> Result<(), Box<dyn std::error::Error>> {+ let (mut cmd, temp) = codex_cmd();+ let auth_dir = temp.path().join("codex");+ std::fs::create_dir_all(&auth_dir)?;+ std::fs::write(+ auth_dir.join("auth.json"),+ r#"{"access":"a","refresh":"r","expires":4102444800000,"accountId":"acct_1"}"#,+ )?;+ cmd.assert().success().stdout(contains("Account: acct_1"));+ Ok(())+}++#[test]+fn codex_auth_status_reads_legacy_account_id_key() -> Result<(), Box<dyn std::error::Error>> {+ let (mut cmd, temp) = codex_cmd();+ let auth_dir = temp.path().join("codex");+ std::fs::create_dir_all(&auth_dir)?;+ std::fs::write(+ auth_dir.join("auth.json"),+ r#"{"access":"a","refresh":"r","expires":4102444800000,"account_id":"acct_2"}"#,+ )?;+ cmd.assert().success().stdout(contains("Account: acct_2"));+ Ok(())+}++#[test]+fn codex_auth_status_no_auth() -> Result<(), Box<dyn std::error::Error>> {+ let (mut cmd, _temp) = codex_cmd();+ let output = cmd.output()?;+ assert_eq!(output.status.code(), Some(1));+ assert!(String::from_utf8(output.stdout)?.contains("Not authenticated"));+ Ok(())+}++#[test]+fn codex_auth_status_shows_auth_path() -> Result<(), Box<dyn std::error::Error>> {+ let (mut cmd, temp) = codex_cmd();+ let auth_dir = temp.path().join("codex");+ std::fs::create_dir_all(&auth_dir)?;+ std::fs::write(+ auth_dir.join("auth.json"),+ r#"{"access":"a","refresh":"r","expires":4102444800000,"accountId":"acct_3"}"#,+ )?;+ cmd.assert().success().stdout(contains("Auth path:"));+ Ok(())+}++#[test]+fn codex_auth_status_no_account_id_shows_no_account_line() -> Result<(), Box<dyn std::error::Error>>+{+ let (mut cmd, temp) = codex_cmd();+ let auth_dir = temp.path().join("codex");+ std::fs::create_dir_all(&auth_dir)?;+ std::fs::write(+ auth_dir.join("auth.json"),+ r#"{"access":"a","refresh":"r","expires":4102444800000}"#,+ )?;+ let output = cmd.output()?;+ let out = String::from_utf8(output.stdout)?;+ assert!(output.status.success());+ assert!(out.contains("Authenticated: true"));+ assert!(!out.contains("Account:"));+ Ok(())+}