Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
codex: harden websocket transport
Raine Virta9d49b4916be1
diff --git a/src/providers/codex/client.rs b/src/providers/codex/client.rsindex c9de29c..d45caa5 100644--- a/src/providers/codex/client.rs+++ b/src/providers/codex/client.rs@@ -86,64 +86,62 @@ pub fn build_codex_headers(let mut headers = http::HeaderMap::new();headers.insert(http::header::CONTENT_TYPE,- "application/json".parse().map_err(|_| CodexError {- status: 500,- message: "Failed to parse content-type header".to_string(),- detail: None,- retry_after: None,- origin: CodexErrorOrigin::Http,- })?,+ header_value("content-type", "application/json")?,);headers.insert(http::header::ACCEPT,- "text/event-stream".parse().map_err(|_| CodexError {- status: 500,- message: "Failed to parse accept header".to_string(),- detail: None,- retry_after: None,- origin: CodexErrorOrigin::Http,- })?,+ header_value("accept", "text/event-stream")?,);let bearer = format!("Bearer {}", auth.access);headers.insert(http::header::AUTHORIZATION,- bearer.parse().map_err(|_| CodexError {- status: 500,- message: "Failed to parse authorization header".to_string(),- detail: None,- retry_after: None,- origin: CodexErrorOrigin::Http,- })?,+ header_value("authorization", &bearer)?,);let originator = config::codex_originator(ORIGINATOR);+ headers.insert("originator", header_value("originator", &originator)?);headers.insert(- "originator",- originator.parse().map_err(|_| CodexError {- status: 500,- message: "Failed to parse originator header".to_string(),- detail: None,- retry_after: None,- origin: CodexErrorOrigin::Http,- })?,+ "openai-beta",+ header_value("openai-beta", "responses=experimental")?,);- headers.insert("openai-beta", "responses=experimental".parse().unwrap());if let Some(ref account_id) = auth.account_id {- headers.insert("ChatGPT-Account-Id", account_id.parse().unwrap());+ headers.insert(+ "ChatGPT-Account-Id",+ header_value("ChatGPT-Account-Id", account_id)?,+ );}if let Some(ref session_id) = ctx.session_id {- headers.insert("session_id", session_id.parse().unwrap());- headers.insert("x-client-request-id", session_id.parse().unwrap());+ headers.insert("session_id", header_value("session_id", session_id)?);+ headers.insert(+ "x-client-request-id",+ header_value("x-client-request-id", session_id)?,+ );let window_id = format!("{session_id}:0");- headers.insert("x-codex-window-id", window_id.parse().unwrap());+ headers.insert(+ "x-codex-window-id",+ header_value("x-codex-window-id", &window_id)?,+ );}let user_agent =config::codex_user_agent(&format!("claude-code-proxy/{}", env!("CARGO_PKG_VERSION")));if !user_agent.is_empty() {- headers.insert(http::header::USER_AGENT, user_agent.parse().unwrap());+ headers.insert(+ http::header::USER_AGENT,+ header_value("user-agent", &user_agent)?,+ );}Ok(headers)}+fn header_value(name: &str, value: &str) -> Result<http::HeaderValue, CodexError> {+ http::HeaderValue::from_str(value).map_err(|e| CodexError {+ status: 500,+ message: format!("Failed to parse {name} header"),+ detail: Some(e.to_string()),+ retry_after: None,+ origin: CodexErrorOrigin::Http,+ })+}+// ---------------------------------------------------------------------------// WebSocket request shaping// ---------------------------------------------------------------------------@@ -353,25 +351,35 @@ impl CodexHttpClient {}};- match result {- Ok(response) if response.status == 401 && transport_attempt == 0 => {- // First 401: try refresh- match self.auth_manager.force_refresh() {- Ok(new_auth) => {- auth = new_auth;- continue;- }- Err(e) => {- return Err(CodexError {- status: 401,- message: "Unauthorized".to_string(),- detail: Some(e.to_string()),- retry_after: None,- origin: CodexErrorOrigin::Http,- });- }+ if should_refresh_after_unauthorized(&result, transport_attempt) {+ match self.auth_manager.force_refresh() {+ Ok(new_auth) => {+ auth = new_auth;+ continue;+ }+ Err(e) => {+ return Err(CodexError {+ status: 401,+ message: "Unauthorized".to_string(),+ detail: Some(e.to_string()),+ retry_after: None,+ origin: CodexErrorOrigin::Http,+ });}}+ }++ match result {+ Ok(response) if response.status == 401 => {+ let detail = String::from_utf8_lossy(&response.body).to_string();+ return Err(CodexError {+ status: 401,+ message: "Unauthorized".to_string(),+ detail: Some(detail),+ retry_after: None,+ origin: CodexErrorOrigin::Http,+ });+ }Ok(response) if response.status == 403 => {let detail = String::from_utf8_lossy(&response.body).to_string();return Err(CodexError {@@ -690,6 +698,19 @@ fn is_retryable_reqwest_error(err: &reqwest::Error) -> bool {|| msg.contains("epipe")}+fn should_refresh_after_unauthorized(+ result: &Result<CodexResponse, CodexError>,+ transport_attempt: u32,+) -> bool {+ if transport_attempt != 0 {+ return false;+ }+ match result {+ Ok(response) => response.status == 401,+ Err(err) => err.status == 401,+ }+}+fn websocket_pool_key<'a>(ctx: &'a RequestContext,continuation: Option<&super::continuation::ContinuationCandidate>,@@ -772,6 +793,26 @@ mod tests {assert!(headers.get("x-client-request-id").is_none());}+ #[test]+ fn codex_headers_return_error_for_invalid_session_header() {+ let auth = StoredAuth {+ access: "tok".into(),+ refresh: String::new(),+ account_id: None,+ expires: u64::MAX,+ };+ let ctx = RequestContext {+ req_id: "r".into(),+ session_id: Some("bad\nsession".into()),+ session_seq: None,+ provider: "codex".into(),+ traffic: None,+ };+ let err = build_codex_headers(&auth, &ctx).unwrap_err();+ assert_eq!(err.status, 500);+ assert!(err.message.contains("session_id"));+ }+#[test]fn build_websocket_request_removes_stream() {let input = vec![@@ -910,4 +951,35 @@ mod tests {let display = format!("{err}");assert!(display.contains("connection reset"));}++ #[test]+ fn unauthorized_retry_check_covers_http_and_websocket_results() {+ let http_unauthorized = Ok(CodexResponse {+ body: Vec::new(),+ status: 401,+ headers: Vec::new(),+ });+ let websocket_unauthorized = Err(CodexError {+ status: 401,+ message: "WebSocket connect error".to_string(),+ detail: None,+ retry_after: None,+ origin: CodexErrorOrigin::WebSocket,+ });+ let forbidden = Err(CodexError {+ status: 403,+ message: "Forbidden".to_string(),+ detail: None,+ retry_after: None,+ origin: CodexErrorOrigin::WebSocket,+ });++ assert!(should_refresh_after_unauthorized(&http_unauthorized, 0));+ assert!(should_refresh_after_unauthorized(+ &websocket_unauthorized,+ 0+ ));+ assert!(!should_refresh_after_unauthorized(&forbidden, 0));+ assert!(!should_refresh_after_unauthorized(&http_unauthorized, 1));+ }}diff --git a/src/providers/codex/websocket.rs b/src/providers/codex/websocket.rsindex 12d3324..ce2a68a 100644--- a/src/providers/codex/websocket.rs+++ b/src/providers/codex/websocket.rs@@ -303,22 +303,28 @@ pub async fn codex_websocket_request(} else {// Connection is alive, send the request through itlet ws_msg = Message::Text(body_json.clone());- ws_guard.send(ws_msg).await.map_err(|e| CodexError {- status: 0,- message: format!("WebSocket send error: {e}"),- detail: None,- retry_after: None,- origin: CodexErrorOrigin::WebSocket,+ ws_guard.send(ws_msg).await.map_err(|e| {+ if let Some(key) = pool_key {+ invalidate_codex_websocket_pool_key(key);+ }+ CodexError {+ status: 0,+ message: format!("WebSocket send error: {e}"),+ detail: None,+ retry_after: None,+ origin: CodexErrorOrigin::WebSocket,+ }})?;// Collect eventslet (sse_body, terminal_event) =collect_ws_events(&mut ws_guard, idle_timeout_ms, pool_key, traffic).await?;+ let Some(terminal_event) = terminal_event else {+ return Err(missing_terminal_error());+ };// Handle previous response missing- if let Some(terminal) = &terminal_event- && is_previous_response_missing(&terminal.payload)- {+ if is_previous_response_missing(&terminal_event.payload) {return Err(CodexError {status: 0,message: "Previous response not found".to_string(),@@ -329,12 +335,8 @@ pub async fn codex_websocket_request(}// Extract status from error events- let status = if let Some(terminal) = &terminal_event {- if terminal.event_type == "error" {- extract_status_from_error(&terminal.payload).unwrap_or(500)- } else {- 200- }+ let status = if terminal_event.event_type == "error" {+ extract_status_from_error(&terminal_event.payload).unwrap_or(500)} else {200};@@ -375,10 +377,11 @@ pub async fn codex_websocket_request(let (sse_body, terminal_event) =collect_ws_events(&mut ws_guard, idle_timeout_ms, pool_key, traffic).await?;+ let Some(terminal_event) = terminal_event else {+ return Err(missing_terminal_error());+ };- if let Some(terminal) = &terminal_event- && is_previous_response_missing(&terminal.payload)- {+ if is_previous_response_missing(&terminal_event.payload) {if let Some(key) = pool_key {invalidate_codex_websocket_pool_key(key);}@@ -393,21 +396,14 @@ pub async fn codex_websocket_request(// Pool the connection if we have a key and it was successfulif let Some(key) = pool_key {- let should_pool = terminal_event- .as_ref()- .map(|t| t.event_type == "response.completed")- .unwrap_or(false);+ let should_pool = terminal_event.event_type == "response.completed";if should_pool {pool_insert(key.to_string(), entry.clone());}}- let status = if let Some(terminal) = &terminal_event {- if terminal.event_type == "error" {- extract_status_from_error(&terminal.payload).unwrap_or(500)- } else {- 200- }+ let status = if terminal_event.event_type == "error" {+ extract_status_from_error(&terminal_event.payload).unwrap_or(500)} else {200};@@ -426,6 +422,16 @@ pub async fn codex_websocket_request(}}+fn missing_terminal_error() -> CodexError {+ CodexError {+ status: 0,+ message: "WebSocket connection closed before terminal Codex response event".to_string(),+ detail: None,+ retry_after: None,+ origin: CodexErrorOrigin::WebSocket,+ }+}+fn write_websocket_metadata_capture(traffic: &TrafficCapture,ws_url: &str,@@ -496,13 +502,11 @@ async fn connect_with_timeout(CodexError,> {// Build an http::Request with the given headers for the WebSocket upgrade+ let host = websocket_host_header(url);let mut req_builder = http::Request::builder().uri(url).method("GET")- .header(- "Host",- url::Url::parse(url).map_or("".to_string(), |u| u.host_str().unwrap_or("").to_string()),- )+ .header("Host", host).header("Connection", "Upgrade").header("Upgrade", "websocket").header("Sec-WebSocket-Version", "13")@@ -565,6 +569,13 @@ async fn connect_with_timeout(})}+fn websocket_host_header(url: &str) -> String {+ let Ok(parsed) = url::Url::parse(url) else {+ return String::new();+ };+ parsed[url::Position::BeforeHost..url::Position::AfterPort].to_string()+}+// ---------------------------------------------------------------------------// Event collection// ---------------------------------------------------------------------------@@ -642,6 +653,9 @@ async fn collect_ws_events(}Some(Ok(Message::Binary(_))) => {// Reject binary frames+ if let Some(key) = pool_key {+ invalidate_codex_websocket_pool_key(key);+ }return Err(CodexError {status: 0,message: "WebSocket binary frames not supported".to_string(),@@ -745,6 +759,19 @@ mod tests {assert!(to_websocket_url("ftp://example.test/codex").is_err());}+ #[test]+ fn websocket_host_header_preserves_explicit_port() {+ assert_eq!(+ websocket_host_header("wss://chatgpt.com/backend-api/codex/responses"),+ "chatgpt.com"+ );+ assert_eq!(+ websocket_host_header("ws://127.0.0.1:4141/backend-api/codex/responses"),+ "127.0.0.1:4141"+ );+ assert_eq!(websocket_host_header("ws://[::1]:4141/path"), "[::1]:4141");+ }+#[test]fn websocket_headers_rewrite_beta() {let mut headers = http::HeaderMap::new();@@ -839,6 +866,95 @@ mod tests {assert!(!WS_POOL.lock().unwrap().contains_key("test-session"));}+ #[tokio::test]+ async fn websocket_connect_401_is_statusful_auth_error() {+ use tokio::io::{AsyncReadExt, AsyncWriteExt};+ use tokio::net::TcpListener;++ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();+ let addr = listener.local_addr().unwrap();+ tokio::spawn(async move {+ let (mut socket, _) = listener.accept().await.unwrap();+ let mut buf = [0_u8; 2048];+ let _ = socket.read(&mut buf).await;+ socket+ .write_all(b"HTTP/1.1 401 Unauthorized\r\nContent-Length: 0\r\n\r\n")+ .await+ .unwrap();+ });++ let err = match connect_with_timeout(+ &format!("ws://{addr}/backend-api/codex/responses"),+ &HeaderMap::new(),+ 1_000,+ )+ .await+ {+ Ok(_) => panic!("expected unauthorized websocket handshake to fail"),+ Err(err) => err,+ };++ assert_eq!(err.status, 401);+ assert_eq!(err.detail, None);+ assert_eq!(err.origin, CodexErrorOrigin::WebSocket);+ }++ #[tokio::test]+ async fn binary_frame_invalidates_pool_key() {+ clear_codex_websocket_pool_for_tests();+ let pooled_stream = create_dummy_stream_async().await;+ {+ let mut guard = WS_POOL.lock().unwrap();+ guard.insert(+ "binary-session".to_string(),+ Arc::new(PoolEntry {+ ws: AsyncMutex::new(pooled_stream),+ created_at: now_ms(),+ }),+ );+ }++ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();+ let addr = listener.local_addr().unwrap();+ tokio::spawn(async move {+ let (stream, _) = listener.accept().await.unwrap();+ let mut ws = tokio_tungstenite::accept_async(stream).await.unwrap();+ ws.send(Message::Binary(vec![1, 2, 3])).await.unwrap();+ });++ let (mut ws, _) = tokio_tungstenite::connect_async(format!("ws://{addr}/"))+ .await+ .unwrap();+ let err = match collect_ws_events(&mut ws, 1_000, Some("binary-session"), None).await {+ Ok(_) => panic!("expected binary frame to fail"),+ Err(err) => err,+ };++ assert!(err.message.contains("binary frames"));+ assert!(!WS_POOL.lock().unwrap().contains_key("binary-session"));+ }++ async fn create_dummy_stream_async() -> WebSocketStream<MaybeTlsStream<TcpStream>> {+ use tokio::net::TcpListener;++ let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();+ let addr = listener.local_addr().unwrap();+ tokio::spawn(async move {+ let (socket, _) = listener.accept().await.unwrap();+ let _ = tokio_tungstenite::accept_async(socket).await;+ futures_util::future::pending::<()>().await;+ });+ let url = format!("ws://{addr}/");+ let (ws, _) = tokio::time::timeout(+ Duration::from_millis(1000),+ tokio_tungstenite::connect_async(&url),+ )+ .await+ .unwrap()+ .unwrap();+ ws+ }+fn create_dummy_stream() -> WebSocketStream<MaybeTlsStream<TcpStream>> {// Use a connected TcpStream pair with connect_async which returns// WebSocketStream<MaybeTlsStream<TcpStream>>