Skip to content

The design language that makes your AI harness better at design.

JavaScript

Fix: honor proxy environment variables in native downloads (#823) (#826)

Abdul Wahabebeb3621b453
diff --git a/Cargo.lock b/Cargo.lock
index 39ab9f98e..483efc3ad 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -71,6 +71,12 @@ version = "1.25.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "95832e849adfb21180ccb6826a99da14e5d266ae5c2e668e1602cf234f153797"
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
[[package]]
name = "byteorder-lite"
version = "0.1.0"
@@ -1341,6 +1347,17 @@ version = "1.16.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b9be42f50aa861c555654aa3a37f52f4b1074bacf4e48fe0ef7fa584e80f1f0f"
+[[package]]
+name = "socks"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0c3dbbd9ae980613c6dd8e28a9407b50509d3803b57624d5dfe8315218cd58b"
+dependencies = [
+ "byteorder",
+ "libc",
+ "winapi",
+]
+
[[package]]
name = "stable_deref_trait"
version = "1.2.1"
@@ -1533,6 +1550,7 @@ dependencies = [
"rustls-pki-types",
"serde",
"serde_json",
+ "socks",
"url",
"webpki-roots 0.26.11",
]
@@ -1663,6 +1681,28 @@ version = "0.1.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88"
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
[[package]]
name = "windows-link"
version = "0.2.1"
diff --git a/crates/context/Cargo.toml b/crates/context/Cargo.toml
index d3a919d41..c57e546f9 100644
--- a/crates/context/Cargo.toml
+++ b/crates/context/Cargo.toml
@@ -21,7 +21,7 @@ regex = { workspace = true }
once_cell = { workspace = true }
sha2 = "0.10"
flate2 = { version = "1", default-features = false, features = ["zlib-rs"] }
-ureq = { version = "2", default-features = false, features = ["tls", "json"] }
+ureq = { version = "2", default-features = false, features = ["tls", "json", "socks-proxy"] }
rustls-native-certs = "0.8"
webpki-roots = "1"
tiny_http = "0.12"
diff --git a/crates/context/src/generate_image.rs b/crates/context/src/generate_image.rs
index 8767dbfea..7e08983bd 100644
--- a/crates/context/src/generate_image.rs
+++ b/crates/context/src/generate_image.rs
@@ -498,6 +498,7 @@ mod tests {
use std::time::Duration;
fn round_trip(edit: bool, override_model: Option<&str>, background: Option<&str>) {
+ let _proxy_lock = crate::http::PROXY_ENV_LOCK.lock().unwrap();
let server = tiny_http::Server::http("127.0.0.1:0").unwrap();
let api_base = format!("http://{}", server.server_addr());
let temp = std::env::temp_dir().join(format!("impeccable-image-{}-{}", std::process::id(), server.server_addr().to_ip().unwrap().port()));
diff --git a/crates/context/src/http.rs b/crates/context/src/http.rs
index c5423984d..2081b2764 100644
--- a/crates/context/src/http.rs
+++ b/crates/context/src/http.rs
@@ -15,18 +15,30 @@
//! fails to load, verifies against the bundled roots exactly as before.
//! `SSL_CERT_FILE` / `SSL_CERT_DIR` stand in for the OS store, as they do
//! for OpenSSL and curl; the bundled roots stay either way.
+//!
+//! The shared agent builder also honors `ALL_PROXY`, `HTTPS_PROXY`, and
+//! `HTTP_PROXY` (and their lowercase forms) so `update` and `install` work
+//! behind a corporate proxy (#823). Live-mode localhost HTTP does not use
+//! this builder. The `socks-proxy` feature is enabled because ureq 2.x
+//! prefers `ALL_PROXY`, which is often `socks5://`. We opt in on this
+//! builder only, not globally via ureq's `proxy-from-env` feature.
use std::sync::Arc;
+#[cfg(test)]
+pub(crate) static PROXY_ENV_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
+
use once_cell::sync::Lazy;
use ureq::rustls::pki_types::CertificateDer;
use ureq::rustls::{self, ClientConfig, RootCertStore};
-/// `ureq::AgentBuilder::new()` with the engine's trust store installed.
-/// Every HTTPS call site builds its agent from this; the plain-HTTP calls
-/// to the live server on localhost do not need it.
+/// `ureq::AgentBuilder::new()` with the engine's trust store installed and
+/// env proxy vars honored. Every HTTPS call site builds its agent from this;
+/// the plain-HTTP calls to the live server on localhost do not use it.
pub fn agent_builder() -> ureq::AgentBuilder {
- ureq::AgentBuilder::new().tls_config(tls_config())
+ ureq::AgentBuilder::new()
+ .tls_config(tls_config())
+ .try_proxy_from_env(true)
}
fn tls_config() -> Arc<ClientConfig> {
@@ -99,6 +111,223 @@ tB0WGTOG3QIgdJa8gBPU9Y6WsrursItsnUeGTYHKDCZZ6MjlekLFuoc=
fn agent_builds_from_this_hosts_store() {
// Runs the real rustls-native-certs load: it must not panic, and the
// shared config must be accepted by a ureq agent.
+ let _lock = PROXY_ENV_LOCK.lock().unwrap();
let _agent = agent_builder().build();
}
+
+ struct ProxyEnvGuard {
+ saved: Vec<(String, Option<String>)>,
+ }
+
+ impl ProxyEnvGuard {
+ fn set(vars: &[(&str, Option<&str>)]) -> Self {
+ let saved = vars
+ .iter()
+ .map(|(key, _)| (key.to_string(), std::env::var(key).ok()))
+ .collect();
+ for (key, value) in vars {
+ match value {
+ // SAFETY: PROXY_ENV_LOCK serializes every test that
+ // reads or writes these process-global proxy vars.
+ Some(v) => unsafe { std::env::set_var(key, v) },
+ None => unsafe { std::env::remove_var(key) },
+ }
+ }
+ Self { saved }
+ }
+ }
+
+ impl Drop for ProxyEnvGuard {
+ fn drop(&mut self) {
+ for (key, value) in &self.saved {
+ match value {
+ // SAFETY: same lock as set(); restore before unlock.
+ Some(v) => unsafe { std::env::set_var(key, v) },
+ None => unsafe { std::env::remove_var(key) },
+ }
+ }
+ }
+ }
+
+ fn accept_until(
+ listener: std::net::TcpListener,
+ mut handle: impl FnMut(&mut std::net::TcpStream) -> bool,
+ ) {
+ use std::time::Duration;
+ listener
+ .set_nonblocking(true)
+ .expect("nonblocking proxy listener");
+ let deadline = std::time::Instant::now() + Duration::from_secs(5);
+ while std::time::Instant::now() < deadline {
+ let Ok((mut stream, _)) = listener.accept() else {
+ std::thread::sleep(Duration::from_millis(10));
+ continue;
+ };
+ let _ = stream.set_nonblocking(false);
+ let _ = stream.set_read_timeout(Some(std::time::Duration::from_secs(2)));
+ let _ = stream.set_write_timeout(Some(std::time::Duration::from_secs(2)));
+ if handle(&mut stream) {
+ return;
+ }
+ }
+ }
+
+ #[test]
+ fn agent_honors_http_proxy_from_env() {
+ use std::io::{Read, Write};
+ use std::net::TcpListener;
+ use std::time::Duration;
+
+ let _lock = PROXY_ENV_LOCK.lock().unwrap();
+
+ let listener = TcpListener::bind("127.0.0.1:0").expect("bind proxy listener");
+ let proxy_addr = listener.local_addr().expect("proxy listener addr");
+
+ let request = std::sync::Arc::new(std::sync::Mutex::new(Vec::<u8>::new()));
+ let request_for_thread = request.clone();
+ let handle = std::thread::spawn(move || {
+ accept_until(listener, |stream| {
+ let mut buf = [0u8; 4096];
+ let n = stream.read(&mut buf).unwrap_or(0);
+ let chunk = &buf[..n];
+ if chunk.is_empty()
+ || !String::from_utf8_lossy(chunk).contains("proxy-test.invalid")
+ {
+ return false;
+ }
+ request_for_thread.lock().unwrap().extend_from_slice(chunk);
+ let _ = stream.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nok");
+ true
+ });
+ });
+
+ let proxy_url = format!("http://127.0.0.1:{}", proxy_addr.port());
+ let _env_guard = ProxyEnvGuard::set(&[
+ ("ALL_PROXY", None),
+ ("all_proxy", None),
+ ("HTTPS_PROXY", None),
+ ("https_proxy", None),
+ ("HTTP_PROXY", Some(&proxy_url)),
+ ("http_proxy", Some(&proxy_url)),
+ ]);
+
+ let agent = agent_builder()
+ .timeout(Duration::from_secs(2))
+ .build();
+ let response = agent.get("http://proxy-test.invalid/").call();
+ assert!(response.is_ok(), "expected proxy-routed GET to succeed");
+
+ handle.join().expect("proxy thread");
+
+ let request_bytes = request.lock().unwrap().clone();
+ let request_text = String::from_utf8_lossy(&request_bytes);
+ assert!(
+ request_text.contains("proxy-test.invalid"),
+ "proxy should receive request for target host, got: {request_text:?}"
+ );
+ }
+
+ #[test]
+ fn agent_honors_socks5_all_proxy_from_env() {
+ use std::io::{Read, Write};
+ use std::net::TcpListener;
+ use std::time::Duration;
+
+ fn socks5_then_http(stream: &mut std::net::TcpStream) -> Option<Vec<u8>> {
+ fn read_n(stream: &mut std::net::TcpStream, n: usize) -> Option<Vec<u8>> {
+ let mut buf = vec![0u8; n];
+ stream.read_exact(&mut buf).ok()?;
+ Some(buf)
+ }
+
+ let greet = read_n(stream, 2)?;
+ if greet[0] != 5 {
+ return None;
+ }
+ let _ = read_n(stream, greet[1] as usize)?;
+ stream.write_all(&[0x05, 0x00]).ok()?;
+
+ let req = read_n(stream, 4)?;
+ if req[0] != 5 || req[1] != 1 {
+ return None;
+ }
+ match req[3] {
+ 1 => {
+ let _ = read_n(stream, 6)?;
+ }
+ 3 => {
+ let len = read_n(stream, 1)?;
+ let _ = read_n(stream, len[0] as usize + 2)?;
+ }
+ 4 => {
+ let _ = read_n(stream, 18)?;
+ }
+ _ => return None,
+ }
+ stream
+ .write_all(&[0x05, 0x00, 0x00, 0x01, 0, 0, 0, 0, 0, 0])
+ .ok()?;
+
+ let mut chunk = Vec::new();
+ let mut buf = [0u8; 4096];
+ loop {
+ let n = stream.read(&mut buf).ok()?;
+ if n == 0 {
+ break;
+ }
+ chunk.extend_from_slice(&buf[..n]);
+ if String::from_utf8_lossy(&chunk).contains("proxy-test.invalid") {
+ break;
+ }
+ }
+ if !String::from_utf8_lossy(&chunk).contains("proxy-test.invalid") {
+ return None;
+ }
+ let _ = stream.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nok");
+ Some(chunk)
+ }
+
+ let _lock = PROXY_ENV_LOCK.lock().unwrap();
+
+ let listener = TcpListener::bind("127.0.0.1:0").expect("bind socks listener");
+ let proxy_addr = listener.local_addr().expect("socks listener addr");
+
+ let request = std::sync::Arc::new(std::sync::Mutex::new(Vec::<u8>::new()));
+ let request_for_thread = request.clone();
+ let handle = std::thread::spawn(move || {
+ accept_until(listener, |stream| {
+ if let Some(chunk) = socks5_then_http(stream) {
+ *request_for_thread.lock().unwrap() = chunk;
+ true
+ } else {
+ false
+ }
+ });
+ });
+
+ let proxy_url = format!("socks5://127.0.0.1:{}", proxy_addr.port());
+ let _env_guard = ProxyEnvGuard::set(&[
+ ("ALL_PROXY", Some(&proxy_url)),
+ ("all_proxy", Some(&proxy_url)),
+ ("HTTPS_PROXY", None),
+ ("https_proxy", None),
+ ("HTTP_PROXY", None),
+ ("http_proxy", None),
+ ]);
+
+ let agent = agent_builder()
+ .timeout(Duration::from_secs(2))
+ .build();
+ let response = agent.get("http://proxy-test.invalid/").call();
+ assert!(response.is_ok(), "expected SOCKS5-routed GET to succeed");
+
+ handle.join().expect("socks thread");
+
+ let request_bytes = request.lock().unwrap().clone();
+ let request_text = String::from_utf8_lossy(&request_bytes);
+ assert!(
+ request_text.contains("proxy-test.invalid"),
+ "SOCKS proxy should receive request for target host, got: {request_text:?}"
+ );
+ }
}