Lightweight coding agent that runs in your terminal
Rust
Preserve account network policy for ChatGPT backend requests (#47703)
jackzd04b0561d354
diff --git a/codex-rs/app-server/src/request_processors/apps_processor/read.rs b/codex-rs/app-server/src/request_processors/apps_processor/read.rsindex 276633bd89..21ab3c8084 100644--- a/codex-rs/app-server/src/request_processors/apps_processor/read.rs+++ b/codex-rs/app-server/src/request_processors/apps_processor/read.rs@@ -26,8 +26,14 @@ impl AppsRequestProcessor {.into_iter().filter(|app_id| seen_app_ids.insert(app_id.clone())).collect::<Vec<_>>();- let config = self.load_apps_config(thread_id.as_deref()).await?;- let auth = self.auth_manager.auth().await;+ let mut config = self.load_apps_config(thread_id.as_deref()).await?;+ let auth = match self.auth_manager.auth_with_http_client_factory().await {+ Some((auth, factory)) => {+ config.application_network_policy = factory.network_policy().clone();+ Some(auth)+ }+ None => None,+ };if !config.features.apps_enabled_for_auth(auth.as_ref().is_some_and(CodexAuth::uses_codex_backend))diff --git a/codex-rs/app-server/src/request_processors/plugins.rs b/codex-rs/app-server/src/request_processors/plugins.rsindex 8ecbdb391c..437dc38586 100644--- a/codex-rs/app-server/src/request_processors/plugins.rs+++ b/codex-rs/app-server/src/request_processors/plugins.rs@@ -1021,9 +1021,15 @@ impl PluginRequestProcessor {marketplace_path.as_path().parent().map(Path::to_path_buf)});- let config = self.load_latest_config(config_cwd).await?;+ let mut config = self.load_latest_config(config_cwd).await?;+ let auth = match self.auth_manager.auth_with_http_client_factory().await {+ Some((auth, factory)) => {+ config.application_network_policy = factory.network_policy().clone();+ Some(auth)+ }+ None => None,+ };let plugins_input = config.plugins_config_input();- let auth = self.auth_manager.auth().await;let plugin = match read_source {Ok(marketplace_path) => {@@ -1483,8 +1489,14 @@ impl PluginRequestProcessor {}};let config_cwd = marketplace_path.as_path().parent().map(Path::to_path_buf);- let config = self.load_latest_config(config_cwd.clone()).await?;- let auth = self.auth_manager.auth().await;+ let mut config = self.load_latest_config(config_cwd.clone()).await?;+ let auth = match self.auth_manager.auth_with_http_client_factory().await {+ Some((auth, factory)) => {+ config.application_network_policy = factory.network_policy().clone();+ Some(auth)+ }+ None => None,+ };let plugins_manager = self.thread_manager.plugins_manager();let marketplace_display = marketplace_path.display().to_string();@@ -1509,7 +1521,11 @@ impl PluginRequestProcessor {}};let config = match self.load_latest_config(config_cwd).await {- Ok(config) => config,+ Ok(mut reloaded_config) => {+ // Keep the policy captured with this installation's auth snapshot.+ reloaded_config.application_network_policy = config.application_network_policy;+ reloaded_config+ }Err(err) => {warn!("failed to reload config after plugin install, using current config: {err:?}"@@ -1564,8 +1580,14 @@ impl PluginRequestProcessor {remote_plugin_id: String,install_attempt_id: Option<String>,) -> Result<PluginInstallResponse, JSONRPCErrorError> {- let config = self.load_latest_config(/*fallback_cwd*/ None).await?;- let auth = self.auth_manager.auth().await;+ let mut config = self.load_latest_config(/*fallback_cwd*/ None).await?;+ let auth = match self.auth_manager.auth_with_http_client_factory().await {+ Some((auth, factory)) => {+ config.application_network_policy = factory.network_policy().clone();+ Some(auth)+ }+ None => None,+ };let plugins_manager = self.thread_manager.plugins_manager();let installation = plugins_manager.install_remote_plugin(diff --git a/codex-rs/app-server/tests/suite/v2/app_read.rs b/codex-rs/app-server/tests/suite/v2/app_read.rsindex 4f147d42bd..058c51dde3 100644--- a/codex-rs/app-server/tests/suite/v2/app_read.rs+++ b/codex-rs/app-server/tests/suite/v2/app_read.rs@@ -26,7 +26,15 @@ use codex_app_server_protocol::LoginAccountResponse;use codex_app_server_protocol::RequestId;use codex_app_server_protocol::ThreadStartParams;use codex_app_server_protocol::ThreadStartResponse;+use codex_chatgpt::connectors;+use codex_config::LoaderOverrides;use codex_config::types::AuthCredentialsStoreMode;+use codex_core::config::ConfigBuilder;+use codex_http_client::DestinationPolicy;+use codex_http_client::HttpError;+use codex_http_client::NetworkPolicyController;+use codex_http_client::NetworkPolicyDenied;+use codex_login::AuthManager;use pretty_assertions::assert_eq;use serde_json::Value;use serde_json::json;@@ -85,6 +93,108 @@ fn app_read_deserializes_legacy_tool_summaries() -> Result<()> {Ok(())}+#[tokio::test]+async fn connector_requests_preserve_account_policy() -> Result<()> {+ let state = BatchServerState::new(json!({ "apps": [] }), "chatgpt-token", "codex");+ let (server_url, server_handle) = start_batch_server(state.clone()).await?;+ let home = TempDir::new()?;+ write_apps_config(home.path(), &server_url, /*apps_mcp_product_sku*/ None)?;+ write_auth(home.path())?;+ let mut config = ConfigBuilder::default()+ .codex_home(home.path().to_path_buf())+ .fallback_cwd(Some(home.path().to_path_buf()))+ .loader_overrides(LoaderOverrides::without_managed_config_for_tests())+ .build()+ .await?;+ let controller = NetworkPolicyController::default();+ let policy = controller.policy();+ controller.publish(policy.revision(), DestinationPolicy::Unrestricted);+ config.application_network_policy = policy.clone();+ let manager =+ AuthManager::shared_from_config(&config, /*enable_codex_api_key_env*/ false).await?;+ let (auth, factory) = manager.auth_with_http_client_factory().await.unwrap();+ config.application_network_policy = factory.network_policy().clone();+ let app_ids = vec!["alpha".to_string()];+ connectors::read_connector_metadata(&config, &auth, &app_ids, /*include_tools*/ false).await?;+ assert_eq!(state.requests().len(), 1);++ policy.invalidate();+ controller.publish(policy.revision(), DestinationPolicy::Unrestricted);+ let error = timeout(+ DEFAULT_TIMEOUT,+ connectors::read_connector_metadata(&config, &auth, &app_ids, /*include_tools*/ false),+ )+ .await?+ .err()+ .expect("old credentials must retain their revoked policy");+ assert!(matches!(+ error.downcast_ref::<HttpError>(),+ Some(HttpError::Policy(NetworkPolicyDenied::Revoked))+ ));+ assert_eq!(state.requests().len(), 1);++ controller.publish(+ policy.revision(),+ DestinationPolicy::Restricted {+ allowed_hosts: Default::default(),+ },+ );+ let error = timeout(+ DEFAULT_TIMEOUT,+ connectors::list_all_connectors_with_options(&config, /*force_refetch*/ true, &[]),+ )+ .await?+ .unwrap_err();+ assert!(matches!(+ error.downcast_ref::<HttpError>(),+ Some(HttpError::Policy(NetworkPolicyDenied::Destination))+ ));+ server_handle.abort();+ Ok(())+}++#[tokio::test]+async fn app_read_applies_network_policy_to_cached_client_after_reload() -> Result<()> {+ let state = BatchServerState::new(json!({ "apps": [] }), "chatgpt-token", "codex");+ let (server_url, server_handle) = start_batch_server(state.clone()).await?;+ let home = TempDir::new()?;+ write_apps_config(home.path(), &server_url, /*apps_mcp_product_sku*/ None)?;+ write_auth(home.path())?;+ let mut app = TestAppServer::builder()+ .with_codex_home(home.path())+ .without_auto_env()+ .build_initialized_with_timeout(DEFAULT_TIMEOUT)+ .await?;+ read_apps(&mut app, vec!["alpha"], /*include_tools*/ false).await?;+ assert_eq!(state.requests().len(), 1);++ std::fs::write(+ home.path().join("requirements.toml"),+ "[application.network]",+ )?;+ let reload_id = app.send_request("config/read", Some(json!({}))).await?;+ let _: Value = timeout(DEFAULT_TIMEOUT, app.read_response(reload_id)).await??;+ let request_id = app+ .send_apps_read_request(AppsReadParams {+ app_ids: vec!["alpha".to_string()],+ thread_id: None,+ include_tools: false,+ })+ .await?;+ let error = timeout(+ DEFAULT_TIMEOUT,+ app.read_stream_until_error_message(RequestId::Integer(request_id)),+ )+ .await??;+ assert_eq!(+ error.error.message,+ "failed to read app metadata: Failed to send request"+ );+ assert_eq!(state.requests().len(), 1);+ server_handle.abort();+ Ok(())+}+#[tokio::test]async fn app_read_deduplicates_orders_partial_misses_and_reuses_cached_metadata() -> Result<()> {let access_token = encode_id_token(diff --git a/codex-rs/chatgpt/src/chatgpt_client.rs b/codex-rs/chatgpt/src/chatgpt_client.rsindex 2e6feb8256..c56f8b9b27 100644--- a/codex-rs/chatgpt/src/chatgpt_client.rs+++ b/codex-rs/chatgpt/src/chatgpt_client.rs@@ -4,7 +4,6 @@ use codex_http_client::HttpClientFactory;use codex_login::AuthManager;use codex_login::CodexAuth;use codex_login::default_client::RESIDENCY_HEADER_NAME;-use codex_login::default_client::create_client;use codex_login::default_client::create_client_with_chatgpt_cookies;use codex_login::default_client::default_headers;@@ -24,15 +23,15 @@ struct CachedChatGptClient {client: HttpClient,}-static PSP_CHATGPT_CLIENT: LazyLock<Mutex<Option<CachedChatGptClient>>> =+static CHATGPT_CLIENT: LazyLock<Mutex<Option<CachedChatGptClient>>> =LazyLock::new(|| Mutex::new(None));-/// Reuse the default client while retaining its configured ChatGPT cookies.-fn psp_chatgpt_client(factory: HttpClientFactory) -> HttpClient {+/// Reuse the client and cookies without changing the caller's captured account policy.+fn chatgpt_client(factory: HttpClientFactory) -> HttpClient {let residency = default_headers().get(RESIDENCY_HEADER_NAME).map(|value| value.as_bytes().to_vec());- let mut cached = PSP_CHATGPT_CLIENT+ let mut cached = CHATGPT_CLIENT.lock().unwrap_or_else(std::sync::PoisonError::into_inner);if let Some(cached_client) = cached.as_ref()@@ -64,6 +63,12 @@ pub(crate) async fn chatgpt_get_request_with_timeout<T: DeserializeOwned>(path: String,timeout: Option<Duration>,) -> anyhow::Result<T> {+ // Bind before loading credentials: the temporary auth manager does not own account changes.+ let policy = config+ .application_network_policy+ .clone()+ .for_current_account();+ let client = chatgpt_client(config.http_client_factory().with_network_policy(policy));let chatgpt_base_url = &config.chatgpt_base_url;let auth_manager =AuthManager::shared_from_config(config, /*enable_codex_api_key_env*/ false).await?;@@ -79,19 +84,12 @@ pub(crate) async fn chatgpt_get_request_with_timeout<T: DeserializeOwned>(auth.get_account_id().is_some(),"ChatGPT account ID not available, please re-run `codex login`");-let url = format!("{}/{}",chatgpt_base_url.trim_end_matches('/'),path.trim_start_matches('/'));- let http_client_factory = config.http_client_factory();- let client = if http_client_factory.has_chatgpt_cookies() {- psp_chatgpt_client(http_client_factory)- } else {- create_client()- };let mut request = client.get(&url).headers(default_headers())@@ -118,8 +116,8 @@ pub(crate) async fn chatgpt_get_request_with_timeout<T: DeserializeOwned>(/// Make a POST request to the ChatGPT backend API with an already-captured auth identity.///-/// Callers that bind other state to the auth snapshot should pass that same snapshot here rather-/// than reacquiring auth while the request is in flight.+/// Callers must capture `auth` and `config.application_network_policy` together and preserve+/// that snapshot rather than reacquiring either while the request is in flight.pub(crate) async fn chatgpt_post_request_with_timeout<TResponse: DeserializeOwned,TRequest: Serialize + ?Sized,@@ -145,12 +143,7 @@ pub(crate) async fn chatgpt_post_request_with_timeout<config.chatgpt_base_url.trim_end_matches('/'),path.trim_start_matches('/'));- let http_client_factory = config.http_client_factory();- let client = if http_client_factory.has_chatgpt_cookies() {- psp_chatgpt_client(http_client_factory)- } else {- create_client()- };+ let client = chatgpt_client(config.http_client_factory());let response = client.post(&url).headers(default_headers())diff --git a/codex-rs/chatgpt/src/connectors.rs b/codex-rs/chatgpt/src/connectors.rsindex ae6cbce5c8..6b30a73936 100644--- a/codex-rs/chatgpt/src/connectors.rs+++ b/codex-rs/chatgpt/src/connectors.rs@@ -134,6 +134,8 @@ pub struct ConnectorMetadataReadResult {////// The store is created before awaiting the backend request, so a response that arrives after an/// account or backend change can only commit to the scope under which it was requested.+/// Capture `auth` and `config.application_network_policy` together using+/// `AuthManager::auth_with_http_client_factory` so the request retains that account's policy.pub async fn read_connector_metadata(config: &Config,auth: &CodexAuth,diff --git a/codex-rs/login/src/auth/default_client.rs b/codex-rs/login/src/auth/default_client.rsindex a8c6c1c18c..28a952ea2d 100644--- a/codex-rs/login/src/auth/default_client.rs+++ b/codex-rs/login/src/auth/default_client.rs@@ -218,13 +218,28 @@ pub fn create_client() -> HttpClient {build_default_client(default_http_client_builder())}-/// Creates the default client with configured ChatGPT cookies and no sensitive-response logging.+/// Creates an API client retaining managed policy, ChatGPT cookies, and no request diagnostics.pub fn create_client_with_chatgpt_cookies(http_client_factory: &HttpClientFactory) -> HttpClient {- build_default_client(- default_http_client_builder()- .with_chatgpt_cookies(http_client_factory)- .without_request_logging(),- )+ let builder = default_http_client_builder()+ .with_chatgpt_cookies(http_client_factory)+ .without_request_logging();+ if !http_client_factory.network_policy().is_managed() {+ return build_default_client(builder);+ }+ let mut pool = RouteAwareClientPool::with_builder(+ http_client_factory.clone(),+ ClientRouteClass::Api,+ builder,+ );+ if is_sandboxed() {+ pool = pool.with_legacy_direct_proxy_and_custom_ca_fallback();+ } else if matches!(+ http_client_factory.outbound_proxy_policy(),+ OutboundProxyPolicy::ReqwestDefault+ ) {+ pool = pool.with_legacy_custom_ca_fallback();+ }+ pool.into_client()}/// Create the default HTTP client without request URL or response-header diagnostics.