feat: retain NetworkProxy, when appropriate (#11207)

As of this PR, `SessionServices` retains a
`Option<StartedNetworkProxy>`, if appropriate.

Now the `network` field on `Config` is `Option<NetworkProxySpec>`
instead of `Option<NetworkProxy>`.

Over in `Session::new()`, we invoke `NetworkProxySpec::start_proxy()` to
create the `StartedNetworkProxy`, which is a new struct that retains the
`NetworkProxy` as well as the `NetworkProxyHandle`. (Note that `Drop` is
implemented for `NetworkProxyHandle` to ensure the proxies are shutdown
when it is dropped.)

The `NetworkProxy` from the `StartedNetworkProxy` is threaded through to
the appropriate places.


---
[//]: # (BEGIN SAPLING FOOTER)
Stack created with [Sapling](https://sapling-scm.com). Best reviewed
with [ReviewStack](https://reviewstack.dev/openai/codex/pull/11207).
* #11285
* __->__ #11207

codex-rs/core/src/config/mod.rs

@@ -47,7 +47,6 @@ use crate::protocol::SandboxPolicy;
 use crate::windows_sandbox::WindowsSandboxLevelExt;
 use codex_app_server_protocol::Tools;
 use codex_app_server_protocol::UserSavedConfig;
-use codex_network_proxy::NetworkProxy;
 use codex_protocol::config_types::AltScreenMode;
 use codex_protocol::config_types::ForcedLoginMethod;
 use codex_protocol::config_types::ModeKind;
@@ -80,6 +79,7 @@ use toml_edit::DocumentMut;
 
 mod constraint;
 pub mod edit;
+mod network_proxy_spec;
 pub mod profile;
 pub mod schema;
 pub mod service;
@@ -88,6 +88,8 @@ pub use constraint::Constrained;
 pub use constraint::ConstraintError;
 pub use constraint::ConstraintResult;
 
+pub use network_proxy_spec::NetworkProxySpec;
+pub use network_proxy_spec::StartedNetworkProxy;
 pub use service::ConfigService;
 pub use service::ConfigServiceError;
 
@@ -154,7 +156,7 @@ pub struct Config {
     pub enforce_residency: Constrained<Option<ResidencyRequirement>>,
 
     /// Effective network configuration applied to all spawned processes.
-    pub network: Option<NetworkProxy>,
+    pub network: Option<NetworkProxySpec>,
 
     /// True if the user passed in an override or set a value in config.toml
     /// for either of approval_policy or sandbox_mode.
@@ -1657,7 +1659,7 @@ impl Config {
             mcp_servers,
             exec_policy: _,
             enforce_residency,
-            network: _network_requirements,
+            network: network_requirements,
         } = requirements;
 
         apply_requirement_constrained_value(
@@ -1682,6 +1684,20 @@ impl Config {
         let mcp_servers = constrain_mcp_servers(cfg.mcp_servers.clone(), mcp_servers.as_ref())
             .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidInput, format!("{e}")))?;
 
+        let network = match network_requirements {
+            Some(Sourced { value, source }) => {
+                let network = NetworkProxySpec::from_constraints(&config_layer_stack, value)
+                    .map_err(|err| {
+                        std::io::Error::new(
+                            err.kind(),
+                            format!("failed to build managed network proxy from {source}: {err}"),
+                        )
+                    })?;
+                Some(network)
+            }
+            None => None,
+        };
+
         let config = Self {
             model,
             review_model,
@@ -1694,7 +1710,7 @@ impl Config {
             approval_policy: constrained_approval_policy.value,
             sandbox_policy: constrained_sandbox_policy.value,
             enforce_residency: enforce_residency.value,
-            network: None,
+            network,
             did_user_set_custom_approval_policy_or_sandbox_mode,
             forced_auto_mode_downgraded_on_windows,
             shell_environment_policy,

codex-rs/core/src/config/network_proxy_spec.rs

@@ -0,0 +1,167 @@
+use crate::config;
+use crate::config_loader::NetworkConstraints;
+use async_trait::async_trait;
+use codex_network_proxy::ConfigReloader;
+use codex_network_proxy::ConfigState;
+use codex_network_proxy::NetworkProxy;
+use codex_network_proxy::NetworkProxyConfig;
+use codex_network_proxy::NetworkProxyConstraints;
+use codex_network_proxy::NetworkProxyHandle;
+use codex_network_proxy::NetworkProxyState;
+use codex_network_proxy::build_config_state;
+use codex_network_proxy::host_and_port_from_network_addr;
+use codex_network_proxy::validate_policy_against_constraints;
+use std::sync::Arc;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct NetworkProxySpec {
+    config: NetworkProxyConfig,
+    constraints: NetworkProxyConstraints,
+}
+
+pub struct StartedNetworkProxy {
+    proxy: NetworkProxy,
+    _handle: NetworkProxyHandle,
+}
+
+impl StartedNetworkProxy {
+    fn new(proxy: NetworkProxy, handle: NetworkProxyHandle) -> Self {
+        Self {
+            proxy,
+            _handle: handle,
+        }
+    }
+
+    pub fn proxy(&self) -> NetworkProxy {
+        self.proxy.clone()
+    }
+}
+
+#[derive(Clone)]
+struct StaticNetworkProxyReloader {
+    state: ConfigState,
+}
+
+impl StaticNetworkProxyReloader {
+    fn new(state: ConfigState) -> Self {
+        Self { state }
+    }
+}
+
+#[async_trait]
+impl ConfigReloader for StaticNetworkProxyReloader {
+    async fn maybe_reload(&self) -> anyhow::Result<Option<ConfigState>> {
+        Ok(None)
+    }
+
+    async fn reload_now(&self) -> anyhow::Result<ConfigState> {
+        Ok(self.state.clone())
+    }
+
+    fn source_label(&self) -> String {
+        "StaticNetworkProxyReloader".to_string()
+    }
+}
+
+impl NetworkProxySpec {
+    pub fn proxy_host_and_port(&self) -> String {
+        host_and_port_from_network_addr(&self.config.network.proxy_url, 3128)
+    }
+
+    pub(crate) fn from_constraints(
+        _config_layer_stack: &config::ConfigLayerStack,
+        requirements: NetworkConstraints,
+    ) -> std::io::Result<Self> {
+        // TODO(mbolin): Use ConfigLayerStack once we are ready to start
+        // honoring network configuration in config.toml.
+        let config = NetworkProxyConfig::default();
+        let (config, constraints) = Self::apply_requirements(config, &requirements);
+        validate_policy_against_constraints(&config, &constraints).map_err(|err| {
+            std::io::Error::new(
+                std::io::ErrorKind::InvalidInput,
+                format!("network proxy constraints are invalid: {err}"),
+            )
+        })?;
+        Ok(Self {
+            config,
+            constraints,
+        })
+    }
+
+    pub async fn start_proxy(&self) -> std::io::Result<StartedNetworkProxy> {
+        let state =
+            build_config_state(self.config.clone(), self.constraints.clone()).map_err(|err| {
+                std::io::Error::other(format!("failed to build network proxy state: {err}"))
+            })?;
+        let reloader = Arc::new(StaticNetworkProxyReloader::new(state.clone()));
+        let state = NetworkProxyState::with_reloader(state, reloader);
+        let proxy = NetworkProxy::builder()
+            .state(Arc::new(state))
+            .build()
+            .await
+            .map_err(|err| {
+                std::io::Error::other(format!("failed to build network proxy: {err}"))
+            })?;
+        let handle = proxy
+            .run()
+            .await
+            .map_err(|err| std::io::Error::other(format!("failed to run network proxy: {err}")))?;
+        Ok(StartedNetworkProxy::new(proxy, handle))
+    }
+
+    fn apply_requirements(
+        mut config: NetworkProxyConfig,
+        requirements: &NetworkConstraints,
+    ) -> (NetworkProxyConfig, NetworkProxyConstraints) {
+        let mut constraints = NetworkProxyConstraints::default();
+
+        if let Some(enabled) = requirements.enabled {
+            config.network.enabled = enabled;
+            constraints.enabled = Some(enabled);
+        }
+        if let Some(http_port) = requirements.http_port {
+            config.network.proxy_url = format!("http://127.0.0.1:{http_port}");
+        }
+        if let Some(socks_port) = requirements.socks_port {
+            config.network.socks_url = format!("http://127.0.0.1:{socks_port}");
+        }
+        if let Some(allow_upstream_proxy) = requirements.allow_upstream_proxy {
+            config.network.allow_upstream_proxy = allow_upstream_proxy;
+            constraints.allow_upstream_proxy = Some(allow_upstream_proxy);
+        }
+        if let Some(dangerously_allow_non_loopback_proxy) =
+            requirements.dangerously_allow_non_loopback_proxy
+        {
+            config.network.dangerously_allow_non_loopback_proxy =
+                dangerously_allow_non_loopback_proxy;
+            constraints.dangerously_allow_non_loopback_proxy =
+                Some(dangerously_allow_non_loopback_proxy);
+        }
+        if let Some(dangerously_allow_non_loopback_admin) =
+            requirements.dangerously_allow_non_loopback_admin
+        {
+            config.network.dangerously_allow_non_loopback_admin =
+                dangerously_allow_non_loopback_admin;
+            constraints.dangerously_allow_non_loopback_admin =
+                Some(dangerously_allow_non_loopback_admin);
+        }
+        if let Some(allowed_domains) = requirements.allowed_domains.clone() {
+            config.network.allowed_domains = allowed_domains.clone();
+            constraints.allowed_domains = Some(allowed_domains);
+        }
+        if let Some(denied_domains) = requirements.denied_domains.clone() {
+            config.network.denied_domains = denied_domains.clone();
+            constraints.denied_domains = Some(denied_domains);
+        }
+        if let Some(allow_unix_sockets) = requirements.allow_unix_sockets.clone() {
+            config.network.allow_unix_sockets = allow_unix_sockets.clone();
+            constraints.allow_unix_sockets = Some(allow_unix_sockets);
+        }
+        if let Some(allow_local_binding) = requirements.allow_local_binding {
+            config.network.allow_local_binding = allow_local_binding;
+            constraints.allow_local_binding = Some(allow_local_binding);
+        }
+
+        (config, constraints)
+    }
+}