fix: overhaul how we spawn commands under seccomp/landlock on Linux

codex-rs/cli/Cargo.toml

@@ -7,10 +7,6 @@ edition = "2024"
 name = "codex"
 path = "src/main.rs"
 
-[[bin]]
-name = "codex-linux-sandbox"
-path = "src/linux-sandbox/main.rs"
-
 [lib]
 name = "codex_cli"
 path = "src/lib.rs"

codex-rs/cli/src/landlock.rs

@@ -1,37 +0,0 @@
-//! `debug landlock` implementation for the Codex CLI.
-//!
-//! 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 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>, 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, env)?;
-        let status = child.wait()?;
-        Ok(status)
-    });
-    let status = handle
-        .join()
-        .map_err(|e| anyhow::anyhow!("Failed to join thread: {e:?}"))??;
-
-    handle_exit_status(status);
-}

codex-rs/cli/src/lib.rs

@@ -1,6 +1,4 @@
 mod exit_status;
-#[cfg(unix)]
-pub mod landlock;
 pub mod proto;
 pub mod seatbelt;
 

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

@@ -1,28 +0,0 @@
-#[cfg(not(target_os = "linux"))]
-fn main() -> anyhow::Result<()> {
-    eprintln!("codex-linux-sandbox is not supported on this platform.");
-    std::process::exit(1);
-}
-
-#[cfg(target_os = "linux")]
-fn main() -> anyhow::Result<()> {
-    use clap::Parser;
-    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,
-        sandbox,
-        command,
-    } = LandlockCommand::parse();
-    let sandbox_policy = create_sandbox_policy(full_auto, sandbox);
-    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

@@ -6,6 +6,7 @@ use codex_cli::proto;
 use codex_cli::seatbelt;
 use codex_core::config::Config;
 use codex_core::config::ConfigOverrides;
+use codex_core::exec_env::create_env;
 use codex_exec::Cli as ExecCli;
 use codex_tui::Cli as TuiCli;
 
@@ -94,22 +95,32 @@ async fn main() -> anyhow::Result<()> {
                 })?;
                 seatbelt::run_seatbelt(command, &config).await?;
             }
-            #[cfg(unix)]
             DebugCommand::Landlock(LandlockCommand {
                 command,
                 sandbox,
                 full_auto,
             }) => {
                 let sandbox_policy = create_sandbox_policy(full_auto, sandbox);
+                let cwd = std::env::current_dir()?;
                 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(_) => {
-                anyhow::bail!("Landlock is only supported on Linux.");
+                let full_args = codex_core::exec::create_linux_sandbox_command_args(
+                    command,
+                    &config.sandbox_policy,
+                    &cwd,
+                );
+
+                let env = create_env(&config.shell_environment_policy);
+                codex_core::exec::spawn_command_under_linux_sandbox(
+                    full_args,
+                    &config.sandbox_policy,
+                    cwd,
+                    codex_core::exec::StdioPolicy::Inherit,
+                    env,
+                )
+                .await?;
             }
         },
     }