Route exec-server HTTP through configured proxy policy (#35023)

## Why Delegated HTTP requests need to honor the same outbound proxy policy as the Codex process that starts the exec server. ## What changed - Pass the configured `HttpClientFactory` through local and remote exec-server startup and use route-aware client pools for delegated HTTP and local MCP requests. - Preserve per-request timeouts and follow-or-stop redirect behavior while keeping request URLs and sensitive response headers out of diagnostics. ## Testing - Cover configured system-proxy routing across the exec-server transport. - Cover both redirect policies and verify that success and failure logs do not expose request or response secrets. GitOrigin-RevId: 4af6aec1d265c4db62dfcb6e1fb076fb31736137
2026-10-18 17:18:52 +00:00 · 2026-07-23 22:39:28 +00:00
parent fe0d472c4c
commit 1ee8f49175
25 changed files with 569 additions and 85 deletions
@@ -0,0 +1,174 @@
+use std::io::Write;
+use std::sync::Arc;
+use std::sync::Mutex;
+
+use codex_exec_server::HttpClient;
+use codex_exec_server::HttpRedirectPolicy;
+use codex_exec_server::HttpRequestParams;
+use codex_exec_server::ReqwestHttpClient;
+use codex_http_client::HttpClientFactory;
+use codex_http_client::OutboundProxyPolicy;
+use pretty_assertions::assert_eq;
+use tokio::io::AsyncBufReadExt;
+use tokio::io::AsyncWriteExt;
+use tokio::io::BufReader;
+use tokio::net::TcpListener;
+use tracing_subscriber::Layer;
+use tracing_subscriber::layer::SubscriberExt;
+
+#[tokio::test(flavor = "current_thread")]
+async fn delegated_http_success_logs_do_not_expose_sensitive_request_or_response_data()
+-> anyhow::Result<()> {
+    let log_buffer = Arc::new(Mutex::new(Vec::new()));
+    let writer_buffer = Arc::clone(&log_buffer);
+    let subscriber = tracing_subscriber::registry().with(
+        tracing_subscriber::fmt::layer()
+            .with_ansi(false)
+            .with_writer(move || TestLogWriter(Arc::clone(&writer_buffer)))
+            .with_filter(
+                tracing_subscriber::filter::Targets::new()
+                    .with_target("codex_http_client", tracing::Level::TRACE)
+                    .with_target("codex_exec_server", tracing::Level::TRACE),
+            ),
+    );
+    let _guard = tracing::subscriber::set_default(subscriber);
+    tracing::debug!(target: "codex_exec_server", "log capture sentinel");
+    let client =
+        ReqwestHttpClient::new(HttpClientFactory::new(OutboundProxyPolicy::ReqwestDefault));
+
+    for (redirect_policy, status, query_secret, cookie_secret, location_secret) in [
+        (
+            HttpRedirectPolicy::Follow,
+            "200 OK",
+            "follow-query-secret",
+            "follow-cookie-secret",
+            "follow-location-secret",
+        ),
+        (
+            HttpRedirectPolicy::Stop,
+            "302 Found",
+            "stop-query-secret",
+            "stop-cookie-secret",
+            "stop-location-secret",
+        ),
+    ] {
+        let listener = TcpListener::bind(("127.0.0.1", 0)).await?;
+        let address = listener.local_addr()?;
+        let response = format!(
+            "HTTP/1.1 {status}\r\nSet-Cookie: session={cookie_secret}\r\nLocation: http://127.0.0.1/private?token={location_secret}\r\nContent-Length: 2\r\nConnection: close\r\n\r\nok"
+        );
+        let server = tokio::spawn(async move {
+            let (stream, _) = listener.accept().await?;
+            let mut reader = BufReader::new(stream);
+            loop {
+                let mut line = String::new();
+                if reader.read_line(&mut line).await? == 0 {
+                    anyhow::bail!("HTTP client disconnected before completing request headers");
+                }
+                if line == "\r\n" {
+                    break;
+                }
+            }
+            reader.get_mut().write_all(response.as_bytes()).await?;
+            anyhow::Ok(())
+        });
+
+        let response = client
+            .http_request(HttpRequestParams {
+                method: "GET".to_string(),
+                url: format!("http://{address}/delegated?token={query_secret}"),
+                headers: Vec::new(),
+                body: None,
+                timeout_ms: Some(5_000),
+                redirect_policy,
+                request_id: "sensitive-request".to_string(),
+                stream_response: false,
+            })
+            .await?;
+        let expected_status = match redirect_policy {
+            HttpRedirectPolicy::Follow => 200,
+            HttpRedirectPolicy::Stop => 302,
+        };
+        assert_eq!(response.status, expected_status);
+        server.await??;
+    }
+
+    let logs = String::from_utf8(log_buffer.lock().expect("log buffer lock").clone())?;
+    assert!(logs.contains("log capture sentinel"));
+    for secret in [
+        "follow-query-secret",
+        "follow-cookie-secret",
+        "follow-location-secret",
+        "stop-query-secret",
+        "stop-cookie-secret",
+        "stop-location-secret",
+    ] {
+        assert!(!logs.contains(secret), "logs exposed {secret}:\n{logs}");
+    }
+
+    Ok(())
+}
+
+#[tokio::test(flavor = "current_thread")]
+async fn delegated_http_failure_warning_redacts_request_url() -> anyhow::Result<()> {
+    let log_buffer = Arc::new(Mutex::new(Vec::new()));
+    let writer_buffer = Arc::clone(&log_buffer);
+    let subscriber = tracing_subscriber::registry().with(
+        tracing_subscriber::fmt::layer()
+            .with_ansi(false)
+            .with_writer(move || TestLogWriter(Arc::clone(&writer_buffer)))
+            .with_filter(
+                tracing_subscriber::filter::Targets::new()
+                    .with_target("codex_http_client", tracing::Level::TRACE)
+                    .with_target("codex_exec_server", tracing::Level::TRACE),
+            ),
+    );
+    let _guard = tracing::subscriber::set_default(subscriber);
+    let unavailable_server = std::net::TcpListener::bind(("127.0.0.1", 0))?;
+    let unavailable_address = unavailable_server.local_addr()?;
+    drop(unavailable_server);
+    let client =
+        ReqwestHttpClient::new(HttpClientFactory::new(OutboundProxyPolicy::ReqwestDefault));
+
+    let error = client
+        .http_request(HttpRequestParams {
+            method: "GET".to_string(),
+            url: format!(
+                "http://{unavailable_address}/private-path-secret?token=failure-query-secret"
+            ),
+            headers: Vec::new(),
+            body: None,
+            timeout_ms: None,
+            redirect_policy: HttpRedirectPolicy::Follow,
+            request_id: "failed-sensitive-request".to_string(),
+            stream_response: false,
+        })
+        .await;
+    assert!(error.is_err(), "request to a closed port should fail");
+
+    let logs = String::from_utf8(log_buffer.lock().expect("log buffer lock").clone())?;
+    assert!(logs.contains("http/request send failed"));
+    assert!(logs.contains("error_is_connect=true"));
+    for secret in ["private-path-secret", "failure-query-secret"] {
+        assert!(!logs.contains(secret), "logs exposed {secret}:\n{logs}");
+    }
+
+    Ok(())
+}
+
+#[derive(Clone)]
+struct TestLogWriter(Arc<Mutex<Vec<u8>>>);
+
+impl Write for TestLogWriter {
+    fn write(&mut self, bytes: &[u8]) -> std::io::Result<usize> {
+        self.0
+            .lock()
+            .map_err(|_| std::io::Error::other("log buffer lock"))?
+            .extend_from_slice(bytes);
+        Ok(bytes.len())
+    }
+
+    fn flush(&mut self) -> std::io::Result<()> {
+        Ok(())
+    }
+}