mirror of
https://github.com/openai/codex.git
synced 2026-11-17 22:10:37 +00:00
## Why `features.respect_system_proxy` already routes authentication traffic through the OS proxy APIs, but it does not affect the primary inference path. That leaves users behind OS-managed proxies unable to send normal Responses API requests even after login succeeds. This PR is the first product-path migration onto the route-aware transport introduced in #31323 and refined in #31331. It also establishes the construction pattern for later migrations: the effective feature state is resolved once into a required HTTP client factory rather than represented by an optional per-call setting. The scope remains limited to the two HTTP Responses endpoints; WebSockets, model discovery, memories, realtime, and file uploads remain follow-up migrations. ## What changed - Replace the optional proxy marker with an explicit `OutboundProxyPolicy::{ReqwestDefault, RespectSystemProxy}` and a required `HttpClientFactory`. The policy has no default, and the lower-level route-aware reqwest builder is now private. - Have `Config` construct the factory from the effective feature state and require every `ModelClient` constructor to receive it. There is no optional setter or implicit `None` fallback. - Build HTTP clients for `/responses` and `/responses/compact` with `ClientRouteClass::Api`, using the complete destination URL so PAC rules can make URL-specific decisions. - Layer route-aware selection onto Codex's existing default headers, Cloudflare cookie store, custom CA handling, and sandbox no-proxy behavior. - Add an integration test that loads `features.respect_system_proxy` through `config.toml`, creates a real Codex session, and verifies that both a normal Responses turn and remote compaction reach an isolated local proxy. ## Review guide 1. `http-client/src/outbound_proxy.rs` defines the mandatory policy/factory boundary and keeps route resolution private. 2. `core/src/config/mod.rs`, `core/src/session/session.rs`, and `core/src/client.rs` show the compile-time invariant: effective config creates the factory, and `ModelClient` cannot be constructed without one. 3. `login/src/auth/default_client.rs` preserves existing default-client behavior while accepting the required factory for migrated routes. 4. `core/src/client.rs` switches only streaming Responses and remote compaction HTTP transports to the API route class. 5. `core/tests/suite/responses_api_system_proxy.rs` is the behavioral regression boundary. Its Linux subprocess deliberately sets the CGI marker that disables reqwest's implicit environment-proxy handling, so the test fails if session wiring or either Responses call site falls back to the default client. ## Test plan - `cargo check --tests -p codex-http-client -p codex-login -p codex-core` - `just test -p codex-login` - `just test -p codex-core respect_system_proxy_feature_resolves_enabled` - Existing `compact_uses_bearer_after_agent_identity_session_fallback` coverage passes with the new transport construction. - New Linux integration coverage: `responses_and_compact_use_enabled_system_proxy` - `just bazel-lock-check` --- [//]: # (BEGIN SAPLING FOOTER) Stack created with [Sapling](https://sapling-scm.com). Best reviewed with [ReviewStack](https://reviewstack.dev/openai/codex/pull/31335). * #31342 * __->__ #31335
214 lines
6.8 KiB
Rust
214 lines
6.8 KiB
Rust
//! Shared outbound proxy policy tests.
|
|
|
|
use super::*;
|
|
use pretty_assertions::assert_eq;
|
|
use std::io::Read;
|
|
use std::io::Write;
|
|
|
|
struct MapEnv {
|
|
values: HashMap<String, String>,
|
|
}
|
|
|
|
impl EnvSource for MapEnv {
|
|
fn var(&self, key: &str) -> Option<String> {
|
|
self.values.get(key).cloned()
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn proxy_env_value_matches_reqwest_casing_precedence() {
|
|
let env = MapEnv {
|
|
values: HashMap::from([
|
|
("HTTPS_PROXY".to_string(), "upper".to_string()),
|
|
("https_proxy".to_string(), "lower".to_string()),
|
|
("http_proxy".to_string(), "lower-only".to_string()),
|
|
("ALL_PROXY".to_string(), String::new()),
|
|
("all_proxy".to_string(), "masked".to_string()),
|
|
]),
|
|
};
|
|
|
|
assert_eq!(
|
|
proxy_env_value(&env, "HTTPS_PROXY"),
|
|
Some("upper".to_string())
|
|
);
|
|
assert_eq!(
|
|
proxy_env_value(&env, "HTTP_PROXY"),
|
|
Some("lower-only".to_string())
|
|
);
|
|
assert_eq!(proxy_env_value(&env, "ALL_PROXY"), None);
|
|
}
|
|
|
|
#[test]
|
|
fn environment_fallback_reads_injected_proxy_environment() {
|
|
let env = MapEnv {
|
|
values: HashMap::from([("HTTPS_PROXY".to_string(), "://invalid".to_string())]),
|
|
};
|
|
let origin = RequestOrigin::parse("https://auth.openai.com/oauth/token").expect("valid URL");
|
|
let result = configure_env_proxy_handling(
|
|
&env,
|
|
reqwest::Client::builder(),
|
|
Some(&origin),
|
|
ClientRouteClass::Auth,
|
|
);
|
|
|
|
assert!(matches!(
|
|
result,
|
|
Err(BuildRouteAwareHttpClientError::InvalidProxyConfig {
|
|
route_class: ClientRouteClass::Auth,
|
|
})
|
|
));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn enabled_environment_proxy_routes_request_through_proxy() {
|
|
let listener =
|
|
std::net::TcpListener::bind(("127.0.0.1", 0)).expect("local proxy listener should bind");
|
|
let proxy_addr = listener
|
|
.local_addr()
|
|
.expect("local proxy listener should have an address");
|
|
let proxy_thread = std::thread::spawn(move || {
|
|
let (mut stream, _) = listener.accept().expect("proxy should accept a request");
|
|
let mut buffer = [0_u8; 4096];
|
|
let size = stream.read(&mut buffer).expect("proxy should read request");
|
|
stream
|
|
.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\nok")
|
|
.expect("proxy should write response");
|
|
String::from_utf8_lossy(&buffer[..size]).into_owned()
|
|
});
|
|
let env = MapEnv {
|
|
values: HashMap::from([("HTTP_PROXY".to_string(), format!("http://{proxy_addr}"))]),
|
|
};
|
|
let request_url = "http://enabled-proxy.test/proxy-check";
|
|
let builder = configure_proxy_for_route(
|
|
&env,
|
|
reqwest::Client::builder().timeout(Duration::from_secs(2)),
|
|
request_url,
|
|
ClientRouteClass::Auth,
|
|
OutboundProxyPolicy::RespectSystemProxy,
|
|
|_, _| SystemProxyDecision::Unavailable {
|
|
failure: RouteFailureClass::ProxyResolutionUnavailable,
|
|
},
|
|
)
|
|
.expect("enabled proxy route should configure");
|
|
|
|
let response = builder
|
|
.build()
|
|
.expect("proxy client should build")
|
|
.get(request_url)
|
|
.send()
|
|
.await
|
|
.expect("request should use local proxy");
|
|
let proxy_request = proxy_thread.join().expect("proxy thread should finish");
|
|
|
|
assert_eq!(response.status(), reqwest::StatusCode::OK);
|
|
assert_eq!(
|
|
proxy_request.lines().next(),
|
|
Some("GET http://enabled-proxy.test/proxy-check HTTP/1.1")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn parses_pac_proxy_tokens() {
|
|
assert_eq!(
|
|
parse_proxy_list("PROXY proxy.internal:8080; DIRECT", "https"),
|
|
ParsedProxyListDecision::Proxy("http://proxy.internal:8080".to_string())
|
|
);
|
|
assert_eq!(
|
|
parse_proxy_list("HTTPS proxy.internal:8443", "https"),
|
|
ParsedProxyListDecision::Proxy("https://proxy.internal:8443".to_string())
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn unavailable_system_proxy_decision_is_cached() {
|
|
let request_url = "https://unavailable-cache.test/oauth/token";
|
|
let decision = SystemProxyDecision::Unavailable {
|
|
failure: RouteFailureClass::ProxyResolutionUnavailable,
|
|
};
|
|
|
|
cache_system_proxy_decision(request_url, decision.clone());
|
|
|
|
assert_eq!(cached_system_proxy_decision(request_url), Some(decision));
|
|
}
|
|
|
|
#[test]
|
|
fn system_proxy_cache_is_bounded() {
|
|
let mut cache = HashMap::new();
|
|
let now = Instant::now();
|
|
|
|
for index in 0..=SYSTEM_PROXY_CACHE_MAX_ENTRIES {
|
|
insert_system_proxy_cache_entry(
|
|
&mut cache,
|
|
&format!("https://bounded-cache.test/{index}"),
|
|
SystemProxyDecision::Direct,
|
|
now,
|
|
);
|
|
}
|
|
|
|
assert_eq!(cache.len(), SYSTEM_PROXY_CACHE_MAX_ENTRIES);
|
|
}
|
|
|
|
#[test]
|
|
fn parses_static_winhttp_proxy_entries_for_target_scheme() {
|
|
assert_eq!(
|
|
parse_proxy_list("http=web-proxy:8080;https=secure-proxy:8443", "https"),
|
|
ParsedProxyListDecision::Proxy("http://secure-proxy:8443".to_string())
|
|
);
|
|
assert_eq!(
|
|
parse_proxy_list("http=web-proxy:8080 https=secure-proxy:8443", "https"),
|
|
ParsedProxyListDecision::Proxy("http://secure-proxy:8443".to_string())
|
|
);
|
|
assert_eq!(
|
|
parse_proxy_list("http=web-proxy:8080", "https"),
|
|
ParsedProxyListDecision::Unavailable
|
|
);
|
|
assert_eq!(
|
|
parse_proxy_list("proxy.internal:8080", "https"),
|
|
ParsedProxyListDecision::Proxy("http://proxy.internal:8080".to_string())
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn reports_direct_and_unsupported_proxy_tokens() {
|
|
assert_eq!(
|
|
parse_proxy_list("DIRECT; PROXY proxy.internal:8080", "https"),
|
|
ParsedProxyListDecision::Direct
|
|
);
|
|
assert_eq!(
|
|
parse_proxy_list("DIRECT", "https"),
|
|
ParsedProxyListDecision::Direct
|
|
);
|
|
assert_eq!(
|
|
parse_proxy_list("SOCKS proxy.internal:1080", "https"),
|
|
ParsedProxyListDecision::UnsupportedScheme
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn no_proxy_matches_exact_suffix_wildcard_and_port() {
|
|
let origin = RequestOrigin {
|
|
scheme: "https".to_string(),
|
|
host: "auth.openai.com".to_string(),
|
|
port: 443,
|
|
};
|
|
assert!(no_proxy_matches_origin("auth.openai.com", &origin));
|
|
assert!(!no_proxy_matches_origin("openai.com", &origin));
|
|
assert!(no_proxy_matches_origin(".openai.com", &origin));
|
|
assert!(no_proxy_matches_origin("*.openai.com", &origin));
|
|
assert!(no_proxy_matches_origin("auth.openai.com:443", &origin));
|
|
assert!(!no_proxy_matches_origin("auth.openai.com:8443", &origin));
|
|
}
|
|
|
|
#[test]
|
|
fn system_proxy_cache_key_preserves_url_specific_pac_decisions() {
|
|
let request_url = "https://auth.openai.com/oauth/token?access_token=secret";
|
|
let cache_key = system_proxy_cache_key(request_url);
|
|
|
|
assert_ne!(
|
|
cache_key,
|
|
system_proxy_cache_key("https://auth.openai.com/oauth/revoke")
|
|
);
|
|
#[cfg(any(target_os = "windows", target_os = "macos"))]
|
|
assert!(!cache_key.contains(request_url));
|
|
}
|