Lightweight coding agent that runs in your terminal
Rust
Add managed network review domains before allow rules (#56154)
olliem-oai94350a910143
diff --git a/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.schemas.json b/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.schemas.jsonindex ba22b80fea..cf785c660d 100644--- a/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.schemas.json+++ b/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.schemas.json@@ -16282,6 +16282,16 @@"null"]},+ "reviewDomains": {+ "description": "Host patterns routed to network approval before ordinary allow rules.",+ "items": {+ "type": "string"+ },+ "type": [+ "array",+ "null"+ ]+ },"socksPort": {"format": "uint16","minimum": 0.0,diff --git a/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.v2.schemas.json b/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.v2.schemas.jsonindex 5c590af8cd..bd88041df4 100644--- a/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.v2.schemas.json+++ b/codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.v2.schemas.json@@ -12274,6 +12274,16 @@"null"]},+ "reviewDomains": {+ "description": "Host patterns routed to network approval before ordinary allow rules.",+ "items": {+ "type": "string"+ },+ "type": [+ "array",+ "null"+ ]+ },"socksPort": {"format": "uint16","minimum": 0.0,diff --git a/codex-rs/app-server-protocol/schema/json/v2/ConfigRequirementsReadResponse.json b/codex-rs/app-server-protocol/schema/json/v2/ConfigRequirementsReadResponse.jsonindex 895d3d6fa8..d549850ac1 100644--- a/codex-rs/app-server-protocol/schema/json/v2/ConfigRequirementsReadResponse.json+++ b/codex-rs/app-server-protocol/schema/json/v2/ConfigRequirementsReadResponse.json@@ -1073,6 +1073,16 @@"null"]},+ "reviewDomains": {+ "description": "Host patterns routed to network approval before ordinary allow rules.",+ "items": {+ "type": "string"+ },+ "type": [+ "array",+ "null"+ ]+ },"socksPort": {"format": "uint16","minimum": 0.0,diff --git a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zst b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zstindex 3772c18975..a9e3c99cba 100644Binary files a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zst and b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zst differdiff --git a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-stable.json.zst b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-stable.json.zstindex 145a95a10c..90c6e35e92 100644Binary files a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-stable.json.zst and b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-stable.json.zst differdiff --git a/codex-rs/app-server-protocol/schema/typescript/v2/NetworkRequirements.ts b/codex-rs/app-server-protocol/schema/typescript/v2/NetworkRequirements.tsindex 04e07ef1de..5a496b132a 100644--- a/codex-rs/app-server-protocol/schema/typescript/v2/NetworkRequirements.ts+++ b/codex-rs/app-server-protocol/schema/typescript/v2/NetworkRequirements.ts@@ -9,6 +9,10 @@ export type NetworkRequirements = { enabled: boolean | null, httpPort: number |* Canonical network permission map for `experimental_network`.*/domains: { [key in string]?: NetworkDomainPermission } | null,+/**+ * Host patterns routed to network approval before ordinary allow rules.+ */+reviewDomains: Array<string> | null,/*** When true, only managed allowlist entries are respected while managed* network enforcement is active.diff --git a/codex-rs/app-server-protocol/src/protocol/v2/config.rs b/codex-rs/app-server-protocol/src/protocol/v2/config.rsindex f9d7b14c6b..552520aff3 100644--- a/codex-rs/app-server-protocol/src/protocol/v2/config.rs+++ b/codex-rs/app-server-protocol/src/protocol/v2/config.rs@@ -725,6 +725,8 @@ pub struct NetworkRequirements {pub dangerously_allow_all_unix_sockets: Option<bool>,/// Canonical network permission map for `experimental_network`.pub domains: Option<BTreeMap<String, NetworkDomainPermission>>,+ /// Host patterns routed to network approval before ordinary allow rules.+ pub review_domains: Option<Vec<String>>,/// When true, only managed allowlist entries are respected while managed/// network enforcement is active.pub managed_allowed_domains_only: Option<bool>,diff --git a/codex-rs/app-server-protocol/src/protocol/v2/tests.rs b/codex-rs/app-server-protocol/src/protocol/v2/tests.rsindex 234636839d..d268de69fb 100644--- a/codex-rs/app-server-protocol/src/protocol/v2/tests.rs+++ b/codex-rs/app-server-protocol/src/protocol/v2/tests.rs@@ -3054,6 +3054,7 @@ fn network_requirements_deserializes_legacy_fields() {dangerously_allow_non_loopback_proxy: None,dangerously_allow_all_unix_sockets: None,domains: None,+ review_domains: None,managed_allowed_domains_only: None,allowed_domains: Some(vec!["api.openai.com".to_string()]),denied_domains: Some(vec!["blocked.example.com".to_string()]),@@ -3080,6 +3081,7 @@ fn network_requirements_serializes_canonical_and_legacy_fields() {NetworkDomainPermission::Deny,),])),+ review_domains: Some(vec!["api.openai.com".to_string()]),managed_allowed_domains_only: Some(true),allowed_domains: Some(vec!["api.openai.com".to_string()]),denied_domains: Some(vec!["blocked.example.com".to_string()]),@@ -3110,6 +3112,7 @@ fn network_requirements_serializes_canonical_and_legacy_fields() {"api.openai.com": "allow","blocked.example.com": "deny"},+ "reviewDomains": ["api.openai.com"],"managedAllowedDomainsOnly": true,"allowedDomains": ["api.openai.com"],"deniedDomains": ["blocked.example.com"],diff --git a/codex-rs/app-server/src/request_processors/config_processor.rs b/codex-rs/app-server/src/request_processors/config_processor.rsindex 1500cd82a2..bbfc952151 100644--- a/codex-rs/app-server/src/request_processors/config_processor.rs+++ b/codex-rs/app-server/src/request_processors/config_processor.rs@@ -868,6 +868,7 @@ fn map_network_requirements_to_api(}).collect()}),+ review_domains: network.review_domains,managed_allowed_domains_only: network.managed_allowed_domains_only,allowed_domains,denied_domains,diff --git a/codex-rs/app-server/tests/suite/v2/config_rpc.rs b/codex-rs/app-server/tests/suite/v2/config_rpc.rsindex c4ba5937d1..20476284ec 100644--- a/codex-rs/app-server/tests/suite/v2/config_rpc.rs+++ b/codex-rs/app-server/tests/suite/v2/config_rpc.rs@@ -37,6 +37,8 @@ use codex_app_server_protocol::ConfiguredHookHandler;use codex_app_server_protocol::ForcedChatgptWorkspaceIds;use codex_app_server_protocol::JSONRPCError;use codex_app_server_protocol::MergeStrategy;+use codex_app_server_protocol::NetworkDomainPermission;+use codex_app_server_protocol::NetworkRequirements;use codex_app_server_protocol::RequestId;use codex_app_server_protocol::SandboxMode;use codex_app_server_protocol::ToolsV2;@@ -106,6 +108,52 @@ async fn config_requirements_read_exposes_independent_speed_policy() -> Result<(Ok(())}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn config_requirements_read_includes_network_review_domains() -> Result<()> {+ let codex_home = TempDir::new()?;+ std::fs::write(+ codex_home.path().join("requirements.toml"),+ r#"[experimental_network]+enabled = true+allowed_domains = ["**.example.com"]+review_domains = ["review.example.com"]+"#,+ )?;+ let mut app_server = TestAppServer::builder()+ .with_codex_home(codex_home.path())+ .build_initialized()+ .await?;++ let request_id = app_server.send_config_requirements_read_request().await?;+ let response: ConfigRequirementsReadResponse = app_server.read_response(request_id).await?;+ assert_eq!(+ response+ .requirements+ .expect("managed requirements should be returned")+ .network,+ Some(NetworkRequirements {+ enabled: Some(true),+ http_port: None,+ socks_port: None,+ allow_upstream_proxy: None,+ dangerously_allow_non_loopback_proxy: None,+ dangerously_allow_all_unix_sockets: None,+ domains: Some(BTreeMap::from([(+ "**.example.com".to_string(),+ NetworkDomainPermission::Allow,+ )])),+ review_domains: Some(vec!["review.example.com".to_string()]),+ managed_allowed_domains_only: None,+ allowed_domains: Some(vec!["**.example.com".to_string()]),+ denied_domains: None,+ unix_sockets: None,+ allow_unix_sockets: None,+ allow_local_binding: None,+ }),+ );+ Ok(())+}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn managed_auth_settings_are_exposed_enforced_and_read_only() -> Result<()> {let codex_home = TempDir::new()?;diff --git a/codex-rs/config/src/config_requirements.rs b/codex-rs/config/src/config_requirements.rsindex 5e1cc86751..961e3c3d78 100644--- a/codex-rs/config/src/config_requirements.rs+++ b/codex-rs/config/src/config_requirements.rs@@ -432,6 +432,9 @@ pub struct NetworkRequirementsToml {pub dangerously_allow_non_loopback_proxy: Option<bool>,pub dangerously_allow_all_unix_sockets: Option<bool>,pub domains: Option<NetworkDomainPermissionsToml>,+ /// Host patterns routed to the existing network approval flow before ordinary allow rules.+ /// Explicit denials take precedence; approval caching, hooks, and reviewer routing still apply.+ pub review_domains: Option<Vec<String>>,/// When true, only managed `allowed_domains` are respected while managed/// network enforcement is active. User allowlist entries are ignored.pub managed_allowed_domains_only: Option<bool>,@@ -471,6 +474,7 @@ struct RawNetworkRequirementsToml {dangerously_allow_non_loopback_proxy: Option<bool>,dangerously_allow_all_unix_sockets: Option<bool>,domains: Option<NetworkDomainPermissionsToml>,+ review_domains: Option<Vec<String>>,#[serde(default)]allowed_domains: Option<Vec<String>>,/// When true, only managed `allowed_domains` are respected while managed@@ -499,6 +503,7 @@ impl<'de> Deserialize<'de> for NetworkRequirementsToml {dangerously_allow_non_loopback_proxy,dangerously_allow_all_unix_sockets,domains,+ review_domains,allowed_domains,managed_allowed_domains_only,denied_domains,@@ -529,6 +534,7 @@ impl<'de> Deserialize<'de> for NetworkRequirementsToml {dangerously_allow_all_unix_sockets,domains: domains.or_else(|| legacy_domain_permissions_from_lists(allowed_domains, denied_domains)),+ review_domains,managed_allowed_domains_only,unix_sockets: unix_sockets.or_else(|| legacy_unix_socket_permissions_from_list(allow_unix_sockets)),@@ -580,6 +586,7 @@ pub struct NetworkConstraints {pub dangerously_allow_non_loopback_proxy: Option<bool>,pub dangerously_allow_all_unix_sockets: Option<bool>,pub domains: Option<NetworkDomainPermissionsToml>,+ pub review_domains: Option<Vec<String>>,/// When true, only managed `allowed_domains` are respected while managed/// network enforcement is active. User allowlist entries are ignored.pub managed_allowed_domains_only: Option<bool>,@@ -608,6 +615,7 @@ impl From<NetworkRequirementsToml> for NetworkConstraints {dangerously_allow_non_loopback_proxy,dangerously_allow_all_unix_sockets,domains,+ review_domains,managed_allowed_domains_only,unix_sockets,allow_local_binding,@@ -621,6 +629,7 @@ impl From<NetworkRequirementsToml> for NetworkConstraints {dangerously_allow_non_loopback_proxy,dangerously_allow_all_unix_sockets,domains,+ review_domains,managed_allowed_domains_only,unix_sockets,allow_local_binding,@@ -4567,6 +4576,7 @@ command = "python3 /enterprise/hooks/pre.py"allow_upstream_proxy = falsedangerously_allow_all_unix_sockets = trueallowed_domains = ["api.example.com", "*.openai.com"]+ review_domains = ["review.example.com", "*.review.example.com"]managed_allowed_domains_only = truedenied_domains = ["blocked.example.com"]allow_unix_sockets = ["/tmp/example.sock"]@@ -4623,6 +4633,14 @@ command = "python3 /enterprise/hooks/pre.py");assert_eq!(sourced_network.value.allow_local_binding, Some(false));+ assert_eq!(+ sourced_network.value.review_domains,+ Some(vec![+ "review.example.com".to_string(),+ "*.review.example.com".to_string()+ ])+ );+Ok(())}diff --git a/codex-rs/core/src/config/network_proxy_spec.rs b/codex-rs/core/src/config/network_proxy_spec.rsindex ace90ef9c2..44e6087a9b 100644--- a/codex-rs/core/src/config/network_proxy_spec.rs+++ b/codex-rs/core/src/config/network_proxy_spec.rs@@ -474,6 +474,10 @@ impl NetworkProxySpec {constraints.denied_domains = Some(managed_denied_domains);constraints.denylist_expansion_enabled = Some(denylist_expansion_enabled);}+ if let Some(review_domains) = &requirements.review_domains {+ config.review_domains =+ Self::merge_domain_lists(review_domains.clone(), &config.review_domains);+ }if requirements.unix_sockets.is_some() {let allow_unix_sockets = requirements.unix_socketsdiff --git a/codex-rs/core/src/config/network_proxy_spec_tests.rs b/codex-rs/core/src/config/network_proxy_spec_tests.rsindex d44b39f75c..d015fb6c40 100644--- a/codex-rs/core/src/config/network_proxy_spec_tests.rs+++ b/codex-rs/core/src/config/network_proxy_spec_tests.rs@@ -223,6 +223,7 @@ fn environment_policy_replaces_soft_controller_allowlist_and_preserves_denials()("controller.example", NetworkDomainPermissionToml::Allow),("blocked.example", NetworkDomainPermissionToml::Deny),])),+ review_domains: Some(vec!["controller-review.example".to_string()]),..Default::default()};let profile = PermissionProfile::workspace_write();@@ -249,7 +250,10 @@ fn environment_policy_replaces_soft_controller_allowlist_and_preserves_denials()&profile,).expect("controller policy should be valid");- let mut owner = NetworkProxyConfig::default();+ let mut owner = NetworkProxyConfig {+ review_domains: vec!["owner-review.example".to_string()],+ ..NetworkProxyConfig::default()+ };owner.set_allowed_domains(vec!["owner.example".to_string()]);owner.set_denied_domains(vec!["owner-blocked.example".to_string()]);owner.set_allow_unix_sockets(vec![@@ -312,6 +316,9 @@ fn environment_policy_replaces_soft_controller_allowlist_and_preserves_denials()owner.dangerously_allow_all_unix_sockets = Some(false);owner.allow_local_binding = Some(true);owner.enabled = true;+ owner+ .review_domains+ .insert(0, "controller-review.example".to_string());assert_eq!(restricted.environment_policy(),EnvironmentNetworkPolicy::from_config(&owner, /*managed_allowed_domains_only*/ false)diff --git a/codex-rs/core/src/tools/network_approval.rs b/codex-rs/core/src/tools/network_approval.rsindex 7eb6860729..467d54e052 100644--- a/codex-rs/core/src/tools/network_approval.rs+++ b/codex-rs/core/src/tools/network_approval.rs@@ -677,7 +677,7 @@ impl NetworkApprovalService {let target = Self::format_network_target(key.protocol, request.host.as_str(), key.port);let policy_denial_message =format!("Network access to \"{target}\" was blocked by policy.");- let prompt_reason = format!("{} is not in the allowed_domains", request.host);+ let prompt_reason = format!("Network access to {} requires approval", request.host);let Some((turn_context, settings, active_environments, strict_auto_review)) = active_turnelse {diff --git a/codex-rs/core/tests/suite/hooks.rs b/codex-rs/core/tests/suite/hooks.rsindex e60331cc94..9fce5b9c3d 100644--- a/codex-rs/core/tests/suite/hooks.rs+++ b/codex-rs/core/tests/suite/hooks.rs@@ -48,7 +48,6 @@ use codex_thread_store::InMemoryThreadStore;use core_test_support::TestTargetOs;use core_test_support::fs_wait;use core_test_support::hooks::trust_discovered_hooks;-use core_test_support::managed_network_requirements_loader;use core_test_support::responses;use core_test_support::responses::ev_apply_patch_custom_tool_call;use core_test_support::responses::ev_assistant_message;@@ -3415,7 +3414,17 @@ allow_local_binding = true).expect("failed to write permission request hook test fixture");})- .with_cloud_config_bundle(managed_network_requirements_loader())+ .with_cloud_config_bundle(+ CloudConfigBundleFixture::loader_with_enterprise_requirement(+ r#"+[experimental_network]+enabled = true+allow_local_binding = true+allowed_domains = ["**.invalid"]+review_domains = ["codex-network-test.invalid"]+"#,+ ),+ ).with_config(move |config| {trust_discovered_hooks(config);config.approvals_reviewer = codex_config::types::ApprovalsReviewer::AutoReview;diff --git a/codex-rs/core/tests/suite/network_approval.rs b/codex-rs/core/tests/suite/network_approval.rsindex 64a97413c9..62b5b1bfb7 100644--- a/codex-rs/core/tests/suite/network_approval.rs+++ b/codex-rs/core/tests/suite/network_approval.rs@@ -1166,7 +1166,7 @@ async fn user_network_approval_once_session_and_denial_semantics() -> Result<()>assert_eq!(approval.cwd, test.config.cwd.clone().into());assert_eq!(approval.reason.as_deref(),- Some("codex-network-test.invalid is not in the allowed_domains")+ Some("Network access to codex-network-test.invalid requires approval"));test.codex.submit(Op::ExecApproval {diff --git a/codex-rs/exec-server-protocol/src/protocol.rs b/codex-rs/exec-server-protocol/src/protocol.rsindex fbb2496f26..dad1132447 100644--- a/codex-rs/exec-server-protocol/src/protocol.rs+++ b/codex-rs/exec-server-protocol/src/protocol.rs@@ -153,6 +153,9 @@ pub struct EnvironmentCapabilities {/// Whether `exec` accepts instructions for launching an executor-local network proxy.#[serde(default)]network_proxy_launch: bool,+ /// Whether executor proxies enforce managed review domains before ordinary allows.+ #[serde(default, skip_serializing_if = "std::ops::Not::not")]+ pub network_proxy_review_domains: bool,/// Whether the selected shell can mask executor environment credentials.#[serde(default, skip_serializing_if = "std::ops::Not::not")]credential_masking: bool,@@ -314,6 +317,7 @@ impl EnvironmentInfo {temp_dir,capabilities: EnvironmentCapabilities {network_proxy_launch: true,+ network_proxy_review_domains: true,credential_masking,credential_masking_custom_providers: credential_masking,capability_discovery_sandbox: true,@@ -1539,6 +1543,7 @@ mod tests {capabilities,EnvironmentCapabilities {network_proxy_launch: true,+ network_proxy_review_domains: false,credential_masking: false,credential_masking_custom_providers: false,capability_discovery_sandbox: true,diff --git a/codex-rs/exec-server/src/client.rs b/codex-rs/exec-server/src/client.rsindex d243b99d99..e8140904f5 100644--- a/codex-rs/exec-server/src/client.rs+++ b/codex-rs/exec-server/src/client.rs@@ -845,9 +845,31 @@ impl ExecServerClient {}pub async fn exec(&self, params: ExecParams) -> Result<ExecResponse, ExecServerError> {+ self.ensure_network_review_capability(¶ms).await?;self.call(EXEC_METHOD, ¶ms).await}+ async fn ensure_network_review_capability(+ &self,+ params: &ExecParams,+ ) -> Result<(), ExecServerError> {+ if params+ .network_proxy+ .as_ref()+ .is_some_and(|launch| !launch.proxy.review_domains.is_empty())+ && !self+ .environment_info()+ .await?+ .capabilities+ .network_proxy_review_domains+ {+ return Err(ExecServerError::Protocol(+ "selected exec-server does not support managed network review domains".to_string(),+ ));+ }+ Ok(())+ }+/// Returns shared cached executor metadata, fetching it lazily if initialization omitted it.pub async fn environment_info(&self) -> Result<Arc<EnvironmentInfo>, ExecServerError> {self.inner@@ -1107,6 +1129,7 @@ impl ExecServerClient {params: ExecParams,network_policy_decider: Option<Arc<dyn NetworkPolicyDecider>>,) -> Result<Session, ExecServerError> {+ self.ensure_network_review_capability(¶ms).await?;let policy_decision_timeout_ms = params.network_proxy.as_ref()diff --git a/codex-rs/network-proxy/src/config.rs b/codex-rs/network-proxy/src/config.rsindex 55841b78bc..91a201f3ef 100644--- a/codex-rs/network-proxy/src/config.rs+++ b/codex-rs/network-proxy/src/config.rs@@ -146,6 +146,10 @@ pub struct NetworkProxyConfig {pub mode: NetworkMode,#[serde(default)]pub domains: Option<NetworkDomainPermissions>,+ /// Managed host selectors routed through the existing approval flow before ordinary allows.+ /// Direct proxy configuration cannot change these requirements-only selectors.+ #[serde(skip)]+ pub review_domains: Vec<String>,#[serde(default)]pub unix_sockets: Option<NetworkUnixSocketPermissions>,/// Omission is resolved for the selected sandbox; ordinary proxy execution defaults to false.@@ -187,6 +191,7 @@ impl Default for NetworkProxyConfig {dangerously_allow_all_unix_sockets: None,mode: NetworkMode::default(),domains: None,+ review_domains: Vec::new(),unix_sockets: None,allow_local_binding: None,mitm: false,@@ -727,6 +732,7 @@ mod tests {dangerously_allow_all_unix_sockets: None,mode: NetworkMode::Full,domains: None,+ review_domains: Vec::new(),unix_sockets: None,allow_local_binding: None,mitm: false,diff --git a/codex-rs/network-proxy/src/connect_policy.rs b/codex-rs/network-proxy/src/connect_policy.rsindex eab3df9831..abb6a67d91 100644--- a/codex-rs/network-proxy/src/connect_policy.rs+++ b/codex-rs/network-proxy/src/connect_policy.rs@@ -1,4 +1,5 @@use crate::policy::is_non_public_ip;+use crate::runtime::HostAuthorization;use crate::runtime::HostBlockDecision;use crate::state::NetworkProxyState;#[cfg(target_os = "macos")]@@ -20,6 +21,8 @@ use std::io;use std::net::SocketAddr;use std::sync::Arc;+/// Connects traffic whose host policy has already allowed the request.+/// Resolved non-public targets still undergo explicit-deny and local-address checks.#[derive(Clone)]pub(crate) struct TargetCheckedTcpConnector {state: Arc<NetworkProxyState>,@@ -105,7 +108,12 @@ impl TargetCheckedStreamConnector {}self.state- .host_blocked(&self.target.host.to_string(), self.target.port)+ .host_blocked_with_local_binding(+ &self.target.host.to_string(),+ self.target.port,+ /*allow_local_binding*/ None,+ HostAuthorization::Approved,+ ).await.map(|decision| decision == HostBlockDecision::Allowed).map_err(|err| {@@ -198,8 +206,9 @@ mod tests {let target = listener.local_addr().expect("local addr");let mut config = NetworkProxyConfig::default();config.set_allowed_domains(vec![target.ip().to_string()]);- let connector =- TargetCheckedTcpConnector::new(Arc::new(network_proxy_state_for_policy(config)));+ config.review_domains = vec![target.ip().to_string()];+ let state = Arc::new(network_proxy_state_for_policy(config));+ let connector = TargetCheckedTcpConnector::new(Arc::clone(&state));let request: rama_tcp::client::Request =rama_tcp::client::Request::new(HostWithPort::from(target));@@ -209,6 +218,12 @@ mod tests {result.is_ok(),"explicitly allowlisted local target should be allowed: {result:?}");+ state+ .add_denied_domain(&target.ip().to_string())+ .await+ .unwrap();+ let request = rama_tcp::client::Request::new(HostWithPort::from(target));+ assert!(Service::serve(&connector, request).await.is_err());}#[tokio::test(flavor = "current_thread")]@@ -219,6 +234,7 @@ mod tests {let target = listener.local_addr().expect("local addr");let mut config = NetworkProxyConfig::default();config.set_allowed_domains(vec!["localhost".to_string()]);+ config.review_domains = vec!["localhost".to_string()];let connector =TargetCheckedTcpConnector::new(Arc::new(network_proxy_state_for_policy(config)));diff --git a/codex-rs/network-proxy/src/environment_policy.rs b/codex-rs/network-proxy/src/environment_policy.rsindex d877f79d02..aea0e9b966 100644--- a/codex-rs/network-proxy/src/environment_policy.rs+++ b/codex-rs/network-proxy/src/environment_policy.rs@@ -17,6 +17,9 @@ pub struct EnvironmentNetworkPolicy {#[serde(default, skip_serializing_if = "std::ops::Not::not")]pub requires_proxy: bool,pub domains: Option<NetworkDomainPermissions>,+ /// Managed host selectors inherited by every execution in this environment.+ #[serde(default, skip_serializing_if = "Vec::is_empty")]+ pub review_domains: Vec<String>,pub unix_sockets: Option<NetworkUnixSocketPermissions>,pub allow_upstream_proxy: bool,pub dangerously_allow_all_unix_sockets: bool,@@ -31,6 +34,7 @@ impl EnvironmentNetworkPolicy {Self {requires_proxy: config.enabled,domains: config.domains.clone(),+ review_domains: config.review_domains.clone(),unix_sockets: config.unix_sockets.clone(),allow_upstream_proxy: config.allow_upstream_proxy,dangerously_allow_all_unix_sockets: config@@ -43,6 +47,16 @@ impl EnvironmentNetworkPolicy {/// Applies attachment-owned traffic settings while preserving inherited denials and proxy setup.pub fn apply_to(&self, config: &mut NetworkProxyConfig) {+ // Neither owner nor controller may remove the other's review selectors.+ for pattern in &self.review_domains {+ if !config+ .review_domains+ .iter()+ .any(|existing| existing.eq_ignore_ascii_case(pattern))+ {+ config.review_domains.push(pattern.clone());+ }+ }// Use the owner's domain rules without dropping controller denials.let inherited_denials = config.denied_domains().unwrap_or_default();config.domains.clone_from(&self.domains);diff --git a/codex-rs/network-proxy/src/host_policy_tests.rs b/codex-rs/network-proxy/src/host_policy_tests.rsindex 7addfffce8..d6009ec3a7 100644--- a/codex-rs/network-proxy/src/host_policy_tests.rs+++ b/codex-rs/network-proxy/src/host_policy_tests.rs@@ -51,7 +51,7 @@ async fn unapproved_hosts_do_not_trigger_dns() {}#[tokio::test]-async fn local_and_remote_approvals_recheck_dns_after_the_decider() -> Result<()> {+async fn local_and_remote_approvals_preserve_review_precedence_and_recheck_dns() -> Result<()> {use crate::NetworkDecision;use crate::NetworkDecisionSource;use crate::NetworkPolicyDecider;@@ -61,21 +61,33 @@ async fn local_and_remote_approvals_recheck_dns_after_the_decider() -> Result<()use crate::NetworkProxy;use crate::network_policy::evaluate_host_policy;use std::sync::Arc;- use std::sync::atomic::AtomicUsize;- use std::sync::atomic::Ordering;+ use std::sync::Mutex;for remote in [false, true] {- let calls = Arc::new(AtomicUsize::new(0));+ let calls = Arc::new(Mutex::new(Vec::new()));let decider_calls = Arc::clone(&calls);- let decider: Arc<dyn NetworkPolicyDecider> = Arc::new(move |_request| {- decider_calls.fetch_add(1, Ordering::SeqCst);- async { NetworkDecision::Allow }- });+ let decider: Arc<dyn NetworkPolicyDecider> =+ Arc::new(move |request: NetworkPolicyRequest| {+ decider_calls.lock().unwrap().push(request.host);+ async { NetworkDecision::Allow }+ });// Explicit controller false must survive an executor allowing local binding.- let config = NetworkProxyConfig {+ let mut config = NetworkProxyConfig {allow_local_binding: Some(false),+ review_domains: vec![+ "8.8.8.8".to_string(),+ "9.9.9.9".to_string(),+ "host.review.invalid".to_string(),+ ],..NetworkProxyConfig::default()};+ config.set_allowed_domains(vec![+ "8.8.8.8".to_string(),+ "1.1.1.1".to_string(),+ "9.9.9.9".to_string(),+ "**.review.invalid".to_string(),+ ]);+ config.set_denied_domains(vec!["9.9.9.9".to_string()]);let state = Arc::new(network_proxy_state_for_policy(config));let proxy = NetworkProxy::builder().state(Arc::clone(&state))@@ -93,7 +105,14 @@ async fn local_and_remote_approvals_recheck_dns_after_the_decider() -> Result<()let remote_decider = scoped.remote_policy_decider(/*allow_local_binding*/ true).unwrap();- for host in ["does-not-resolve.invalid", "8.8.8.8"] {+ for host in [+ "does-not-resolve.invalid",+ "8.8.8.8",+ "host.review.invalid",+ "ordinary.review.invalid",+ "1.1.1.1",+ "9.9.9.9",+ ] {let request = NetworkPolicyRequest::new(NetworkPolicyRequestArgs {protocol: NetworkProtocol::HttpsConnect,host: host.to_string(),@@ -114,15 +133,20 @@ async fn local_and_remote_approvals_recheck_dns_after_the_decider() -> Result<()HostBlockReason::NotAllowedLocal.as_str(),NetworkDecisionSource::BaselinePolicy,)+ } else if host == "9.9.9.9" {+ NetworkDecision::deny_with_source(+ HostBlockReason::Denied.as_str(),+ NetworkDecisionSource::BaselinePolicy,+ )} else {NetworkDecision::Allow};assert_eq!(decision, expected);}assert_eq!(- calls.load(Ordering::SeqCst),- 2,- "domain review precedes DNS"+ *calls.lock().unwrap(),+ vec!["does-not-resolve.invalid", "8.8.8.8", "host.review.invalid"],+ "review selectors precede exact and wildcard allows; ordinary allows and denies skip the decider");}Ok(())diff --git a/codex-rs/network-proxy/src/remote_config.rs b/codex-rs/network-proxy/src/remote_config.rsindex 4b00da931f..b5f203425c 100644--- a/codex-rs/network-proxy/src/remote_config.rs+++ b/codex-rs/network-proxy/src/remote_config.rs@@ -184,6 +184,9 @@ pub struct RemoteNetworkProxyConfig {pub dangerously_allow_all_unix_sockets: bool,pub mode: NetworkMode,pub domains: Option<NetworkDomainPermissions>,+ /// Clients must require the `networkProxyReviewDomains` executor capability when nonempty.+ #[serde(default, skip_serializing_if = "Vec::is_empty")]+ pub review_domains: Vec<String>,pub unix_sockets: Option<NetworkUnixSocketPermissions>,pub allow_local_binding: bool,}@@ -210,6 +213,7 @@ impl RemoteNetworkProxyConfig {.unwrap_or(false),mode: config.mode,domains: config.domains.clone(),+ review_domains: config.review_domains.clone(),unix_sockets: config.unix_sockets.clone(),allow_local_binding: config.allow_local_binding(),})@@ -240,6 +244,7 @@ impl RemoteNetworkProxyConfig {dangerously_allow_all_unix_sockets: Some(self.dangerously_allow_all_unix_sockets),mode: self.mode,domains: self.domains,+ review_domains: self.review_domains,unix_sockets: self.unix_sockets,allow_local_binding: Some(self.allow_local_binding),..NetworkProxyConfig::default()diff --git a/codex-rs/network-proxy/src/remote_config_tests.rs b/codex-rs/network-proxy/src/remote_config_tests.rsindex ec327bb902..332d8a99c0 100644--- a/codex-rs/network-proxy/src/remote_config_tests.rs+++ b/codex-rs/network-proxy/src/remote_config_tests.rs@@ -65,6 +65,7 @@ async fn round_trip_preserves_supported_effective_settings() {dangerously_allow_all_unix_sockets: Some(true),mode: NetworkMode::Limited,allow_local_binding: Some(true),+ review_domains: vec!["review.example.com".to_string()],..NetworkProxyConfig::default()};// Domain permissions serialize as a sorted map.diff --git a/codex-rs/network-proxy/src/runtime.rs b/codex-rs/network-proxy/src/runtime.rsindex c70c4dc39c..cd09549cb4 100644--- a/codex-rs/network-proxy/src/runtime.rs+++ b/codex-rs/network-proxy/src/runtime.rs@@ -181,6 +181,7 @@ pub struct ConfigState {pub(crate) brokerage_created_default_allowlist: bool,pub allow_set: DomainPatternSet,pub deny_set: DomainPatternSet,+ pub review_set: DomainPatternSet,pub mitm: Option<Arc<MitmState>>,pub mitm_hooks: MitmHooksByHost,pub constraints: NetworkProxyConstraints,@@ -816,11 +817,12 @@ impl NetworkProxyState {Ok(host) => host,Err(_) => return Ok(HostBlockDecision::Blocked(HostBlockReason::NotAllowed)),};- let (deny_set, allow_set, allow_local_binding, allowed_domains) = {+ let (deny_set, review_set, allow_set, allow_local_binding, allowed_domains) = {let guard = self.state.read().await;let allowed_domains = guard.config.allowed_domains();(guard.deny_set.clone(),+ guard.review_set.clone(),guard.allow_set.clone(),// Keep explicit controller restrictions even if the executor launched with true.allow_local_binding@@ -836,13 +838,15 @@ impl NetworkProxyState {// Decision order matters:// 1) explicit deny always wins// 2) local/private networking is opt-in (defense-in-depth)- // 3) DNS requires an allowlist match or an approval+ // 3) managed review selectors precede every ordinary allow rule+ // 4) DNS requires an allowlist match or an approvalif domains_match_host_or_unscoped(&deny_set, host_str) {return Ok(HostBlockDecision::Blocked(HostBlockReason::Denied));}let is_authorized = authorization == HostAuthorization::Approved- || domains_match_host_or_unscoped(&allow_set, host_str);+ || (!domains_match_host_or_unscoped(&review_set, host_str)+ && domains_match_host_or_unscoped(&allow_set, host_str));if !allow_local_binding {// If the intent is "prevent access to local/internal networks", we must not rely solely// on string checks like `localhost` / `127.0.0.1`. Attackers can use DNS rebinding or@@ -1381,6 +1385,7 @@ pub(crate) fn network_proxy_state_for_policy(constraints: NetworkProxyConstraints::default(),deny_set: crate::policy::compile_denylist(&config.denied_domains().unwrap_or_default()).unwrap(),+ review_set: crate::policy::compile_allowlist(&config.review_domains).unwrap(),mitm: None,mitm_hooks: crate::mitm_hook::compile_mitm_hooks(&config).unwrap(),config,diff --git a/codex-rs/network-proxy/src/state.rs b/codex-rs/network-proxy/src/state.rsindex b31367170e..262b7270c2 100644--- a/codex-rs/network-proxy/src/state.rs+++ b/codex-rs/network-proxy/src/state.rs@@ -92,6 +92,7 @@ pub fn build_config_state(.map_err(NetworkProxyConstraintError::into_anyhow)?;let deny_set = compile_denylist(&denied_domains)?;let allow_set = compile_allowlist(&allowed_domains)?;+ let review_set = compile_allowlist(&config.review_domains)?;let mitm_hooks = compile_mitm_hooks(&config)?;let mitm = if config.mitm {Some(Arc::new(MitmState::new(MitmUpstreamConfig {@@ -107,6 +108,7 @@ pub fn build_config_state(brokerage_created_default_allowlist,allow_set,deny_set,+ review_set,mitm,mitm_hooks,constraints,diff --git a/codex-rs/tui/src/debug_config.rs b/codex-rs/tui/src/debug_config.rsindex 70eb6042b0..01a7802d06 100644--- a/codex-rs/tui/src/debug_config.rs+++ b/codex-rs/tui/src/debug_config.rs@@ -557,6 +557,7 @@ fn format_network_constraints(network: &NetworkConstraints) -> String {dangerously_allow_non_loopback_proxy,dangerously_allow_all_unix_sockets,domains,+ review_domains,managed_allowed_domains_only,unix_sockets,allow_local_binding,@@ -591,6 +592,9 @@ fn format_network_constraints(network: &NetworkConstraints) -> String {format_network_permission_entries(&domains.entries, format_network_domain_permission)));}+ if let Some(review_domains) = review_domains {+ parts.push(format!("review_domains={{{}}}", review_domains.join(", ")));+ }if let Some(managed_allowed_domains_only) = managed_allowed_domains_only {parts.push(format!("managed_allowed_domains_only={managed_allowed_domains_only}"@@ -917,6 +921,7 @@ interrupt_message = falseNetworkDomainPermissionToml::Allow,)]),}),+ review_domains: Some(vec!["api.example.com".to_string()]),header_injections: Some(vec![NetworkHeaderInjectionToml {host: "api.example.com".to_string(),methods: vec!["POST".to_string()],@@ -1065,7 +1070,7 @@ interrupt_message = false"enforce_residency: us (source: {requirements_source})")));assert!(rendered.contains(&format!(- "experimental_network: enabled=true, domains={{example.com=allow}}, header_injections=1 hosts={{api.example.com}} (source: {requirements_source})"+ "experimental_network: enabled=true, domains={{example.com=allow}}, review_domains={{api.example.com}}, header_injections=1 hosts={{api.example.com}} (source: {requirements_source})")));assert!(!rendered.contains("secret-looking-value"));assert!(diff --git a/codex-rs/tui/src/snapshots/codex_tui__debug_config__tests__debug_config_requirement_sources.snap b/codex-rs/tui/src/snapshots/codex_tui__debug_config__tests__debug_config_requirement_sources.snapindex 7d4455cb1c..64120d4aed 100644--- a/codex-rs/tui/src/snapshots/codex_tui__debug_config__tests__debug_config_requirement_sources.snap+++ b/codex-rs/tui/src/snapshots/codex_tui__debug_config__tests__debug_config_requirement_sources.snap@@ -25,5 +25,5 @@ Requirements:- features: guardian_approval=true (source: MDM managed_config.toml (legacy))- mcp_servers: docs (source: MDM managed_config.toml (legacy))- enforce_residency: us (source: MDM managed_config.toml (legacy))- - experimental_network: enabled=true, domains={example.com=allow}, header_injections=1 hosts={api.example.com} (source: MDM managed_config.toml (legacy))+ - experimental_network: enabled=true, domains={example.com=allow}, review_domains={api.example.com}, header_injections=1 hosts={api.example.com} (source: MDM managed_config.toml (legacy))- permissions.filesystem.deny_read: /home/alice/.gitconfig (source: /etc/codex/requirements.toml)diff --git a/sdk/python/src/openai_codex/generated/v2_all.py b/sdk/python/src/openai_codex/generated/v2_all.pyindex 1c9d500670..4ea7e766aa 100644--- a/sdk/python/src/openai_codex/generated/v2_all.py+++ b/sdk/python/src/openai_codex/generated/v2_all.py@@ -3001,6 +3001,13 @@ class NetworkRequirements(BaseModel):description="When true, only managed allowlist entries are respected while managed network enforcement is active.",),] = None+ review_domains: Annotated[+ list[str] | None,+ Field(+ alias="reviewDomains",+ description="Host patterns routed to network approval before ordinary allow rules.",+ ),+ ] = Nonesocks_port: Annotated[int | None, Field(alias="socksPort", ge=0)] = Noneunix_sockets: Annotated[dict[str, Any] | None,