feat: introduce support for shell_environment_policy in config.toml

codex-rs/cli/src/landlock.rs

@@ -3,27 +3,29 @@
 //! On Linux the command is executed inside a Landlock + seccomp sandbox by
 //! calling the low-level `exec_linux` helper from `codex_core::linux`.
 
+use codex_core::config::Config;
 use codex_core::exec::StdioPolicy;
 use codex_core::exec::spawn_child_sync;
 use codex_core::exec_linux::apply_sandbox_policy_to_current_thread;
-use codex_core::protocol::SandboxPolicy;
 use std::process::ExitStatus;
 
 use crate::exit_status::handle_exit_status;
 
 /// Execute `command` in a Linux sandbox (Landlock + seccomp) the way Codex
 /// would.
-pub fn run_landlock(command: Vec<String>, sandbox_policy: SandboxPolicy) -> anyhow::Result<()> {
+pub fn run_landlock(command: Vec<String>, config: &Config) -> anyhow::Result<()> {
     if command.is_empty() {
         anyhow::bail!("command args are empty");
     }
 
     // Spawn a new thread and apply the sandbox policies there.
+    let env = codex_core::exec_env::create_env(&config.shell_environment_policy);
+    let sandbox_policy = config.sandbox_policy.clone();
     let handle = std::thread::spawn(move || -> anyhow::Result<ExitStatus> {
         let cwd = std::env::current_dir()?;
 
         apply_sandbox_policy_to_current_thread(&sandbox_policy, &cwd)?;
-        let mut child = spawn_child_sync(command, cwd, &sandbox_policy, StdioPolicy::Inherit)?;
+        let mut child = spawn_child_sync(command, cwd, &sandbox_policy, StdioPolicy::Inherit, env)?;
         let status = child.wait()?;
         Ok(status)
     });

codex-rs/cli/src/linux-sandbox/main.rs

@@ -10,6 +10,8 @@ fn main() -> anyhow::Result<()> {
     use codex_cli::LandlockCommand;
     use codex_cli::create_sandbox_policy;
     use codex_cli::landlock;
+    use codex_core::config::Config;
+    use codex_core::config::ConfigOverrides;
 
     let LandlockCommand {
         full_auto,
@@ -17,6 +19,10 @@ fn main() -> anyhow::Result<()> {
         command,
     } = LandlockCommand::parse();
     let sandbox_policy = create_sandbox_policy(full_auto, sandbox);
-    landlock::run_landlock(command, sandbox_policy)?;
+    let config = Config::load_with_overrides(ConfigOverrides {
+        sandbox_policy: Some(sandbox_policy),
+        ..Default::default()
+    })?;
+    landlock::run_landlock(command, &config)?;
     Ok(())
 }

codex-rs/cli/src/main.rs

@@ -4,6 +4,8 @@ use codex_cli::SeatbeltCommand;
 use codex_cli::create_sandbox_policy;
 use codex_cli::proto;
 use codex_cli::seatbelt;
+use codex_core::config::Config;
+use codex_core::config::ConfigOverrides;
 use codex_exec::Cli as ExecCli;
 use codex_tui::Cli as TuiCli;
 
@@ -86,7 +88,11 @@ async fn main() -> anyhow::Result<()> {
                 full_auto,
             }) => {
                 let sandbox_policy = create_sandbox_policy(full_auto, sandbox);
-                seatbelt::run_seatbelt(command, sandbox_policy).await?;
+                let config = Config::load_with_overrides(ConfigOverrides {
+                    sandbox_policy: Some(sandbox_policy),
+                    ..Default::default()
+                })?;
+                seatbelt::run_seatbelt(command, &config).await?;
             }
             #[cfg(unix)]
             DebugCommand::Landlock(LandlockCommand {
@@ -95,7 +101,11 @@ async fn main() -> anyhow::Result<()> {
                 full_auto,
             }) => {
                 let sandbox_policy = create_sandbox_policy(full_auto, sandbox);
-                codex_cli::landlock::run_landlock(command, sandbox_policy)?;
+                let config = Config::load_with_overrides(ConfigOverrides {
+                    sandbox_policy: Some(sandbox_policy),
+                    ..Default::default()
+                })?;
+                codex_cli::landlock::run_landlock(command, &config)?;
             }
             #[cfg(not(unix))]
             DebugCommand::Landlock(_) => {

codex-rs/cli/src/seatbelt.rs

@@ -1,16 +1,21 @@
+use codex_core::config::Config;
 use codex_core::exec::StdioPolicy;
 use codex_core::exec::spawn_command_under_seatbelt;
-use codex_core::protocol::SandboxPolicy;
+use codex_core::exec_env::create_env;
 
 use crate::exit_status::handle_exit_status;
 
-pub async fn run_seatbelt(
-    command: Vec<String>,
-    sandbox_policy: SandboxPolicy,
-) -> anyhow::Result<()> {
+pub async fn run_seatbelt(command: Vec<String>, config: &Config) -> anyhow::Result<()> {
     let cwd = std::env::current_dir()?;
-    let mut child =
-        spawn_command_under_seatbelt(command, &sandbox_policy, cwd, StdioPolicy::Inherit).await?;
+    let env = create_env(&config.shell_environment_policy);
+    let mut child = spawn_command_under_seatbelt(
+        command,
+        &config.sandbox_policy,
+        cwd,
+        StdioPolicy::Inherit,
+        env,
+    )
+    .await?;
     let status = child.wait().await?;
     handle_exit_status(status);
 }