Lightweight coding agent that runs in your terminal
Rust
Remove the patched zsh shell execution backend (#52160)
jifcd85a26cae00
diff --git a/.github/scripts/windows_bazel_test_durations.tsv b/.github/scripts/windows_bazel_test_durations.tsvindex 32bcc24783..3cd4b4283a 100644--- a/.github/scripts/windows_bazel_test_durations.tsv+++ b/.github/scripts/windows_bazel_test_durations.tsv@@ -218,8 +218,6 @@//codex-rs/sandboxing:sandboxing-unit-tests 74//codex-rs/secrets:secrets-unit-tests 57//codex-rs/shell-command:shell-command-unit-tests 60-//codex-rs/shell-escalation:codex-execve-wrapper-bin-unit-tests 62-//codex-rs/shell-escalation:shell-escalation-unit-tests 60//codex-rs/skills:skills-unit-tests 59//codex-rs/state:state-unit-tests 242//codex-rs/test-binary-support:test-binary-support-unit-tests 48diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lockindex bb0ae5b38b..6e275de4d4 100644--- a/codex-rs/Cargo.lock+++ b/codex-rs/Cargo.lock@@ -2350,7 +2350,6 @@ dependencies = ["codex-install-context","codex-linux-sandbox","codex-sandboxing",- "codex-shell-escalation","codex-utils-absolute-path","codex-utils-cargo-bin","codex-utils-home-dir",@@ -2966,7 +2965,6 @@ dependencies = ["codex-rollout-trace","codex-sandboxing","codex-shell-command",- "codex-shell-escalation","codex-skills","codex-skills-extension","codex-state",@@ -4561,26 +4559,6 @@ dependencies = ["which 8.0.0",]-[[package]]-name = "codex-shell-escalation"-version = "0.0.0"-dependencies = [- "anyhow",- "clap",- "codex-protocol",- "codex-utils-absolute-path",- "libc",- "pretty_assertions",- "serde",- "serde_json",- "socket2 0.6.3",- "tempfile",- "tokio",- "tokio-util",- "tracing",- "tracing-subscriber",-]-[[package]]name = "codex-skills"version = "0.0.0"@@ -4765,7 +4743,6 @@ dependencies = ["codex-features","codex-file-system","codex-protocol",- "codex-utils-absolute-path","codex-utils-cargo-bin","codex-utils-output-truncation","codex-utils-path-uri",@@ -4776,7 +4753,6 @@ dependencies = ["serde","serde_json","thiserror 2.0.18",- "tracing","urlencoding",]diff --git a/codex-rs/Cargo.toml b/codex-rs/Cargo.tomlindex 73c3ed62bd..4703a04f6d 100644--- a/codex-rs/Cargo.toml+++ b/codex-rs/Cargo.toml@@ -42,7 +42,6 @@ members = ["config-schema","context-fragments","shell-command",- "shell-escalation","skills","core","core-api",@@ -275,7 +274,6 @@ codex-rollout-trace = { path = "rollout-trace" }codex-sandboxing = { path = "sandboxing" }codex-secrets = { path = "secrets" }codex-shell-command = { path = "shell-command" }-codex-shell-escalation = { path = "shell-escalation" }codex-skills-extension = { path = "ext/skills" }codex-skills = { path = "skills" }codex-state = { path = "state" }@@ -480,7 +478,6 @@ symphonia = { version = "0.6.0", default-features = false, features = ["ogg","wav",] }-socket2 = "0.6.1"# Keep SQLx versions in sync; when bumping, audit the SQLite constructor deny list in clippy.toml.sqlx = { version = "=0.9.0", default-features = false, features = ["chrono",diff --git a/codex-rs/app-server-test-client/src/lib.rs b/codex-rs/app-server-test-client/src/lib.rsindex 64c82fa5dc..26aeed921f 100644--- a/codex-rs/app-server-test-client/src/lib.rs+++ b/codex-rs/app-server-test-client/src/lib.rs@@ -219,18 +219,6 @@ enum CliCommand {/// Follow-up user message for the second turn.follow_up_message: String,},- /// Trigger zsh-fork multi-subcommand approvals and assert expected approval behavior.- #[command(name = "trigger-zsh-fork-multi-cmd-approval")]- TriggerZshForkMultiCmdApproval {- /// Optional prompt; defaults to an explicit `/usr/bin/true && /usr/bin/true` command.- user_message: Option<String>,- /// Minimum number of command-approval callbacks expected in the turn.- #[arg(long, default_value_t = 2)]- min_approvals: usize,- /// One-based approval index to abort (e.g. --abort-on 2 aborts the second approval).- #[arg(long)]- abort_on: Option<usize>,- },/// Trigger a ChatGPT or Amazon Bedrock login flow.TestLogin {/// Use the device-code login flow instead of the browser callback flow.@@ -417,22 +405,6 @@ pub async fn run() -> Result<()> {).await}- CliCommand::TriggerZshForkMultiCmdApproval {- user_message,- min_approvals,- abort_on,- } => {- let endpoint = resolve_endpoint(codex_bin, url)?;- trigger_zsh_fork_multi_cmd_approval(- &endpoint,- &config_overrides,- user_message,- min_approvals,- abort_on,- &dynamic_tools,- )- .await- }CliCommand::TestLogin {device_code,amazon_bedrock,@@ -821,112 +793,6 @@ async fn send_message_v2_endpoint(.await}-async fn trigger_zsh_fork_multi_cmd_approval(- endpoint: &Endpoint,- config_overrides: &[String],- user_message: Option<String>,- min_approvals: usize,- abort_on: Option<usize>,- dynamic_tools: &Option<Vec<DynamicToolSpec>>,-) -> Result<()> {- if let Some(abort_on) = abort_on- && abort_on == 0- {- bail!("--abort-on must be >= 1 when provided");- }-- let default_prompt = "Run this exact command using shell command execution without rewriting or splitting it: /usr/bin/true && /usr/bin/true";- let message = user_message.unwrap_or_else(|| default_prompt.to_string());-- with_client(- "trigger-zsh-fork-multi-cmd-approval",- endpoint,- config_overrides,- |client| {- let initialize = client.initialize()?;- println!("< initialize response: {initialize:?}");-- let thread_response = client.thread_start(ThreadStartParams {- dynamic_tools: dynamic_tools.clone(),- ..Default::default()- })?;- println!("< thread/start response: {thread_response:?}");-- client.command_approval_behavior = match abort_on {- Some(index) => CommandApprovalBehavior::AbortOn(index),- None => CommandApprovalBehavior::AlwaysAccept,- };- client.command_approval_count = 0;- client.command_approval_item_ids.clear();- client.command_execution_statuses.clear();- client.last_turn_status = None;-- let mut turn_params = TurnStartParams {- thread_id: thread_response.thread.id.clone(),- client_user_message_id: None,- input: vec![V2UserInput::Text {- text: message,- text_elements: Vec::new(),- }],- ..Default::default()- };- turn_params.approval_policy = Some(AskForApproval::OnRequest);- turn_params.sandbox_policy = Some(SandboxPolicy::ReadOnly {- network_access: false,- });-- let turn_response = client.turn_start(turn_params)?;- println!("< turn/start response: {turn_response:?}");- client.stream_turn(&thread_response.thread.id, &turn_response.turn.id)?;-- if client.command_approval_count < min_approvals {- bail!(- "expected at least {min_approvals} command approvals, got {}",- client.command_approval_count- );- }- let mut approvals_per_item = std::collections::BTreeMap::new();- for item_id in &client.command_approval_item_ids {- *approvals_per_item.entry(item_id.clone()).or_insert(0usize) += 1;- }- let max_approvals_for_one_item =- approvals_per_item.values().copied().max().unwrap_or(0);- if max_approvals_for_one_item < min_approvals {- bail!(- "expected at least {min_approvals} approvals for one command item, got max {max_approvals_for_one_item} with map {approvals_per_item:?}"- );- }-- let last_command_status = client.command_execution_statuses.last();- if abort_on.is_none() {- if last_command_status != Some(&CommandExecutionStatus::Completed) {- bail!("expected completed command execution, got {last_command_status:?}");- }- if client.last_turn_status != Some(TurnStatus::Completed) {- bail!(- "expected completed turn in all-accept flow, got {:?}",- client.last_turn_status- );- }- } else if last_command_status == Some(&CommandExecutionStatus::Completed) {- bail!(- "expected non-completed command execution in mixed approval/decline flow, got {last_command_status:?}"- );- }-- println!(- "[zsh-fork multi-approval summary] approvals={}, approvals_per_item={approvals_per_item:?}, command_statuses={:?}, turn_status={:?}",- client.command_approval_count,- client.command_execution_statuses,- client.last_turn_status- );-- Ok(())- },- )- .await-}-async fn resume_message_v2(endpoint: &Endpoint,config_overrides: &[String],@@ -1582,9 +1448,7 @@ enum ClientTransport {struct CodexClient {transport: ClientTransport,pending_notifications: VecDeque<JSONRPCNotification>,- command_approval_behavior: CommandApprovalBehavior,command_approval_count: usize,- command_approval_item_ids: Vec<String>,command_execution_statuses: Vec<CommandExecutionStatus>,command_execution_outputs: Vec<String>,command_output_stream: String,@@ -1596,12 +1460,6 @@ struct CodexClient {last_turn_error_message: Option<String>,}-#[derive(Debug, Clone, Copy)]-enum CommandApprovalBehavior {- AlwaysAccept,- AbortOn(usize),-}-fn item_started_before_helper_done_is_unexpected(item: &ThreadItem,command_item_started: bool,@@ -1671,9 +1529,7 @@ impl CodexClient {stdout: BufReader::new(stdout),},pending_notifications: VecDeque::new(),- command_approval_behavior: CommandApprovalBehavior::AlwaysAccept,command_approval_count: 0,- command_approval_item_ids: Vec::new(),command_execution_statuses: Vec::new(),command_execution_outputs: Vec::new(),command_output_stream: String::new(),@@ -1710,9 +1566,7 @@ impl CodexClient {socket: Box::new(socket),},pending_notifications: VecDeque::new(),- command_approval_behavior: CommandApprovalBehavior::AlwaysAccept,command_approval_count: 0,- command_approval_item_ids: Vec::new(),command_execution_statuses: Vec::new(),command_execution_outputs: Vec::new(),command_output_stream: String::new(),@@ -2194,7 +2048,6 @@ impl CodexClient {approval_id.as_deref().unwrap_or("<none>"));self.command_approval_count += 1;- self.command_approval_item_ids.push(item_id.clone());if let Some(environment_id) = environment_id.as_deref() {println!("< environment: {environment_id}");}@@ -2228,13 +2081,7 @@ impl CodexClient {println!("< proposed network policy amendments: {network_policy_amendments:?}");}- let decision = match self.command_approval_behavior {- CommandApprovalBehavior::AlwaysAccept => CommandExecutionApprovalDecision::Accept,- CommandApprovalBehavior::AbortOn(index) if self.command_approval_count == index => {- CommandExecutionApprovalDecision::Cancel- }- CommandApprovalBehavior::AbortOn(_) => CommandExecutionApprovalDecision::Accept,- };+ let decision = CommandExecutionApprovalDecision::Accept;let response = CommandExecutionRequestApprovalResponse {decision: decision.clone(),};diff --git a/codex-rs/app-server/src/config_manager.rs b/codex-rs/app-server/src/config_manager.rsindex 2f826de9ff..10739fb0ef 100644--- a/codex-rs/app-server/src/config_manager.rs+++ b/codex-rs/app-server/src/config_manager.rs@@ -240,7 +240,6 @@ impl ConfigManager {cwd.to_path_buf(),&layers,codex_home,- /*default_zsh_path*/ None,).await?;self.apply_network_policy(&mut config);@@ -266,7 +265,6 @@ impl ConfigManager {cwd.to_path_buf(),&refreshed_layers,AbsolutePathBuf::from_absolute_path(&self.codex_home)?,- /*default_zsh_path*/ None,).await?;self.apply_network_policy(&mut config);@@ -434,7 +432,6 @@ impl ConfigManager {cwd: Some(cwd.to_path_buf()),default_permissions: Some(permission_profile),codex_linux_sandbox_exe: self.arg0_paths.codex_linux_sandbox_exe.clone(),- main_execve_wrapper_exe: self.arg0_paths.main_execve_wrapper_exe.clone(),..Default::default()},Some(cwd.to_path_buf()),@@ -548,7 +545,6 @@ impl ConfigManager {fn apply_arg0_paths(&self, config: &mut Config) {config.codex_self_exe = self.arg0_paths.codex_self_exe.clone();config.codex_linux_sandbox_exe = self.arg0_paths.codex_linux_sandbox_exe.clone();- config.main_execve_wrapper_exe = self.arg0_paths.main_execve_wrapper_exe.clone();}#[cfg(test)]diff --git a/codex-rs/app-server/src/config_manager_service_tests.rs b/codex-rs/app-server/src/config_manager_service_tests.rsindex af60acb652..d390205cf5 100644--- a/codex-rs/app-server/src/config_manager_service_tests.rs+++ b/codex-rs/app-server/src/config_manager_service_tests.rs@@ -2757,20 +2757,13 @@ async fn permission_config_reload_merges_session_layers() -> Result<()> {use codex_config::ConfigLayerSource;use codex_config::ConfigLayerStack;let tmp = tempdir()?;- let wrapper_dir = tmp.path().join("tmp/arg0/session");- std::fs::create_dir_all(&wrapper_dir)?;- let wrapper = wrapper_dir.join("codex-execve-wrapper");- std::fs::write(&wrapper, "")?;let service = ConfigManager::new(tmp.path().to_path_buf(),Vec::new(),LoaderOverrides::without_managed_config_for_tests(),/*strict_config*/ false,CloudConfigBundleLoader::default(),- codex_arg0::Arg0DispatchPaths {- main_execve_wrapper_exe: Some(wrapper),- ..Default::default()- },+ codex_arg0::Arg0DispatchPaths::default(),std::sync::Arc::new(codex_config::NoopThreadConfigLoader),);@@ -2815,16 +2808,5 @@ async fn permission_config_reload_merges_session_layers() -> Result<()> {.collect::<Vec<_>>(),vec!["first", "second"]);- let policy = loaded.permissions.file_system_sandbox_policy();- assert_eq!(- (- policy.can_read_local_path_with_cwd(&wrapper_dir, loaded.cwd.as_path()),- policy.can_read_local_path_with_cwd(- &tmp.path().join("tmp/arg0/other"),- loaded.cwd.as_path()- ),- ),- (true, false),- );Ok(())}diff --git a/codex-rs/app-server/src/external_agent_migration/session_importer.rs b/codex-rs/app-server/src/external_agent_migration/session_importer.rsindex 33f28ed878..13fbb93627 100644--- a/codex-rs/app-server/src/external_agent_migration/session_importer.rs+++ b/codex-rs/app-server/src/external_agent_migration/session_importer.rs@@ -405,7 +405,6 @@ impl ExternalAgentSessionImporter {ConfigOverrides {cwd: Some(cwd),codex_linux_sandbox_exe: self.arg0_paths.codex_linux_sandbox_exe.clone(),- main_execve_wrapper_exe: self.arg0_paths.main_execve_wrapper_exe.clone(),..Default::default()},)diff --git a/codex-rs/app-server/src/request_processors/thread_processor.rs b/codex-rs/app-server/src/request_processors/thread_processor.rsindex efad426991..abc2daf877 100644--- a/codex-rs/app-server/src/request_processors/thread_processor.rs+++ b/codex-rs/app-server/src/request_processors/thread_processor.rs@@ -1693,7 +1693,6 @@ impl ThreadRequestProcessor {.map(codex_app_server_protocol::ApprovalsReviewer::to_core),sandbox_mode: sandbox.map(SandboxMode::to_core),codex_linux_sandbox_exe: self.arg0_paths.codex_linux_sandbox_exe.clone(),- main_execve_wrapper_exe: self.arg0_paths.main_execve_wrapper_exe.clone(),base_instructions,developer_instructions,personality,diff --git a/codex-rs/app-server/tests/suite/v2/analytics.rs b/codex-rs/app-server/tests/suite/v2/analytics.rsindex 32a3ca8d8c..d8e8813c97 100644--- a/codex-rs/app-server/tests/suite/v2/analytics.rs+++ b/codex-rs/app-server/tests/suite/v2/analytics.rs@@ -907,8 +907,6 @@ default_mode_request_user_input = trueplugins = trueremote_plugin = falseunified_exec = true-shell_zsh_fork = false-unified_exec_zsh_fork = false[plugins."{METRICS_PLUGIN_ID}"]enabled = truediff --git a/codex-rs/app-server/tests/suite/v2/mod.rs b/codex-rs/app-server/tests/suite/v2/mod.rsindex 75855aad4d..d8d1e44192 100644--- a/codex-rs/app-server/tests/suite/v2/mod.rs+++ b/codex-rs/app-server/tests/suite/v2/mod.rs@@ -162,7 +162,6 @@ mod turn_cost_otel;mod turn_interrupt;mod turn_settings_update;mod turn_start;-mod turn_start_zsh_fork;mod turn_steer;mod view_image;mod web_search;diff --git a/codex-rs/app-server/tests/suite/v2/turn_start.rs b/codex-rs/app-server/tests/suite/v2/turn_start.rsindex b27ac1a1b2..ab566dc094 100644--- a/codex-rs/app-server/tests/suite/v2/turn_start.rs+++ b/codex-rs/app-server/tests/suite/v2/turn_start.rs@@ -5468,7 +5468,6 @@ async fn command_execution_notifications_include_process_id(MockResponsesConfig::new(&server.uri()).with_sandbox_mode("danger-full-access").enable_feature(Feature::UnifiedExec)- .disable_feature(Feature::ShellZshFork).disable_feature(Feature::ShellSnapshot).write(codex_home.path())?;@@ -5653,7 +5652,6 @@ async fn command_execution_notifications_include_trusted_plugin_id(.enable_feature(Feature::Plugins).enable_feature(Feature::UnifiedExec).disable_feature(Feature::RemotePlugin)- .disable_feature(Feature::ShellZshFork).disable_feature(Feature::ShellSnapshot).with_extra_config("[plugins.\"google-calendar@openai-api-curated\"]\nenabled = true").write(codex_home.path())?;diff --git a/codex-rs/app-server/tests/suite/v2/turn_start_zsh_fork.rs b/codex-rs/app-server/tests/suite/v2/turn_start_zsh_fork.rsdeleted file mode 100644index 9384541311..0000000000--- a/codex-rs/app-server/tests/suite/v2/turn_start_zsh_fork.rs+++ /dev/null@@ -1,847 +0,0 @@-#![cfg(not(windows))]-//-// Running these tests with the patched zsh fork:-//-// The suite resolves the shared test-only zsh DotSlash file at-// `app-server/tests/suite/zsh` via DotSlash on first use, so `dotslash` and-// network access are required the first time the artifact is fetched.--use anyhow::Result;-use app_test_support::MockResponsesConfig;-use app_test_support::TestAppServer;-use app_test_support::create_command_execution_sse_response;-use app_test_support::create_escalated_command_execution_sse_response;-use app_test_support::create_final_assistant_message_sse_response;-use app_test_support::create_mock_responses_server_sequence;-use app_test_support::create_mock_responses_server_sequence_unchecked;-use codex_app_server_protocol::CommandAction;-use codex_app_server_protocol::CommandExecutionApprovalDecision;-use codex_app_server_protocol::CommandExecutionRequestApprovalResponse;-use codex_app_server_protocol::CommandExecutionStatus;-use codex_app_server_protocol::ItemCompletedNotification;-use codex_app_server_protocol::ItemStartedNotification;-use codex_app_server_protocol::ServerRequest;-use codex_app_server_protocol::ThreadItem;-use codex_app_server_protocol::ThreadStartParams;-use codex_app_server_protocol::ThreadStartResponse;-use codex_app_server_protocol::TurnCompletedNotification;-use codex_app_server_protocol::TurnStartParams;-use codex_app_server_protocol::TurnStartResponse;-use codex_app_server_protocol::TurnStatus;-use codex_app_server_protocol::UserInput as V2UserInput;-use codex_features::Feature;-use core_test_support::responses;-use core_test_support::skip_if_no_network;-use core_test_support::skip_if_remote;-use pretty_assertions::assert_eq;-use std::collections::BTreeMap;-use std::path::Path;-use std::path::PathBuf;-use tempfile::TempDir;-use test_case::test_case;-use tokio::time::timeout;--#[cfg(windows)]-const DEFAULT_READ_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(15);-#[cfg(not(windows))]-const DEFAULT_READ_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(10);--#[tokio::test]-async fn turn_start_shell_zsh_fork_executes_command_v2() -> Result<()> {- // TODO(anp): Remove after zsh-fork fixtures can run in the selected remote environment.- skip_if_remote!(- Ok(()),- "zsh-fork fixtures use host-local zsh and workspace paths"- );- skip_if_no_network!(Ok(()));-- let tmp = TempDir::new()?;- let codex_home = tmp.path().join("codex_home");- std::fs::create_dir(&codex_home)?;- let workspace = tmp.path().join("workspace");- std::fs::create_dir(&workspace)?;- let release_marker = workspace.join("interrupt-release");-- let Some(zsh_path) = find_test_zsh_path()? else {- eprintln!("skipping zsh fork test: no zsh executable found");- return Ok(());- };- eprintln!("using zsh path for zsh-fork test: {}", zsh_path.display());-- // Keep the shell command in flight until we interrupt it. A fast command- // like `echo hi` can finish before the interrupt arrives on faster runners,- // which turns this into a test for post-command follow-up behavior instead- // of interrupting an active zsh-fork command.- let release_marker_escaped = release_marker.to_string_lossy().replace('\'', r#"'\''"#);- let wait_for_interrupt =- format!("while [ ! -f '{release_marker_escaped}' ]; do sleep 0.01; done");- let response = create_command_execution_sse_response(- vec!["/bin/sh".to_string(), "-c".to_string(), wait_for_interrupt],- /*workdir*/ None,- Some(5000),- "call-zsh-fork",- )?;- let no_op_response = responses::sse(vec![- responses::ev_response_created("resp-2"),- responses::ev_completed("resp-2"),- ]);- // Interrupting after the shell item starts can race with the follow-up- // model request that reports the aborted tool call. This test only cares- // that zsh-fork launches the expected command, so allow one extra no-op- // `/responses` POST instead of asserting an exact request count.- let server =- create_mock_responses_server_sequence_unchecked(vec![response, no_op_response]).await;- create_config_toml(- &codex_home,- &server.uri(),- "never",- &BTreeMap::from([- (Feature::ShellZshFork, true),- (Feature::ShellSnapshot, false),- ]),- )?;-- let mut mcp = create_zsh_test_mcp_process(&codex_home, &workspace, &zsh_path).await?;-- let start_id = mcp- .send_thread_start_request_with_auto_env(ThreadStartParams {- model: Some("mock-model".to_string()),- cwd: Some(workspace.to_string_lossy().into_owned()),- ..Default::default()- })- .await?;- let ThreadStartResponse { thread, .. } =- timeout(DEFAULT_READ_TIMEOUT, mcp.read_response(start_id)).await??;-- let turn_id = mcp- .send_turn_start_request(TurnStartParams {- thread_id: thread.id.clone(),- client_user_message_id: None,- input: vec![V2UserInput::Text {- text: "run echo hi".to_string(),- text_elements: Vec::new(),- }],- cwd: Some(workspace.clone()),- approval_policy: Some(codex_app_server_protocol::AskForApproval::Never),- sandbox_policy: Some(codex_app_server_protocol::SandboxPolicy::DangerFullAccess),- model: Some("mock-model".to_string()),- effort: Some(codex_protocol::openai_models::ReasoningEffort::Medium),- summary: Some(codex_protocol::config_types::ReasoningSummary::Auto),- ..Default::default()- })- .await?;- let TurnStartResponse { turn } =- timeout(DEFAULT_READ_TIMEOUT, mcp.read_response(turn_id)).await??;-- let started_command_execution = timeout(DEFAULT_READ_TIMEOUT, async {- loop {- let started_notif = mcp- .read_stream_until_notification_message("item/started")- .await?;- let started: ItemStartedNotification =- serde_json::from_value(started_notif.params.clone().expect("item/started params"))?;- if let ThreadItem::CommandExecution { .. } = started.item {- return Ok::<ThreadItem, anyhow::Error>(started.item);- }- }- })- .await??;- let ThreadItem::CommandExecution {- id,- status,- command,- cwd,- ..- } = started_command_execution- else {- unreachable!("loop ensures we break on command execution items");- };- assert_eq!(id, "call-zsh-fork");- assert_eq!(status, CommandExecutionStatus::InProgress);- assert!(command.starts_with(&command_packaged_zsh_path(&codex_home).display().to_string()));- assert!(command.contains("/bin/sh -c"));- assert!(command.contains("sleep 0.01"));- assert!(command.contains(&release_marker.display().to_string()));- assert_eq!(cwd.as_str(), workspace.to_string_lossy().as_ref());-- mcp.interrupt_turn_and_wait_for_aborted(thread.id, turn.id, DEFAULT_READ_TIMEOUT)- .await?;-- Ok(())-}--#[test_case(CommandExecutionApprovalDecision::Decline; "declined")]-#[test_case(CommandExecutionApprovalDecision::Accept; "launch_failure")]-#[tokio::test]-async fn turn_start_shell_zsh_fork_exec_approval_v2(- decision: CommandExecutionApprovalDecision,-) -> Result<()> {- // TODO(anp): Remove after zsh-fork fixtures can run in the selected remote environment.- skip_if_remote!(- Ok(()),- "zsh-fork fixtures use host-local zsh and workspace paths"- );- skip_if_no_network!(Ok(()));-- let tmp = TempDir::new()?;- let codex_home = tmp.path().join("codex_home");- std::fs::create_dir(&codex_home)?;- let workspace = tmp.path().join("workspace");- std::fs::create_dir(&workspace)?;-- let Some(zsh_path) = find_test_zsh_path()? else {- eprintln!("skipping zsh fork decline test: no zsh executable found");- return Ok(());- };- eprintln!("using zsh path for zsh-fork test: {}", zsh_path.display());-- let launch_failed = matches!(decision, CommandExecutionApprovalDecision::Accept);- let missing_cwd = workspace.join("missing-work-directory");- let responses = vec![- create_escalated_command_execution_sse_response(- vec![- "python3".to_string(),- "-c".to_string(),- "print(42)".to_string(),- ],- launch_failed.then_some(missing_cwd.as_path()),- Some(5000),- "call-zsh-fork-decline",- )?,- create_final_assistant_message_sse_response("done")?,- ];- let server = create_mock_responses_server_sequence(responses).await;- create_config_toml(- &codex_home,- &server.uri(),- "on-request",- &BTreeMap::from([- (Feature::UnifiedExec, true),- (Feature::ShellZshFork, true),- (Feature::ShellSnapshot, false),- ]),- )?;-- let mut mcp = create_zsh_test_mcp_process(&codex_home, &workspace, &zsh_path).await?;-- let start_id = mcp- .send_thread_start_request_with_auto_env(ThreadStartParams {- model: Some("mock-model".to_string()),- cwd: Some(workspace.to_string_lossy().into_owned()),- ..Default::default()- })- .await?;- let ThreadStartResponse { thread, .. } =- timeout(DEFAULT_READ_TIMEOUT, mcp.read_response(start_id)).await??;-- let turn_id = mcp- .send_turn_start_request(TurnStartParams {- thread_id: thread.id.clone(),- client_user_message_id: None,- input: vec![V2UserInput::Text {- text: "run python".to_string(),- text_elements: Vec::new(),- }],- cwd: Some(workspace.clone()),- ..Default::default()- })- .await?;- let _: TurnStartResponse = timeout(DEFAULT_READ_TIMEOUT, mcp.read_response(turn_id)).await??;-- let server_req = timeout(- DEFAULT_READ_TIMEOUT,- mcp.read_stream_until_request_message(),- )- .await??;- let ServerRequest::CommandExecutionRequestApproval { request_id, params } = server_req else {- panic!("expected CommandExecutionRequestApproval request");- };- assert_eq!(params.item_id, "call-zsh-fork-decline");- assert_eq!(params.thread_id, thread.id);-- mcp.send_response(- request_id,- serde_json::to_value(CommandExecutionRequestApprovalResponse { decision })?,- )- .await?;-- let completed_command_execution = timeout(DEFAULT_READ_TIMEOUT, async {- loop {- let completed_notif = mcp- .read_stream_until_notification_message("item/completed")- .await?;- let completed: ItemCompletedNotification = serde_json::from_value(- completed_notif- .params- .clone()- .expect("item/completed params"),- )?;- if let ThreadItem::CommandExecution { .. } = completed.item {- return Ok::<ThreadItem, anyhow::Error>(completed.item);- }- }- })- .await??;- let ThreadItem::CommandExecution {- id,- status,- exit_code,- process_id,- duration_ms,- aggregated_output,- ..- } = completed_command_execution- else {- unreachable!("loop ensures we break on command execution items");- };- assert_eq!(id, "call-zsh-fork-decline");- assert_eq!(process_id, None);- if launch_failed {- assert_eq!(- (status, exit_code, duration_ms),- (CommandExecutionStatus::Failed, Some(-1), Some(0))- );- assert!(- aggregated_output- .expect("launch diagnostic")- .starts_with("Failed to create unified exec process:")- );- } else {- assert_eq!(- (status, exit_code, duration_ms),- (CommandExecutionStatus::Declined, None, None)- );- assert!(aggregated_output.is_none());- }-- timeout(- DEFAULT_READ_TIMEOUT,- mcp.read_stream_until_notification_message("turn/completed"),- )- .await??;-- let mut command_events = Vec::new();- for method in mcp.pending_notification_methods() {- let notification = mcp.read_stream_until_notification_message(&method).await?;- if notification.params.expect("notification params")["item"]["id"]- == "call-zsh-fork-decline"- {- command_events.push(method);- }- }- assert_eq!(command_events, ["item/started"]);-- Ok(())-}--#[tokio::test]-async fn turn_start_shell_zsh_fork_exec_approval_cancel_v2() -> Result<()> {- // TODO(anp): Remove after zsh-fork fixtures can run in the selected remote environment.- skip_if_remote!(- Ok(()),- "zsh-fork fixtures use host-local zsh and workspace paths"- );- skip_if_no_network!(Ok(()));-- let tmp = TempDir::new()?;- let codex_home = tmp.path().join("codex_home");- std::fs::create_dir(&codex_home)?;- let workspace = tmp.path().join("workspace");- std::fs::create_dir(&workspace)?;-- let Some(zsh_path) = find_test_zsh_path()? else {- eprintln!("skipping zsh fork cancel test: no zsh executable found");- return Ok(());- };- eprintln!("using zsh path for zsh-fork test: {}", zsh_path.display());-- let responses = vec![create_escalated_command_execution_sse_response(- vec![- "python3".to_string(),- "-c".to_string(),- "print(42)".to_string(),- ],- /*workdir*/ None,- Some(5000),- "call-zsh-fork-cancel",- )?];- let server = create_mock_responses_server_sequence(responses).await;- create_config_toml(- &codex_home,- &server.uri(),- "on-request",- &BTreeMap::from([- (Feature::ShellZshFork, true),- (Feature::ShellSnapshot, false),- ]),- )?;-- let mut mcp = create_zsh_test_mcp_process(&codex_home, &workspace, &zsh_path).await?;-- let start_id = mcp- .send_thread_start_request_with_auto_env(ThreadStartParams {- model: Some("mock-model".to_string()),- cwd: Some(workspace.to_string_lossy().into_owned()),- ..Default::default()- })- .await?;- let ThreadStartResponse { thread, .. } =- timeout(DEFAULT_READ_TIMEOUT, mcp.read_response(start_id)).await??;-- let turn_id = mcp- .send_turn_start_request(TurnStartParams {- thread_id: thread.id.clone(),- client_user_message_id: None,- input: vec![V2UserInput::Text {- text: "run python".to_string(),- text_elements: Vec::new(),- }],- cwd: Some(workspace.clone()),- ..Default::default()- })- .await?;- let _: TurnStartResponse = timeout(DEFAULT_READ_TIMEOUT, mcp.read_response(turn_id)).await??;-- let server_req = timeout(- DEFAULT_READ_TIMEOUT,- mcp.read_stream_until_request_message(),- )- .await??;- let ServerRequest::CommandExecutionRequestApproval { request_id, params } = server_req else {- panic!("expected CommandExecutionRequestApproval request");- };- assert_eq!(params.item_id, "call-zsh-fork-cancel");- assert_eq!(params.thread_id, thread.id.clone());-- mcp.send_response(- request_id,- serde_json::to_value(CommandExecutionRequestApprovalResponse {- decision: CommandExecutionApprovalDecision::Cancel,- })?,- )- .await?;-- let completed_command_execution = timeout(DEFAULT_READ_TIMEOUT, async {- loop {- let completed_notif = mcp- .read_stream_until_notification_message("item/completed")- .await?;- let completed: ItemCompletedNotification = serde_json::from_value(- completed_notif- .params- .clone()- .expect("item/completed params"),- )?;- if let ThreadItem::CommandExecution { .. } = completed.item {- return Ok::<ThreadItem, anyhow::Error>(completed.item);- }- }- })- .await??;- let ThreadItem::CommandExecution { id, status, .. } = completed_command_execution else {- unreachable!("loop ensures we break on command execution items");- };- assert_eq!(id, "call-zsh-fork-cancel");- assert_eq!(status, CommandExecutionStatus::Declined);-- let completed_notif = timeout(- DEFAULT_READ_TIMEOUT,- mcp.read_stream_until_notification_message("turn/completed"),- )- .await??;- let completed: TurnCompletedNotification = serde_json::from_value(- completed_notif- .params- .expect("turn/completed params must be present"),- )?;- assert_eq!(completed.thread_id, thread.id);- assert_eq!(completed.turn.status, TurnStatus::Interrupted);-- Ok(())-}--#[tokio::test]-async fn turn_start_shell_zsh_fork_subcommand_decline_marks_parent_declined_v2() -> Result<()> {- // TODO(anp): Remove after zsh-fork fixtures can run in the selected remote environment.- skip_if_remote!(- Ok(()),- "zsh-fork fixtures use host-local zsh and workspace paths"- );- skip_if_no_network!(Ok(()));-- let tmp = TempDir::new()?;- let codex_home = tmp.path().join("codex_home");- std::fs::create_dir(&codex_home)?;- let workspace = tmp.path().join("workspace");- std::fs::create_dir(&workspace)?;-- let Some(zsh_path) = find_test_zsh_path()? else {- eprintln!("skipping zsh fork subcommand decline test: no zsh executable found");- return Ok(());- };- if !supports_exec_wrapper_intercept(&zsh_path) {- eprintln!(- "skipping zsh fork subcommand decline test: zsh does not support EXEC_WRAPPER intercepts ({})",- zsh_path.display()- );- return Ok(());- }- eprintln!("using zsh path for zsh-fork test: {}", zsh_path.display());- let first_file = workspace.join("first.txt");- let second_file = workspace.join("second.txt");- std::fs::write(&first_file, "one")?;- std::fs::write(&second_file, "two")?;- let shell_command = format!(- "/bin/rm {} && /bin/rm {}",- first_file.display(),- second_file.display()- );- let tool_call_arguments = serde_json::to_string(&serde_json::json!({- "cmd": shell_command,- "workdir": serde_json::Value::Null,- "yield_time_ms": 20000- }))?;- let response = responses::sse(vec![- responses::ev_response_created("resp-1"),- responses::ev_function_call(- "call-zsh-fork-subcommand-decline",- "exec_command",- &tool_call_arguments,- ),- responses::ev_completed("resp-1"),- ]);- let no_op_response = responses::sse(vec![- responses::ev_response_created("resp-2"),- responses::ev_completed("resp-2"),- ]);- // Linux CI has occasionally issued a second `/responses` POST after the- // subcommand-decline flow. This test is about approval/decline behavior in- // the zsh fork, not exact model request count, so allow an extra request- // and return a harmless no-op response if it arrives.- let server =- create_mock_responses_server_sequence_unchecked(vec![response, no_op_response]).await;- create_config_toml(- &codex_home,- &server.uri(),- "on-request",- &BTreeMap::from([- (Feature::ShellZshFork, true),- (Feature::ShellSnapshot, false),- ]),- )?;-- let mut mcp = create_zsh_test_mcp_process(&codex_home, &workspace, &zsh_path).await?;-- let start_id = mcp- .send_thread_start_request_with_auto_env(ThreadStartParams {- model: Some("mock-model".to_string()),- cwd: Some(workspace.to_string_lossy().into_owned()),- ..Default::default()- })- .await?;- let ThreadStartResponse { thread, .. } =- timeout(DEFAULT_READ_TIMEOUT, mcp.read_response(start_id)).await??;-- let turn_id = mcp- .send_turn_start_request(TurnStartParams {- thread_id: thread.id.clone(),- client_user_message_id: None,- input: vec![V2UserInput::Text {- text: "remove both files".to_string(),- text_elements: Vec::new(),- }],- cwd: Some(workspace.clone()),- approval_policy: Some(codex_app_server_protocol::AskForApproval::UnlessTrusted),- // This test is about execve-intercept approval propagation, not- // workspace sandboxing. Using full access avoids macOS sandbox- // setup failures that can terminate the parent shell before the- // second subcommand approval is observed.- sandbox_policy: Some(codex_app_server_protocol::SandboxPolicy::DangerFullAccess),- model: Some("mock-model".to_string()),- effort: Some(codex_protocol::openai_models::ReasoningEffort::Medium),- summary: Some(codex_protocol::config_types::ReasoningSummary::Auto),- ..Default::default()- })- .await?;- let TurnStartResponse { turn } =- timeout(DEFAULT_READ_TIMEOUT, mcp.read_response(turn_id)).await??;-- let mut approved_subcommand_strings = Vec::new();- let mut approved_subcommand_ids = Vec::new();- let mut saw_parent_approval = false;- let target_decisions = [- CommandExecutionApprovalDecision::Accept,- CommandExecutionApprovalDecision::Cancel,- ];- let mut target_decision_index = 0;- let first_file_str = first_file.to_string_lossy().into_owned();- let second_file_str = second_file.to_string_lossy().into_owned();- let parent_shell_hint = format!("&& {}", &first_file_str);- while target_decision_index < target_decisions.len() || !saw_parent_approval {- let server_req = timeout(- DEFAULT_READ_TIMEOUT,- mcp.read_stream_until_request_message(),- )- .await??;- let ServerRequest::CommandExecutionRequestApproval { request_id, params } = server_req- else {- panic!("expected CommandExecutionRequestApproval request");- };- assert_eq!(params.item_id, "call-zsh-fork-subcommand-decline");- assert_eq!(params.thread_id, thread.id);- let approval_command = params- .command- .as_deref()- .expect("approval command should be present");- let has_first_file = approval_command.contains(&first_file_str);- let has_second_file = approval_command.contains(&second_file_str);- let mentions_rm_binary =- approval_command.contains("/bin/rm ") || approval_command.contains("/usr/bin/rm ");- let has_rm_action = params.command_actions.as_ref().is_some_and(|actions| {- actions.iter().any(|action| match action {- CommandAction::Read { name, .. } => name == "rm",- CommandAction::Unknown { command } => command.contains("rm"),- _ => false,- })- });- let is_target_subcommand =- (has_first_file != has_second_file) && (has_rm_action || mentions_rm_binary);-- if is_target_subcommand {- approved_subcommand_ids.push(- params- .approval_id- .clone()- .expect("approval_id must be present for zsh subcommand approvals"),- );- approved_subcommand_strings.push(approval_command.to_string());- }- let is_parent_approval = approval_command- .contains(&command_packaged_zsh_path(&codex_home).display().to_string())- && (approval_command.contains(&shell_command)- || (has_first_file && has_second_file)- || approval_command.contains(&parent_shell_hint));- let decision = if is_target_subcommand {- let decision = target_decisions[target_decision_index].clone();- target_decision_index += 1;- decision- } else if is_parent_approval {- assert!(- !saw_parent_approval,- "unexpected extra non-target approval: {approval_command}"- );- saw_parent_approval = true;- CommandExecutionApprovalDecision::Accept- } else {- // Login shells may run startup helpers (for example path_helper on macOS)- // before the parent shell command or target subcommands are reached.- CommandExecutionApprovalDecision::Accept- };- mcp.send_response(- request_id,- serde_json::to_value(CommandExecutionRequestApprovalResponse { decision })?,- )- .await?;- }-- assert!(- saw_parent_approval,- "expected parent shell approval request"- );- assert_eq!(approved_subcommand_ids.len(), 2);- assert_ne!(approved_subcommand_ids[0], approved_subcommand_ids[1]);- assert_eq!(approved_subcommand_strings.len(), 2);- assert!(approved_subcommand_strings[0].contains(&first_file.display().to_string()));- assert!(approved_subcommand_strings[1].contains(&second_file.display().to_string()));- let parent_completed_command_execution = timeout(DEFAULT_READ_TIMEOUT, async {- loop {- let completed_notif = mcp- .read_stream_until_notification_message("item/completed")- .await?;- let completed: ItemCompletedNotification = serde_json::from_value(- completed_notif- .params- .clone()- .expect("item/completed params"),- )?;- if let ThreadItem::CommandExecution { id, .. } = &completed.item- && id == "call-zsh-fork-subcommand-decline"- {- return Ok::<ThreadItem, anyhow::Error>(completed.item);- }- }- })- .await;-- match parent_completed_command_execution {- Ok(Ok(parent_completed_command_execution)) => {- let ThreadItem::CommandExecution {- id,- status,- aggregated_output,- ..- } = parent_completed_command_execution- else {- unreachable!("loop ensures we break on parent command execution item");- };- assert_eq!(id, "call-zsh-fork-subcommand-decline");- assert_eq!(status, CommandExecutionStatus::Declined);- if let Some(output) = aggregated_output.as_deref() {- assert!(- output == "exec command rejected by user"- || output.contains("sandbox denied exec error"),- "unexpected aggregated output: {output}"- );- }-- match timeout(- DEFAULT_READ_TIMEOUT,- mcp.read_stream_until_notification_message("turn/completed"),- )- .await- {- Ok(Ok(completed_notif)) => {- let completed: TurnCompletedNotification = serde_json::from_value(- completed_notif- .params- .expect("turn/completed params must be present"),- )?;- assert_eq!(completed.thread_id, thread.id);- assert_eq!(completed.turn.id, turn.id);- assert!(matches!(- completed.turn.status,- TurnStatus::Interrupted | TurnStatus::Completed- ));- }- Ok(Err(error)) => return Err(error),- Err(_) => {- mcp.interrupt_turn_and_wait_for_aborted(- thread.id.clone(),- turn.id.clone(),- DEFAULT_READ_TIMEOUT,- )- .await?;- }- }- }- Ok(Err(error)) => return Err(error),- Err(_) => {- // Some zsh builds abort the turn immediately after the rejected- // subcommand without emitting a parent `item/completed`, and Linux- // sandbox failures can also complete the turn before the parent- // completion item is observed.- let completed_notif = timeout(- DEFAULT_READ_TIMEOUT,- mcp.read_stream_until_notification_message("turn/completed"),- )- .await??;- let completed: TurnCompletedNotification = serde_json::from_value(- completed_notif- .params- .expect("turn/completed params must be present"),- )?;- assert_eq!(completed.thread_id, thread.id);- assert_eq!(completed.turn.id, turn.id);- assert!(matches!(- completed.turn.status,- TurnStatus::Interrupted | TurnStatus::Completed- ));- }- }-- Ok(())-}--async fn create_zsh_test_mcp_process(- codex_home: &Path,- zdotdir: &Path,- zsh_path: &Path,-) -> Result<TestAppServer> {- let app_server = create_test_package_app_server(codex_home, zsh_path)?;- let zdotdir = zdotdir.to_string_lossy().into_owned();- TestAppServer::builder()- .with_codex_home(codex_home)- .with_program(&app_server)- .with_env_overrides(&[("ZDOTDIR", Some(zdotdir.as_str()))])- .build_initialized_with_timeout(DEFAULT_READ_TIMEOUT)- .await-}--fn create_test_package_app_server(codex_home: &Path, zsh_path: &Path) -> Result<PathBuf> {- let package_dir = codex_home.join("test-package");- let bin_dir = package_dir.join("bin");- let package_zsh_path = packaged_zsh_path(codex_home);- let Some(zsh_bin_dir) = package_zsh_path.parent() else {- anyhow::bail!("packaged zsh path should have parent");- };- std::fs::create_dir_all(&bin_dir)?;- std::fs::create_dir_all(zsh_bin_dir)?;- std::fs::write(package_dir.join("codex-package.json"), "{}")?;-- let app_server = bin_dir.join("codex-app-server");- codex_utils_cargo_bin::copy_executable(- &codex_utils_cargo_bin::cargo_bin("codex-app-server")?,- &app_server,- )?;- codex_utils_cargo_bin::copy_executable(zsh_path, &package_zsh_path)?;- Ok(app_server)-}--fn packaged_zsh_path(codex_home: &Path) -> PathBuf {- codex_home- .join("test-package")- .join("codex-resources")- .join("zsh")- .join("bin")- .join("zsh")-}--fn command_packaged_zsh_path(codex_home: &Path) -> PathBuf {- let path = packaged_zsh_path(codex_home);- std::fs::canonicalize(&path).unwrap_or(path)-}--fn create_config_toml(- codex_home: &Path,- server_uri: &str,- approval_policy: &str,- feature_flags: &BTreeMap<Feature, bool>,-) -> std::io::Result<()> {- MockResponsesConfig::new(server_uri)- .with_approval_policy(approval_policy)- .disable_feature(Feature::RemoteModels)- .with_features(feature_flags)- .write(codex_home)-}--fn find_test_zsh_path() -> Result<Option<std::path::PathBuf>> {- let repo_root = codex_utils_cargo_bin::repo_root()?;- let dotslash_zsh = repo_root.join("codex-rs/app-server/tests/suite/zsh");- if !dotslash_zsh.is_file() {- eprintln!(- "skipping zsh fork test: shared zsh DotSlash file not found at {}",- dotslash_zsh.display()- );- return Ok(None);- }- match core_test_support::fetch_dotslash_file(&dotslash_zsh, /*dotslash_cache*/ None) {- Ok(path) => return Ok(Some(path)),- Err(error) => {- eprintln!("failed to fetch vendored zsh via dotslash: {error:#}");- }- }-- Ok(None)-}--fn supports_exec_wrapper_intercept(zsh_path: &Path) -> bool {- let status = std::process::Command::new(zsh_path)- .arg("-fc")- .arg("/usr/bin/true")- .env("EXEC_WRAPPER", "/usr/bin/false")- .status();- match status {- Ok(status) => !status.success(),- Err(_) => false,- }-}diff --git a/codex-rs/app-server/tests/suite/zsh b/codex-rs/app-server/tests/suite/zshdeleted file mode 100755index f796fa7201..0000000000--- a/codex-rs/app-server/tests/suite/zsh+++ /dev/null@@ -1,73 +0,0 @@-#!/usr/bin/env dotslash--// This is the patched zsh fork corresponding to-// `codex-rs/shell-escalation/patches/zsh-exec-wrapper.patch`.-// Fetching the prebuilt version via DotSlash makes it easier to write-// integration tests that exercise the zsh fork behavior in app-server tests.-//-// This checked-in fixture is still pinned to the latest released bundle that-// contains this binary. New releases publish standalone `codex-zsh-*.tar.gz`-// assets plus a generated `codex-zsh` DotSlash release asset, so this file can-// be retargeted when a newer fork build needs to be exercised in tests.-{- "name": "codex-zsh",- "platforms": {- // macOS 13 builds (and therefore x86_64) were dropped in- // https://github.com/openai/codex/pull/7295, so we only provide an- // Apple Silicon build for now.- "macos-aarch64": {- "size": 53771483,- "hash": "blake3",- "digest": "ff664f63f5e1fa62762c9aff0aafa66cf196faf9b157f98ec98f59c152fc7bd3",- "format": "tar.gz",- "path": "package/vendor/aarch64-apple-darwin/zsh/macos-15/zsh",- "providers": [- {- "url": "https://github.com/openai/codex/releases/download/rust-v0.104.0/codex-shell-tool-mcp-npm-0.104.0.tgz"- },- {- "type": "github-release",- "repo": "openai/codex",- "tag": "rust-v0.104.0",- "name": "codex-shell-tool-mcp-npm-0.104.0.tgz"- }- ]- },- "linux-x86_64": {- "size": 53771483,- "hash": "blake3",- "digest": "ff664f63f5e1fa62762c9aff0aafa66cf196faf9b157f98ec98f59c152fc7bd3",- "format": "tar.gz",- "path": "package/vendor/x86_64-unknown-linux-musl/zsh/ubuntu-24.04/zsh",- "providers": [- {- "url": "https://github.com/openai/codex/releases/download/rust-v0.104.0/codex-shell-tool-mcp-npm-0.104.0.tgz"- },- {- "type": "github-release",- "repo": "openai/codex",- "tag": "rust-v0.104.0",- "name": "codex-shell-tool-mcp-npm-0.104.0.tgz"- }- ]- },- "linux-aarch64": {- "size": 53771483,- "hash": "blake3",- "digest": "ff664f63f5e1fa62762c9aff0aafa66cf196faf9b157f98ec98f59c152fc7bd3",- "format": "tar.gz",- "path": "package/vendor/aarch64-unknown-linux-musl/zsh/ubuntu-24.04/zsh",- "providers": [- {- "url": "https://github.com/openai/codex/releases/download/rust-v0.104.0/codex-shell-tool-mcp-npm-0.104.0.tgz"- },- {- "type": "github-release",- "repo": "openai/codex",- "tag": "rust-v0.104.0",- "name": "codex-shell-tool-mcp-npm-0.104.0.tgz"- }- ]- },- }-}diff --git a/codex-rs/arg0/Cargo.toml b/codex-rs/arg0/Cargo.tomlindex 1f1bc3866e..fad5169ffa 100644--- a/codex-rs/arg0/Cargo.toml+++ b/codex-rs/arg0/Cargo.toml@@ -20,7 +20,6 @@ codex-exec-server = { workspace = true }codex-install-context = { workspace = true }codex-linux-sandbox = { workspace = true }codex-sandboxing = { workspace = true }-codex-shell-escalation = { workspace = true }codex-utils-absolute-path = { workspace = true }codex-utils-home-dir = { workspace = true }codex-utils-pty = { workspace = true }diff --git a/codex-rs/arg0/src/lib.rs b/codex-rs/arg0/src/lib.rsindex c346736719..33d2e65989 100644--- a/codex-rs/arg0/src/lib.rs+++ b/codex-rs/arg0/src/lib.rs@@ -20,8 +20,6 @@ use tempfile::TempDir;const APPLY_PATCH_ARG0: &str = "apply_patch";const MISSPELLED_APPLY_PATCH_ARG0: &str = "applypatch";-#[cfg(unix)]-const EXECVE_WRAPPER_ARG0: &str = "codex-execve-wrapper";const LOCK_FILENAME: &str = ".lock";#[derive(Clone, Debug, Default, Eq, PartialEq)]@@ -33,6 +31,7 @@ pub struct Arg0DispatchPaths {/// instead of the real Codex CLI.pub codex_self_exe: Option<PathBuf>,pub codex_linux_sandbox_exe: Option<PathBuf>,+ /// Always absent; retained for clients that still pass the retired wrapper path.pub main_execve_wrapper_exe: Option<PathBuf>,}@@ -68,32 +67,6 @@ pub fn arg0_dispatch() -> Option<Arg0PathEntryGuard> {.and_then(|s| s.to_str()).unwrap_or("");- #[cfg(unix)]- if exe_name == EXECVE_WRAPPER_ARG0 {- let mut args = std::env::args();- let _ = args.next();- let file = match args.next() {- Some(file) => file,- None => std::process::exit(1),- };- let argv = args.collect::<Vec<_>>();-- let runtime = match tokio::runtime::Builder::new_current_thread()- .enable_all()- .build()- {- Ok(runtime) => runtime,- Err(_) => std::process::exit(1),- };- let exit_code = runtime.block_on(- codex_shell_escalation::run_shell_escalation_execve_wrapper(file, argv),- );- match exit_code {- Ok(exit_code) => std::process::exit(exit_code),- Err(_) => std::process::exit(1),- }- }-if exe_name == CODEX_LINUX_SANDBOX_ARG0 {// Safety: [`run_main`] never returns.codex_linux_sandbox::run_main();@@ -257,15 +230,13 @@ whereFut: Future<Output = anyhow::Result<()>>,{let paths = Arg0DispatchPaths {+ main_execve_wrapper_exe: None,codex_self_exe: current_exe.clone(),codex_linux_sandbox_exe: if cfg!(target_os = "linux") {linux_sandbox_exe_path(path_entry_guard.as_ref(), current_exe)} else {None},- main_execve_wrapper_exe: path_entry_guard- .as_ref()- .and_then(|path_entry| path_entry.paths().main_execve_wrapper_exe.clone()),};let result = main_fn(paths).await;@@ -389,8 +360,6 @@ fn prepare_path_entry_for_codex_aliases(MISSPELLED_APPLY_PATCH_ARG0,#[cfg(target_os = "linux")]CODEX_LINUX_SANDBOX_ARG0,- #[cfg(unix)]- EXECVE_WRAPPER_ARG0,] {let exe = std::env::current_exe()?;@@ -418,6 +387,7 @@ fn prepare_path_entry_for_codex_aliases(let updated_path_env_var = path_env_with_entry(path, existing_path);let paths = Arg0DispatchPaths {+ main_execve_wrapper_exe: None,codex_self_exe: std::env::current_exe().ok(),codex_linux_sandbox_exe: {#[cfg(target_os = "linux")]@@ -429,16 +399,6 @@ fn prepare_path_entry_for_codex_aliases(None}},- main_execve_wrapper_exe: {- #[cfg(unix)]- {- Some(path.join(EXECVE_WRAPPER_ARG0))- }- #[cfg(not(unix))]- {- None- }- },};Ok((@@ -656,9 +616,9 @@ mod tests {temp_dir,lock_file,Arg0DispatchPaths {+ main_execve_wrapper_exe: None,codex_self_exe: Some(PathBuf::from("/usr/bin/codex")),codex_linux_sandbox_exe: Some(alias_path.clone()),- main_execve_wrapper_exe: None,},);@@ -737,20 +697,16 @@ mod tests {temp_dir,lock_file,Arg0DispatchPaths {+ main_execve_wrapper_exe: None,codex_self_exe: Some(PathBuf::from("/usr/bin/codex")),codex_linux_sandbox_exe: Some(alias_path.clone()),- main_execve_wrapper_exe: Some(alias_path),},);super::build_runtime()?.block_on(run_main_with_arg0_guard(/*path_entry_guard*/ Some(path_entry),Some(PathBuf::from("/usr/bin/codex")),- |paths| async move {- let alias_path = paths- .codex_linux_sandbox_exe- .or(paths.main_execve_wrapper_exe)- .expect("unix dispatch should create at least one alias path");+ |_paths| async move {ensure!(alias_path.exists(),"alias path disappeared before main future was polled: {}",diff --git a/codex-rs/cli/src/doctor.rs b/codex-rs/cli/src/doctor.rsindex b9f26e9d86..859fad9f69 100644--- a/codex-rs/cli/src/doctor.rs+++ b/codex-rs/cli/src/doctor.rs@@ -664,7 +664,6 @@ fn config_overrides_from_interactive(.flatten(),codex_self_exe: arg0_paths.codex_self_exe.clone(),codex_linux_sandbox_exe: arg0_paths.codex_linux_sandbox_exe.clone(),- main_execve_wrapper_exe: arg0_paths.main_execve_wrapper_exe.clone(),show_raw_agent_reasoning: interactive.oss.then_some(true),additional_writable_roots: interactive.add_dir.clone(),..Default::default()@@ -3229,7 +3228,7 @@ mod tests {let arg0_paths = Arg0DispatchPaths {codex_self_exe: Some(PathBuf::from("/bin/codex")),codex_linux_sandbox_exe: Some(PathBuf::from("/bin/codex-linux-sandbox")),- main_execve_wrapper_exe: Some(PathBuf::from("/bin/codex-execve-wrapper")),+ ..Default::default()};let overrides = config_overrides_from_interactive(&interactive, &arg0_paths);@@ -3249,10 +3248,6 @@ mod tests {overrides.codex_linux_sandbox_exe,arg0_paths.codex_linux_sandbox_exe);- assert_eq!(- overrides.main_execve_wrapper_exe,- arg0_paths.main_execve_wrapper_exe- );}#[test]diff --git a/codex-rs/cli/src/doctor/sandbox.rs b/codex-rs/cli/src/doctor/sandbox.rsindex 10a7d351f4..4e1d54bb19 100644--- a/codex-rs/cli/src/doctor/sandbox.rs+++ b/codex-rs/cli/src/doctor/sandbox.rs@@ -100,11 +100,6 @@ pub(super) fn sandbox_check(config: &Config, arg0_paths: &Arg0DispatchPaths) ->"codex-linux-sandbox helper",arg0_paths.codex_linux_sandbox_exe.as_deref(),);- push_path_detail(- &mut details,- "execve wrapper helper",- arg0_paths.main_execve_wrapper_exe.as_deref(),- );let mut status = CheckStatus::Ok;let mut summary = "sandbox configuration is readable".to_string();diff --git a/codex-rs/cli/src/main.rs b/codex-rs/cli/src/main.rsindex 8d062a2397..e90a13c32f 100644--- a/codex-rs/cli/src/main.rs+++ b/codex-rs/cli/src/main.rs@@ -2027,7 +2027,6 @@ async fn run_debug_prompt_input_command(cwd: shared.cwd,codex_self_exe: arg0_paths.codex_self_exe,codex_linux_sandbox_exe: arg0_paths.codex_linux_sandbox_exe,- main_execve_wrapper_exe: arg0_paths.main_execve_wrapper_exe,show_raw_agent_reasoning: shared.oss.then_some(true),ephemeral: Some(true),bypass_hook_trust: shared.bypass_hook_trust.then_some(true),diff --git a/codex-rs/core/Cargo.toml b/codex-rs/core/Cargo.tomlindex cfd7236881..a8ad7d678a 100644--- a/codex-rs/core/Cargo.toml+++ b/codex-rs/core/Cargo.toml@@ -137,9 +137,6 @@ openssl-sys = { workspace = true, features = ["vendored"] }[target.aarch64-unknown-linux-musl.dependencies]openssl-sys = { workspace = true, features = ["vendored"] }-[target.'cfg(unix)'.dependencies]-codex-shell-escalation = { workspace = true }-[dev-dependencies]assert_cmd = { workspace = true }assert_matches = { workspace = true }diff --git a/codex-rs/core/src/agent/role_tests.rs b/codex-rs/core/src/agent/role_tests.rsindex bcf8892aa6..b480f58580 100644--- a/codex-rs/core/src/agent/role_tests.rs+++ b/codex-rs/core/src/agent/role_tests.rs@@ -189,7 +189,6 @@ async fn apply_role_preserves_unspecified_keys() {)]).await;config.codex_linux_sandbox_exe = Some(PathBuf::from("/tmp/codex-linux-sandbox"));- config.main_execve_wrapper_exe = Some(PathBuf::from("/tmp/codex-execve-wrapper"));let role_path = write_role_config(&home,"instructions-only.toml",@@ -226,10 +225,6 @@ async fn apply_role_preserves_unspecified_keys() {config.codex_linux_sandbox_exe,Some(PathBuf::from("/tmp/codex-linux-sandbox")));- assert_eq!(- config.main_execve_wrapper_exe,- Some(PathBuf::from("/tmp/codex-execve-wrapper"))- );assert_eq!(config.base_instructions, base_instructions);assert_eq!(config.base_instructions_provenance, provenance);}diff --git a/codex-rs/core/src/config/config_tests.rs b/codex-rs/core/src/config/config_tests.rsindex 2ec201aff2..40268dd89c 100644--- a/codex-rs/core/src/config/config_tests.rs+++ b/codex-rs/core/src/config/config_tests.rs@@ -5611,7 +5611,6 @@ async fn rebuild_with_session_layers_refreshes_requirements() -> std::io::Resultthread_config.cwd.to_path_buf(),&refreshed_layer_stack,codex_home.abs(),- /*default_zsh_path*/ None,).await?;@@ -5727,7 +5726,6 @@ async fn rebuild_with_session_layers_refreshes_plugin_derived_mcp_config() -> anthread_config.cwd.to_path_buf(),&refreshed_layer_stack,codex_home.abs(),- /*default_zsh_path*/ None,).await?;let plugins_manager =@@ -6037,25 +6035,6 @@ async fn add_dir_override_extends_workspace_writable_roots() -> std::io::Result<Ok(())}-#[tokio::test]-async fn default_zsh_path_sets_runtime_zsh_path() -> std::io::Result<()> {- let codex_home = TempDir::new()?;- let default_zsh_path = codex_home.path().join("packaged-zsh");-- let config = Config::load_from_base_config_with_overrides(- ConfigToml::default(),- ConfigOverrides {- default_zsh_path: Some(default_zsh_path.abs()),- ..Default::default()- },- codex_home.abs(),- )- .await?;- assert_eq!(config.zsh_path, Some(default_zsh_path));-- Ok(())-}-#[tokio::test]async fn sqlite_home_defaults_to_codex_home_for_workspace_write() -> std::io::Result<()> {let codex_home = TempDir::new()?;@@ -11635,7 +11614,6 @@ async fn feature_requirements_can_still_disable_unified_exec() -> std::io::Resul[features]unified_exec = falseshell_tool = true-unified_exec_zsh_fork = falseuse_xaa = false"#,),@@ -11645,7 +11623,6 @@ use_xaa = falseassert!(!config.features.enabled(Feature::UnifiedExec));assert!(config.features.enabled(Feature::ShellTool));- assert!(!config.features.enabled(Feature::UnifiedExecZshFork));assert!(!config.features.enabled(Feature::UseXaa));assert!(!config@@ -11660,13 +11637,8 @@ use_xaa = false.features.enable(Feature::UnifiedExec).expect("managed feature mutations should normalize successfully");- config- .features- .enable(Feature::UnifiedExecZshFork)- .expect("managed feature updates should preserve administrator policy");assert!(!config.features.enabled(Feature::UnifiedExec));assert!(config.features.enabled(Feature::ShellTool));- assert!(!config.features.enabled(Feature::UnifiedExecZshFork));Ok(())}@@ -11830,6 +11802,8 @@ shell_tool = false#[test_case::test_case(Feature::Personality; "personality")]#[test_case::test_case(Feature::GuardianThreadContext; "guardian thread context")]+#[test_case::test_case(Feature::ShellZshFork; "shell zsh fork")]+#[test_case::test_case(Feature::UnifiedExecZshFork; "unified exec zsh fork")]fn retired_feature_requirements_do_not_pin_configured_values(feature: Feature,) -> std::io::Result<()> {@@ -11876,7 +11850,7 @@ fn retired_feature_requirements_do_not_pin_configured_values((Features::with_defaults().enabled(feature),false,- usize::from(feature == Feature::GuardianThreadContext),+ usize::from(feature != Feature::Personality),),);}diff --git a/codex-rs/core/src/config/managed_features.rs b/codex-rs/core/src/config/managed_features.rsindex 80c951c488..a6519b2a44 100644--- a/codex-rs/core/src/config/managed_features.rs+++ b/codex-rs/core/src/config/managed_features.rs@@ -243,6 +243,15 @@ fn parse_feature_requirements(if key == Feature::Personality.key() {continue;}+ if matches!(key.as_str(), "shell_zsh_fork" | "unified_exec_zsh_fork") {+ push_feature_requirement_warning(+ &mut startup_warnings,+ format!(+ "Ignoring removed `features` requirement `{key}` from {source}; the patched zsh backend has been removed."+ ),+ );+ continue;+ }if key == Feature::GuardianThreadContext.key() {push_feature_requirement_warning(&mut startup_warnings,diff --git a/codex-rs/core/src/config/mod.rs b/codex-rs/core/src/config/mod.rsindex 0537ee4adb..db88628e7a 100644--- a/codex-rs/core/src/config/mod.rs+++ b/codex-rs/core/src/config/mod.rs@@ -80,7 +80,6 @@ use codex_features::TokenBudgetConfigToml;use codex_git_utils::resolve_root_git_project_for_trust;use codex_http_client::HttpClientFactory;use codex_http_client::OutboundProxyPolicy;-use codex_install_context::InstallContext;use codex_login::AuthManagerConfig;use codex_login::AuthRouteConfig;use codex_mcp::DEFAULT_OPTIONAL_MCP_STARTUP_GRACE;@@ -155,7 +154,6 @@ use crate::config::permissions::BUILT_IN_READ_ONLY_PROFILE;use crate::config::permissions::BUILT_IN_WORKSPACE_PROFILE;use crate::config::permissions::apply_network_proxy_feature_config;use crate::config::permissions::default_builtin_permission_profile_name;-use crate::config::permissions::get_readable_roots_required_for_codex_runtime;use crate::config::permissions::network_proxy_config_for_profile_selection;use crate::config::permissions::validate_user_permission_profile_names;use crate::responses_metadata::validate_extra_metadata;@@ -1002,12 +1000,10 @@ pub struct Config {/// When this program is invoked, arg0 will be set to `codex-linux-sandbox`.pub codex_linux_sandbox_exe: Option<PathBuf>,- /// Path to the `codex-execve-wrapper` executable used for shell- /// escalation. This cannot be set in the config file: it must be set in- /// code via [`ConfigOverrides`].+ /// Ignored compatibility field for clients that still pass the retired wrapper path.pub main_execve_wrapper_exe: Option<PathBuf>,- /// Optional absolute path to patched zsh used by zsh-exec-bridge-backed shell execution.+ /// Ignored compatibility field for clients that still pass a patched zsh path.pub zsh_path: Option<PathBuf>,/// Value to use for `reasoning.effort` when making a request using the@@ -1933,7 +1929,6 @@ impl Config {cwd: PathBuf,refreshed_layers: &ConfigLayerStack,codex_home: AbsolutePathBuf,- default_zsh_path: Option<AbsolutePathBuf>,) -> std::io::Result<Self> {let config_layer_stack =Self::layer_stack_preserving_session(session_layers, refreshed_layers)?;@@ -1943,7 +1938,6 @@ impl Config {cfg,ConfigOverrides {cwd: Some(cwd),- default_zsh_path,..Default::default()},codex_home,@@ -2033,8 +2027,7 @@ impl Config {/// designed to use [AskForApproval::Never] exclusively.////// Further, [ConfigOverrides] contains some options that are not supported- /// in [ConfigToml], such as `cwd`, `codex_self_exe`, `codex_linux_sandbox_exe`, and- /// `main_execve_wrapper_exe`.+ /// in [ConfigToml], such as `cwd`, `codex_self_exe`, and `codex_linux_sandbox_exe`.pub async fn load_with_cli_overrides_and_harness_overrides(cli_overrides: Vec<(String, TomlValue)>,harness_overrides: ConfigOverrides,@@ -2667,8 +2660,8 @@ pub struct ConfigOverrides {pub service_tier: Option<Option<String>>,pub codex_self_exe: Option<PathBuf>,pub codex_linux_sandbox_exe: Option<PathBuf>,+ /// Ignored compatibility field for clients that still pass the retired wrapper path.pub main_execve_wrapper_exe: Option<PathBuf>,- pub default_zsh_path: Option<AbsolutePathBuf>,pub base_instructions: Option<String>,pub developer_instructions: Option<String>,/// Deprecated: `friendly` and `pragmatic` no longer select a style.@@ -3362,8 +3355,7 @@ impl Config {service_tier: service_tier_override,codex_self_exe,codex_linux_sandbox_exe,- main_execve_wrapper_exe,- default_zsh_path,+ main_execve_wrapper_exe: _,base_instructions,developer_instructions,personality,@@ -4111,10 +4103,6 @@ impl Config {).await?;let compact_prompt = compact_prompt.or(file_compact_prompt);- let zsh_path = default_zsh_path- .or_else(|| InstallContext::current().bundled_zsh_path())- .map(AbsolutePathBuf::into_path_buf);-let review_model = override_review_model.or(cfg.review_model);let check_for_update_on_startup = cfg.check_for_update_on_startup.unwrap_or(true);@@ -4208,11 +4196,11 @@ impl Config {&network_permission_profile,&shell_environment_policy.r#set,)?;- let mut helper_readable_roots = get_readable_roots_required_for_codex_runtime(- &codex_home,- zsh_path.as_ref(),- main_execve_wrapper_exe.as_ref(),- );+ let mut helper_readable_roots: Vec<_> = std::env::var_os("PATH")+ .as_deref()+ .and_then(|path| permissions::active_arg0_helper_dir(&codex_home, path))+ .into_iter()+ .collect();if features.enabled(Feature::MemoryTool) && memories_config.use_memories {helper_readable_roots.push(memories_root);}@@ -4442,8 +4430,8 @@ impl Config {file_opener: cfg.file_opener.unwrap_or(UriBasedFileOpener::VsCode),codex_self_exe,codex_linux_sandbox_exe,- main_execve_wrapper_exe,- zsh_path,+ main_execve_wrapper_exe: None,+ zsh_path: None,hide_agent_reasoning: cfg.hide_agent_reasoning.unwrap_or(false),show_raw_agent_reasoning: cfgdiff --git a/codex-rs/core/src/config/permissions.rs b/codex-rs/core/src/config/permissions.rsindex 9cef5b075a..78eaf3d217 100644--- a/codex-rs/core/src/config/permissions.rs+++ b/codex-rs/core/src/config/permissions.rs@@ -1,8 +1,8 @@use std::collections::BTreeMap;use std::collections::HashSet;+use std::ffi::OsStr;use std::io;use std::path::Path;-use std::path::PathBuf;use codex_config::ConfigPathContext;use codex_config::permissions_toml::FilesystemPermissionToml;@@ -48,6 +48,23 @@ pub(crate) const BUILT_IN_WORKSPACE_PROFILE: &str = BUILT_IN_PERMISSION_PROFILE_pub(crate) const BUILT_IN_DANGER_FULL_ACCESS_PROFILE: &str =BUILT_IN_PERMISSION_PROFILE_DANGER_FULL_ACCESS;+/// Keep the active apply_patch aliases readable without granting access to other+/// sessions or the rest of CODEX_HOME. Preserve the alias directory, not its target.+pub(super) fn active_arg0_helper_dir(+ codex_home: &Path,+ path_env: &OsStr,+) -> Option<AbsolutePathBuf> {+ let arg0_root = codex_home.join("tmp").join("arg0");+ std::env::split_paths(path_env)+ .find(|path| {+ path.parent() == Some(arg0_root.as_path())+ && path+ .file_name()+ .is_some_and(|name| name.to_string_lossy().starts_with("codex-arg0"))+ })+ .and_then(|path| AbsolutePathBuf::from_absolute_path(path).ok())+}+pub(crate) fn default_builtin_permission_profile_name(active_project: &ProjectConfig,windows_sandbox_level: WindowsSandboxLevel,@@ -508,37 +525,6 @@ pub(crate) fn reject_unknown_builtin_permission_profile(profile_name: &str) -> iOk(())}-/// Returns a list of paths that must be readable by shell tools in order-/// for Codex to function. These should always be added to the-/// `FileSystemSandboxPolicy` for a thread.-pub(crate) fn get_readable_roots_required_for_codex_runtime(- codex_home: &Path,- zsh_path: Option<&PathBuf>,- main_execve_wrapper_exe: Option<&PathBuf>,-) -> Vec<AbsolutePathBuf> {- let arg0_root = AbsolutePathBuf::from_absolute_path(codex_home.join("tmp").join("arg0")).ok();- let zsh_path = zsh_path.and_then(|path| AbsolutePathBuf::from_absolute_path(path).ok());- let execve_wrapper_root = main_execve_wrapper_exe.and_then(|path| {- let path = AbsolutePathBuf::from_absolute_path(path).ok()?;- if let Some(arg0_root) = arg0_root.as_ref()- && path.as_path().starts_with(arg0_root.as_path())- {- path.parent()- } else {- Some(path)- }- });-- let mut readable_roots = Vec::new();- if let Some(zsh_path) = zsh_path {- readable_roots.push(zsh_path);- }- if let Some(execve_wrapper_root) = execve_wrapper_root {- readable_roots.push(execve_wrapper_root);- }- readable_roots-}-fn compile_network_sandbox_policy(network: Option<&NetworkToml>,base_network_sandbox_policy: NetworkSandboxPolicy,diff --git a/codex-rs/core/src/config/permissions_tests.rs b/codex-rs/core/src/config/permissions_tests.rsindex 6b385ff25b..0e2468b8b1 100644--- a/codex-rs/core/src/config/permissions_tests.rs+++ b/codex-rs/core/src/config/permissions_tests.rs@@ -1,7 +1,4 @@use super::*;-use crate::config::Config;-use crate::config::ConfigOverrides;-use codex_config::config_toml::ConfigToml;use codex_config::permissions_toml::FilesystemPermissionToml;use codex_config::permissions_toml::FilesystemPermissionsToml;use codex_config::permissions_toml::NetworkDomainPermissionToml;@@ -17,12 +14,30 @@ use codex_protocol::permissions::FileSystemPath;use codex_protocol::permissions::FileSystemSandboxEntry;use codex_protocol::permissions::FileSystemSandboxPolicy;use codex_protocol::permissions::FileSystemSpecialPath;-use codex_utils_absolute_path::AbsolutePathBuf;use codex_utils_path_uri::PathConvention;use pretty_assertions::assert_eq;use std::collections::BTreeMap;use tempfile::TempDir;+#[test]+fn active_arg0_helper_dir_selects_only_the_first_session_alias_directory() -> anyhow::Result<()> {+ let home = TempDir::new()?;+ let arg0_root = home.path().join("tmp/arg0");+ let active = arg0_root.join("codex-arg0-active");+ let paths = std::env::join_paths([+ home.path().join("bin"),+ arg0_root.clone(),+ arg0_root.join("unrelated"),+ active.clone(),+ arg0_root.join("codex-arg0-parent"),+ ])?;+ assert_eq!(+ active_arg0_helper_dir(home.path(), &paths),+ Some(AbsolutePathBuf::from_absolute_path(active)?)+ );+ Ok(())+}+#[test]fn windows_verbatim_path_prefix_does_not_count_as_glob_syntax() {assert!(!contains_glob_chars_for_platform(@@ -35,74 +50,6 @@ fn windows_verbatim_path_prefix_does_not_count_as_glob_syntax() {));}-#[tokio::test]-async fn restricted_read_implicitly_allows_helper_executables() -> std::io::Result<()> {- let temp_dir = TempDir::new()?;- let cwd = temp_dir.path().join("workspace");- let codex_home = temp_dir.path().join(".codex");- let zsh_path = temp_dir.path().join("runtime").join("zsh");- let arg0_root = codex_home.join("tmp").join("arg0");- let allowed_arg0_dir = arg0_root.join("codex-arg0-session");- let sibling_arg0_dir = arg0_root.join("codex-arg0-other-session");- let execve_wrapper = allowed_arg0_dir.join("codex-execve-wrapper");- std::fs::create_dir_all(&cwd)?;- std::fs::create_dir_all(zsh_path.parent().expect("zsh path should have parent"))?;- std::fs::create_dir_all(&allowed_arg0_dir)?;- std::fs::create_dir_all(&sibling_arg0_dir)?;- std::fs::write(&zsh_path, "")?;- std::fs::write(&execve_wrapper, "")?;-- let config = Config::load_from_base_config_with_overrides(- ConfigToml {- default_permissions: Some("workspace".to_string()),- permissions: Some(PermissionsToml {- entries: BTreeMap::from([(- "workspace".to_string(),- PermissionProfileToml {- description: None,- extends: None,- workspace_roots: None,- filesystem: Some(FilesystemPermissionsToml {- glob_scan_max_depth: None,- entries: BTreeMap::new(),- }),- network: None,- },- )]),- }),- ..Default::default()- },- ConfigOverrides {- cwd: Some(cwd.clone()),- default_zsh_path: Some(AbsolutePathBuf::try_from(zsh_path.clone())?),- main_execve_wrapper_exe: Some(execve_wrapper),- ..Default::default()- },- AbsolutePathBuf::from_absolute_path(&codex_home)?,- )- .await?;-- let expected_zsh = AbsolutePathBuf::try_from(zsh_path)?;- let expected_allowed_arg0_dir = AbsolutePathBuf::try_from(allowed_arg0_dir)?;- let expected_sibling_arg0_dir = AbsolutePathBuf::try_from(sibling_arg0_dir)?;- let policy = config.permissions.file_system_sandbox_policy();-- assert!(- policy.can_read_local_path_with_cwd(expected_zsh.as_path(), &cwd),- "expected zsh helper path to be readable, policy: {policy:?}"- );- assert!(- policy.can_read_local_path_with_cwd(expected_allowed_arg0_dir.as_path(), &cwd),- "expected active arg0 helper dir to be readable, policy: {policy:?}"- );- assert!(- !policy.can_read_local_path_with_cwd(expected_sibling_arg0_dir.as_path(), &cwd),- "expected sibling arg0 helper dir to remain unreadable, policy: {policy:?}"- );-- Ok(())-}-#[test]fn network_toml_ignores_legacy_network_list_keys() {let parsed = toml::from_str::<NetworkToml>(diff --git a/codex-rs/core/src/exec_policy.rs b/codex-rs/core/src/exec_policy.rsindex 21e414ed01..79d564e338 100644--- a/codex-rs/core/src/exec_policy.rs+++ b/codex-rs/core/src/exec_policy.rs@@ -755,8 +755,8 @@ fn dangerous_command_match_for_heuristics(}/// If a command is not matched by any execpolicy rule, derive a [`Decision`].-#[cfg(any(test, unix))]-pub(crate) fn render_decision_for_unmatched_command(+#[cfg(test)]+fn render_decision_for_unmatched_command(command: &[String],context: UnmatchedCommandContext<'_>,) -> Decision {diff --git a/codex-rs/core/src/exec_policy/executable_identity.rs b/codex-rs/core/src/exec_policy/executable_identity.rsindex 47363da0e0..c85fa184bb 100644--- a/codex-rs/core/src/exec_policy/executable_identity.rs+++ b/codex-rs/core/src/exec_policy/executable_identity.rs@@ -8,7 +8,6 @@ use crate::tools::sandboxing::ExecApprovalRequirement;use codex_shell_command::is_dangerous_command::DangerousCommandPlatform;use codex_shell_command::powershell::extract_powershell_command;use codex_shell_command::powershell::parse_powershell_script_into_plain_commands;-use codex_tools::UnifiedExecShellMode;use std::path::Path;impl ExecPolicyManager {@@ -16,11 +15,10 @@ impl ExecPolicyManager {&self,mut request: ExecApprovalRequest<'_>,configured_shell: &Shell,- shell_mode: &UnifiedExecShellMode,command_platform: DangerousCommandPlatform,) -> ExecApprovalRequirement {let command = request.command;- let executable = shell_approval_command(command, configured_shell, shell_mode);+ let executable = shell_approval_command(command, configured_shell);if executable.len() == command.len() {return self.create_exec_approval_requirement_for_command_platform(request, command_platform)@@ -53,11 +51,7 @@ impl ExecPolicyManager {}}-fn shell_approval_command<'a>(- command: &'a [String],- configured_shell: &Shell,- shell_mode: &UnifiedExecShellMode,-) -> &'a [String] {+fn shell_approval_command<'a>(command: &'a [String], configured_shell: &Shell) -> &'a [String] {let Some(executable) = command.first() else {return command;};@@ -90,10 +84,7 @@ fn shell_approval_command<'a>(#[cfg(not(windows))]let is_configured_shell = executable_path == configured_shell.shell_path.as_path();- if is_configured_shell- || is_system_shell- || matches!(shell_mode, UnifiedExecShellMode::ZshFork(_))- {+ if is_configured_shell || is_system_shell {command} else {// An unfamiliar executable can ignore its arguments, so evaluate thediff --git a/codex-rs/core/src/exec_policy/executable_identity_tests.rs b/codex-rs/core/src/exec_policy/executable_identity_tests.rsindex 9f90cd629b..57be815416 100644--- a/codex-rs/core/src/exec_policy/executable_identity_tests.rs+++ b/codex-rs/core/src/exec_policy/executable_identity_tests.rs@@ -1,7 +1,6 @@use super::shell_approval_command;use crate::shell::Shell;use crate::shell::ShellType;-use codex_tools::UnifiedExecShellMode;use pretty_assertions::assert_eq;use std::path::PathBuf;@@ -37,10 +36,7 @@ fn parent_directory_traversal_is_not_a_trusted_system_shell() {"ls".to_string(),];- assert_eq!(- shell_approval_command(&command, &shell, &UnifiedExecShellMode::Direct),- &command[..1],- );+ assert_eq!(shell_approval_command(&command, &shell), &command[..1],);}#[cfg(windows)]@@ -65,7 +61,7 @@ fn windows_shell_identity_is_case_insensitive() {let command = vec![executable, "-Command".to_string(), "echo safe".to_string()];assert_eq!(- shell_approval_command(&command, &configured_shell, &UnifiedExecShellMode::Direct),+ shell_approval_command(&command, &configured_shell),command.as_slice(),);}diff --git a/codex-rs/core/src/guardian/approval_request.rs b/codex-rs/core/src/guardian/approval_request.rsindex ee6fc74330..63893f6a30 100644--- a/codex-rs/core/src/guardian/approval_request.rs+++ b/codex-rs/core/src/guardian/approval_request.rs@@ -1,14 +1,9 @@-#[cfg(unix)]-use std::path::Path;-use codex_analytics::GuardianReviewedAction;use codex_protocol::approvals::GuardianAssessmentAction;use codex_protocol::approvals::GuardianCommandSource;use codex_protocol::approvals::NetworkApprovalProtocol;use codex_protocol::models::AdditionalPermissionProfile;use codex_protocol::request_permissions::RequestPermissionProfile;-#[cfg(unix)]-use codex_utils_absolute_path::AbsolutePathBuf;use codex_utils_path_uri::LegacyAppPathString;use codex_utils_path_uri::PathUri;use serde::Serialize;@@ -39,16 +34,6 @@ pub(crate) enum GuardianApprovalRequest {sandbox_permissions: crate::sandboxing::SandboxPermissions,additional_permissions: Option<AdditionalPermissionProfile>,},- #[cfg(unix)]- Execve {- id: String,- environment_id: String,- source: GuardianCommandSource,- program: String,- argv: Vec<String>,- cwd: AbsolutePathBuf,- additional_permissions: Option<AdditionalPermissionProfile>,- },ApplyPatch {id: String,environment_id: String,@@ -97,8 +82,6 @@ impl GuardianApprovalRequest {| Self::ApplyPatch { environment_id, .. }| Self::RequestPermissions { environment_id, .. }| Self::NetworkAccess { environment_id, .. } => Some(environment_id),- #[cfg(unix)]- Self::Execve { environment_id, .. } => Some(environment_id),Self::McpToolCall { .. } => None,}}@@ -164,17 +147,6 @@ struct WriteStdinApprovalAction<'a> {tty: bool,}-#[cfg(unix)]-#[derive(Serialize)]-struct ExecveApprovalAction<'a> {- tool: &'a str,- program: &'a str,- argv: &'a [String],- cwd: &'a Path,- #[serde(skip_serializing_if = "Option::is_none")]- additional_permissions: Option<&'a AdditionalPermissionProfile>,-}-#[derive(Serialize)]struct McpToolCallApprovalAction<'a> {tool: &'static str,@@ -255,14 +227,6 @@ fn command_assessment_action(}}-#[cfg(unix)]-fn guardian_command_source_tool_name(source: GuardianCommandSource) -> &'static str {- match source {- GuardianCommandSource::Shell => "shell",- GuardianCommandSource::UnifiedExec => "exec_command",- }-}-pub(crate) fn guardian_approval_request_to_json(action: &GuardianApprovalRequest,) -> serde_json::Result<Value> {@@ -303,22 +267,6 @@ pub(crate) fn guardian_approval_request_to_json(additional_permissions: additional_permissions.as_ref(),tty: *tty,}),- #[cfg(unix)]- GuardianApprovalRequest::Execve {- id: _,- environment_id: _,- source,- program,- argv,- cwd,- additional_permissions,- } => serialize_guardian_action(ExecveApprovalAction {- tool: guardian_command_source_tool_name(*source),- program,- argv,- cwd,- additional_permissions: additional_permissions.as_ref(),- }),GuardianApprovalRequest::ApplyPatch {id: _,environment_id: _,@@ -419,19 +367,6 @@ pub(crate) fn guardian_assessment_action(stdin: input.clone(),cwd: cwd.clone(),},- #[cfg(unix)]- GuardianApprovalRequest::Execve {- source,- program,- argv,- cwd,- ..- } => GuardianAssessmentAction::Execve {- source: *source,- program: program.clone(),- argv: argv.clone(),- cwd: cwd.clone(),- },GuardianApprovalRequest::ApplyPatch { cwd, files, .. } => {GuardianAssessmentAction::ApplyPatch {cwd: cwd.clone().into(),@@ -495,15 +430,6 @@ pub(crate) fn guardian_reviewed_action(GuardianApprovalRequest::WriteStdin { tty, .. } => {GuardianReviewedAction::WriteStdin { tty: *tty }}- #[cfg(unix)]- GuardianApprovalRequest::Execve {- source,- additional_permissions,- ..- } => GuardianReviewedAction::Execve {- source: *source,- additional_permissions: additional_permissions.as_ref().map(Into::into),- },GuardianApprovalRequest::ApplyPatch { .. } => GuardianReviewedAction::ApplyPatch {},GuardianApprovalRequest::NetworkAccess { protocol, port, .. } => {GuardianReviewedAction::NetworkAccess {@@ -539,8 +465,6 @@ pub(crate) fn guardian_request_target_item_id(request: &GuardianApprovalRequest)| GuardianApprovalRequest::McpToolCall { id, .. }| GuardianApprovalRequest::RequestPermissions { id, .. } => Some(id),GuardianApprovalRequest::NetworkAccess { .. } => None,- #[cfg(unix)]- GuardianApprovalRequest::Execve { id, .. } => Some(id),}}@@ -555,8 +479,6 @@ pub(crate) fn guardian_request_turn_id<'a>(| GuardianApprovalRequest::WriteStdin { .. }| GuardianApprovalRequest::ApplyPatch { .. }| GuardianApprovalRequest::McpToolCall { .. } => default_turn_id,- #[cfg(unix)]- GuardianApprovalRequest::Execve { .. } => default_turn_id,}}diff --git a/codex-rs/core/src/guardian/coverage.rs b/codex-rs/core/src/guardian/coverage.rsindex f505bcb198..d0b2d12434 100644--- a/codex-rs/core/src/guardian/coverage.rs+++ b/codex-rs/core/src/guardian/coverage.rs@@ -8,8 +8,6 @@ impl GuardianApprovalRequest {pub(crate) fn guardian_scope(&self) -> GuardianScope {match self {Self::ExecCommand { .. } | Self::WriteStdin { .. } => GuardianScope::Shell,- #[cfg(unix)]- Self::Execve { .. } => GuardianScope::Shell,Self::ApplyPatch { .. } => GuardianScope::FileChanges,Self::McpToolCall { server, .. } => GuardianScope::for_mcp_server(server),Self::NetworkAccess { .. } => GuardianScope::Network,@@ -22,8 +20,6 @@ impl ApprovalAction {pub(crate) fn guardian_scope(&self) -> GuardianScope {match self {Self::ExecCommand { .. } | Self::WriteStdin { .. } => GuardianScope::Shell,- #[cfg(unix)]- Self::Execve { .. } => GuardianScope::Shell,Self::ApplyPatch { .. } => GuardianScope::FileChanges,Self::McpToolCall {server,diff --git a/codex-rs/core/src/guardian/prompt.rs b/codex-rs/core/src/guardian/prompt.rsindex fd432462d8..212a66cb21 100644--- a/codex-rs/core/src/guardian/prompt.rs+++ b/codex-rs/core/src/guardian/prompt.rs@@ -147,8 +147,6 @@ pub(crate) async fn build_guardian_prompt_items_with_parent_turn(has_trigger: trigger.is_some(),},GuardianApprovalRequest::WriteStdin { .. } => PlannedActionKind::TerminalInput,- #[cfg(unix)]- GuardianApprovalRequest::Execve { .. } => PlannedActionKind::Command,GuardianApprovalRequest::ExecCommand { .. }| GuardianApprovalRequest::ApplyPatch { .. }| GuardianApprovalRequest::McpToolCall { .. }diff --git a/codex-rs/core/src/guardian/review.rs b/codex-rs/core/src/guardian/review.rsindex e86bd8c662..355360d160 100644--- a/codex-rs/core/src/guardian/review.rs+++ b/codex-rs/core/src/guardian/review.rs@@ -76,19 +76,6 @@ async fn plugin_attribution_for_guardian_request(.and_then(|cwd| turn.plugin_attribution_for_command(command, &cwd))}}- #[cfg(unix)]- GuardianApprovalRequest::Execve {- program, argv, cwd, ..- } => {- let command = if argv.is_empty() {- vec![program.clone()]- } else {- std::iter::once(program.clone())- .chain(argv.iter().skip(1).cloned())- .collect()- };- turn.plugin_attribution_for_command(&command, cwd)- }_ => None,}}diff --git a/codex-rs/core/src/guardian/review_session.rs b/codex-rs/core/src/guardian/review_session.rsindex 836983bc75..80763c9db0 100644--- a/codex-rs/core/src/guardian/review_session.rs+++ b/codex-rs/core/src/guardian/review_session.rs@@ -214,8 +214,6 @@ pub struct GuardianReviewSessionReuseKey {cwd: PathUri,mcp_servers: Constrained<HashMap<String, McpServerConfig>>,codex_linux_sandbox_exe: Option<PathBuf>,- main_execve_wrapper_exe: Option<PathBuf>,- zsh_path: Option<PathBuf>,features: ManagedFeatures,environment_ids: Vec<String>,}@@ -259,8 +257,6 @@ impl GuardianReviewSessionReuseKey {cwd: PathUri::from_abs_path(&spawn_config.cwd),mcp_servers: spawn_config.mcp_servers.clone(),codex_linux_sandbox_exe: spawn_config.codex_linux_sandbox_exe.clone(),- main_execve_wrapper_exe: spawn_config.main_execve_wrapper_exe.clone(),- zsh_path: spawn_config.zsh_path.clone(),features: spawn_config.features.clone(),environment_ids: Vec::new(),}diff --git a/codex-rs/core/src/guardian/runtime.rs b/codex-rs/core/src/guardian/runtime.rsindex 7a494d7b74..9cb154233e 100644--- a/codex-rs/core/src/guardian/runtime.rs+++ b/codex-rs/core/src/guardian/runtime.rs@@ -28,9 +28,6 @@ impl From<GuardianApprovalRequest> for ReviewAction {let tool_call_id = match &request {// Stdin's display target is the launch; freshness belongs to this write.GuardianApprovalRequest::WriteStdin { approval_id, .. } => Some(approval_id.clone()),- // Intercepts retain the launch ID, not the current triggering call.- #[cfg(unix)]- GuardianApprovalRequest::Execve { .. } => None,GuardianApprovalRequest::ExecCommand { .. }| GuardianApprovalRequest::ApplyPatch { .. }| GuardianApprovalRequest::NetworkAccess { .. }diff --git a/codex-rs/core/src/guardian/tests.rs b/codex-rs/core/src/guardian/tests.rsindex 14b8a49c25..3644e42cde 100644--- a/codex-rs/core/src/guardian/tests.rs+++ b/codex-rs/core/src/guardian/tests.rs@@ -648,16 +648,6 @@ async fn approval_permissions_use_the_owning_environment() -> anyhow::Result<()>sandbox_permissions: SandboxPermissions::UseDefault,additional_permissions: None,},- #[cfg(unix)]- GuardianApprovalRequest::Execve {- id: "shell".to_string(),- environment_id: "secondary".to_string(),- source: codex_protocol::approvals::GuardianCommandSource::UnifiedExec,- program: "cat".to_string(),- argv: Vec::new(),- cwd,- additional_permissions: None,- },];let mut missing_context = context.clone();missing_context.environments.environments.truncate(1);diff --git a/codex-rs/core/src/session/mod.rs b/codex-rs/core/src/session/mod.rsindex e4face0152..4714566430 100644--- a/codex-rs/core/src/session/mod.rs+++ b/codex-rs/core/src/session/mod.rs@@ -401,7 +401,6 @@ use codex_protocol::turn_input::TurnStartOptions;use codex_protocol::user_input::UserInput;use codex_skills_extension::HostSkillsService;use codex_tools::ToolName;-use codex_tools::UnifiedExecShellMode;use codex_utils_absolute_path::AbsolutePathBuf;#[cfg(test)]use codex_utils_stream_parser::ProposedPlanSegment;diff --git a/codex-rs/core/src/session/review.rs b/codex-rs/core/src/session/review.rsindex 44ec95ff60..e93643f1d5 100644--- a/codex-rs/core/src/session/review.rs+++ b/codex-rs/core/src/session/review.rs@@ -32,12 +32,6 @@ pub(super) async fn spawn_review_thread(let _ = review_features.disable(Feature::WebSearchCached);let _ = review_features.disable(Feature::Goals);let review_web_search_mode = WebSearchMode::Disabled;- let unified_exec_shell_mode = UnifiedExecShellMode::for_session(- review_features.get(),- crate::tools::tool_user_shell_type(sess.services.user_shell.as_ref()),- sess.services.shell_zsh_path.as_ref(),- sess.services.main_execve_wrapper_exe.as_ref(),- );let review_prompt = resolved.prompt.clone();let model_info = review_model_info.clone();@@ -142,7 +136,6 @@ pub(super) async fn spawn_review_thread(per_turn_config,step_settings,available_models,- unified_exec_shell_mode,turn_metadata_state,);diff --git a/codex-rs/core/src/session/session.rs b/codex-rs/core/src/session/session.rsindex 6210785bf9..08743217ed 100644--- a/codex-rs/core/src/session/session.rs+++ b/codex-rs/core/src/session/session.rs@@ -1238,9 +1238,17 @@ impl Session {session_source: session_configuration.session_source.clone(),cwd: session_configuration.cwd().to_path_buf(),rollout_path: rollout_path.clone(),- model: session_configuration.step_settings.collaboration_mode.model().to_string(),+ model: session_configuration+ .step_settings+ .collaboration_mode+ .model()+ .to_string(),provider_name: config.model_provider_id.clone(),- approval_policy: session_configuration.step_settings.approval_policy.value().to_string(),+ approval_policy: session_configuration+ .step_settings+ .approval_policy+ .value()+ .to_string(),sandbox_policy: format!("{:?}",session_configuration.sandbox_policy(environment_selections)@@ -1280,7 +1288,9 @@ impl Session {let effective_config = config.config_layer_stack.effective_config();let config_path = config.codex_home.join(CONFIG_TOML_FILE);if let Some(event) = unstable_features_warning_event(- effective_config.get("features").and_then(TomlValue::as_table),+ effective_config+ .get("features")+ .and_then(TomlValue::as_table),config.suppress_unstable_features_warning,&config.features,&config_path.display().to_string(),@@ -1295,7 +1305,11 @@ impl Session {let account_email = telemetry_auth.and_then(CodexAuth::get_account_email);let originator = session_configuration.originator.clone();let terminal_type = user_agent();- let session_model = session_configuration.step_settings.collaboration_mode.model().to_string();+ let session_model = session_configuration+ .step_settings+ .collaboration_mode+ .model()+ .to_string();let auth_env_telemetry = collect_auth_env_telemetry(session_configuration.provider.info(),auth_manager.codex_api_key_env_enabled(),@@ -1333,11 +1347,15 @@ impl Session {slug: Some(session_model),};crate::config::emit_session_start_metrics(config.as_ref(), &session_telemetry);- let is_worktree = session_configuration.cwd().canonicalize().ok().and_then(|cwd| {- codex_git_utils::repository_identity(&cwd).and_then(|_| {- get_git_repo_root(&cwd).map(|root| root.join(".git").is_file())- })- });+ let is_worktree = session_configuration+ .cwd()+ .canonicalize()+ .ok()+ .and_then(|cwd| {+ codex_git_utils::repository_identity(&cwd).and_then(|_| {+ get_git_repo_root(&cwd).map(|root| root.join(".git").is_file())+ })+ });let is_worktree_tag = match is_worktree {Some(true) => "true",Some(false) => "false",@@ -1355,16 +1373,16 @@ impl Session {);let mcp_server_names =- codex_mcp::effective_mcp_servers(- &mcp_projection.config,- auth.as_ref(),- )+ codex_mcp::effective_mcp_servers(&mcp_projection.config, auth.as_ref()).into_iter().filter_map(|(name, server)| server.enabled().then_some(name)).collect::<Vec<_>>();session_telemetry.conversation_starts(config.model_provider.name.as_str(),- session_configuration.step_settings.collaboration_mode.reasoning_effort(),+ session_configuration+ .step_settings+ .collaboration_mode+ .reasoning_effort(),config.model_reasoning_summary.unwrap_or(ReasoningSummaryConfig::Auto),@@ -1377,33 +1395,10 @@ impl Session {mcp_server_names.iter().map(String::as_str).collect(),);- let use_zsh_fork_shell = config.features.enabled(Feature::ShellZshFork);- let default_shell = if let Some(user_shell_override) =- session_configuration.user_shell_override.clone()- {- user_shell_override- } else if use_zsh_fork_shell {- let zsh_path = config.zsh_path.as_ref().ok_or_else(|| {- anyhow::anyhow!(- "zsh fork feature enabled, but no packaged zsh fork is available for this install"- )- })?;- if zsh_path.is_file() {- shell::Shell {- shell_type: shell::ShellType::Zsh,- shell_path: zsh_path.clone(),- }- } else {- shell::get_shell(shell::ShellType::Zsh).ok_or_else(|| {- anyhow::anyhow!(- "zsh fork feature enabled, but packaged zsh fork `{}` is not usable",- zsh_path.display()- )- })?- }- } else {- shell::default_user_shell()- };+ let default_shell = session_configuration+ .user_shell_override+ .clone()+ .unwrap_or_else(shell::default_user_shell);let credential_broker_available = config.features.enabled(Feature::NetworkProxy)&& config.config_layer_stack@@ -1426,16 +1421,7 @@ impl Session {.is_some_and(crate::config::NetworkProxySpec::credential_broker_enabled);let prefer_executor_shell_snapshots = config.features.enabled(Feature::ShellSnapshotV2)&& config.features.enabled(Feature::ShellTool)- && config.features.enabled(Feature::UnifiedExec)- && matches!(- codex_tools::UnifiedExecShellMode::for_session(- config.features.get(),- crate::tools::tool_user_shell_type(&default_shell),- config.zsh_path.as_ref(),- config.main_execve_wrapper_exe.as_ref(),- ),- codex_tools::UnifiedExecShellMode::Direct- );+ && config.features.enabled(Feature::UnifiedExec);let use_executor_shell_snapshots =prefer_executor_shell_snapshots && !credential_broker_active;let shell_snapshot = if config.features.enabled(Feature::ShellSnapshot)@@ -1508,12 +1494,12 @@ impl Session {let (agents_md_result, instruction_warnings) = instruction_refresh;// TODO(anp): Present AGENTS.md discovery errors more clearly to the user.agents_md_result?;- post_session_configured_events.extend(- instruction_warnings.into_iter().map(|message| Event {+ post_session_configured_events.extend(instruction_warnings.into_iter().map(+ |message| Event {id: INITIAL_SUBMIT_ID.to_owned(),msg: EventMsg::Warning(WarningEvent { message }),- }),- );+ },+ ));for err in &plugin_skill_errors {error!("failed to load skill {}: {}",@@ -1541,7 +1527,8 @@ impl Session {.requirements_toml().network.is_some();- let managed_network_requirements_enabled = config.managed_network_requirements_enabled();+ let managed_network_requirements_enabled =+ config.managed_network_requirements_enabled();let network_approval = Arc::new(NetworkApprovalService::default());// The managed proxy can call back into core for allowlist-miss decisions.let network_policy_decider_session = if managed_network_requirements_configured {@@ -1567,35 +1554,34 @@ impl Session {Arc::clone(network_policy_decider_session),)});- let (network_proxy, session_network_proxy) =- if let Some(spec) = config- .permissions- .network- .as_ref()- .filter(|spec| spec.enabled())- {- let current_exec_policy = exec_policy.current();- let (network_proxy, session_network_proxy) = Self::start_managed_network_proxy(- spec,- current_exec_policy.as_ref(),- config.permissions.permission_profile(),- config.effective_local_windows_sandbox_type(),- network_policy_decider.as_ref().map(Arc::clone),- blocked_request_observer.as_ref().map(Arc::clone),- managed_network_requirements_configured,- network_proxy_audit_metadata.clone(),- )- .instrument(info_span!(- "session_init.network_proxy",- otel.name = "session_init.network_proxy",- session_init.managed_network_requirements_enabled =- managed_network_requirements_enabled,- ))- .await?;- (Some(network_proxy), Some(session_network_proxy))- } else {- (None, None)- };+ let (network_proxy, session_network_proxy) = if let Some(spec) = config+ .permissions+ .network+ .as_ref()+ .filter(|spec| spec.enabled())+ {+ let current_exec_policy = exec_policy.current();+ let (network_proxy, session_network_proxy) = Self::start_managed_network_proxy(+ spec,+ current_exec_policy.as_ref(),+ config.permissions.permission_profile(),+ config.effective_local_windows_sandbox_type(),+ network_policy_decider.as_ref().map(Arc::clone),+ blocked_request_observer.as_ref().map(Arc::clone),+ managed_network_requirements_configured,+ network_proxy_audit_metadata.clone(),+ )+ .instrument(info_span!(+ "session_init.network_proxy",+ otel.name = "session_init.network_proxy",+ session_init.managed_network_requirements_enabled =+ managed_network_requirements_enabled,+ ))+ .await?;+ (Some(network_proxy), Some(session_network_proxy))+ } else {+ (None, None)+ };if let Some(network_proxy) = network_proxy.as_ref()&& config.permissions@@ -1684,32 +1670,34 @@ impl Session {let mcp_resource_client = Arc::new(McpResourceClient::new(Arc::clone(&mcp_runtime)));let extension_metrics =extension_metrics::from_session_telemetry(session_telemetry.clone());- let workspace_routing = thread_extension_data- .get_or_init(|| config.workspace_routing_context());+ let workspace_routing =+ thread_extension_data.get_or_init(|| config.workspace_routing_context());for contributor in extensions.thread_lifecycle_contributors() {- contributor.on_thread_start(codex_extension_api::ThreadStartInput {- config: config.as_ref(),- session_source: &session_configuration.session_source,- persistent_thread_state_available: state_db_ctx.is_some(),- environments: environment_selections,- mcp_resource_client: Some(Arc::clone(&mcp_resource_client)),- extension_metrics: Some(Arc::clone(&extension_metrics)),- session_store: &session_extension_data,- thread_store: &thread_extension_data,- }).await;+ contributor+ .on_thread_start(codex_extension_api::ThreadStartInput {+ config: config.as_ref(),+ session_source: &session_configuration.session_source,+ persistent_thread_state_available: state_db_ctx.is_some(),+ environments: environment_selections,+ mcp_resource_client: Some(Arc::clone(&mcp_resource_client)),+ extension_metrics: Some(Arc::clone(&extension_metrics)),+ session_store: &session_extension_data,+ thread_store: &thread_extension_data,+ })+ .await;}- let executed_tool_calls = crate::state::ExecutedToolCalls::new(- &config.features,- &initial_history,- );- let codex_responses_headers = thread_extension_data.get::<crate::CodexResponsesHeaders>();+ let executed_tool_calls =+ crate::state::ExecutedToolCalls::new(&config.features, &initial_history);+ let codex_responses_headers =+ thread_extension_data.get::<crate::CodexResponsesHeaders>();// Ephemeral title requests use request-level effort even when managed settings// enable overrides. The client-supplied tag selects cache behavior, not permissions.- let title_request = config.ephemeral && matches!(- session_configuration.thread_source.as_ref(),- Some(ThreadSource::Feature(feature)) if feature == "thread_title"- );+ let title_request = config.ephemeral+ && matches!(+ session_configuration.thread_source.as_ref(),+ Some(ThreadSource::Feature(feature)) if feature == "thread_title"+ );let reasoning_effort_override_enabled =config.features.enabled(Feature::ReasoningEffortOverride) && !title_request;let services = SessionServices {@@ -1721,8 +1709,6 @@ impl Session {config.background_terminal_max_timeout,),elicitations: crate::elicitation::ElicitationService::new(),- shell_zsh_path: config.zsh_path.clone(),- main_execve_wrapper_exe: config.main_execve_wrapper_exe.clone(),analytics_events_client,hooks: arc_swap::ArcSwap::from_pointee(hooks),rollout_thread_trace,@@ -1781,7 +1767,8 @@ impl Session {config.features.enabled(Feature::EnableRequestCompression),config.features.enabled(Feature::RuntimeMetrics),Self::build_model_client_beta_features_header(config.as_ref()),- /*concurrent_reasoning_summaries_enabled*/ config+ /*concurrent_reasoning_summaries_enabled*/+ config.features.enabled(Feature::ConcurrentReasoningSummaries),attestation_provider,@@ -1831,18 +1818,22 @@ impl Session {multi_agent_version,mcp_refresh: McpRefresh::new(),mcp_tool_approval_metadata: Default::default(),- mcp_elicitation_reviewer_handle: OnceLock::new(),+ mcp_elicitation_reviewer_handle: OnceLock::new(),mcp_elicitation_lifecycle_handle: OnceLock::new(),mcp_prewarm_tx,mcp_prewarm_shutdown: CancellationToken::new(),mcp_prewarm_task: std::sync::Mutex::new(None),conversation: Arc::new(RealtimeConversationManager::new()),- realtime_history: (session_configuration.history_mode == ThreadHistoryMode::Paginated+ realtime_history: (session_configuration.history_mode+ == ThreadHistoryMode::Paginated&& services.live_thread.is_some()).then(|| Mutex::new(Default::default())),active_turn: Mutex::new(None),async_hook_results,- input_queue: InputQueue::with_controller(thread_id, Arc::clone(&services.agent_control)),+ input_queue: InputQueue::with_controller(+ thread_id,+ Arc::clone(&services.agent_control),+ ),services,git_enrichment_policy,fork_persistence,@@ -1915,7 +1906,9 @@ impl Session {session_source: &session_configuration.session_source,originator: &session_configuration.originator,disabled_plugin_ids: &session_configuration.disabled_plugin_ids,- environments: McpEnvironmentScope::Selected(&resolved_environment_selections),+ environments: McpEnvironmentScope::Selected(+ &resolved_environment_selections,+ ),},/*ready_selected_capability_roots*/ &[],/*executor_capability_discovery*/ None,diff --git a/codex-rs/core/src/session/tests.rs b/codex-rs/core/src/session/tests.rsindex 7b5a34e4aa..0019592ea6 100644--- a/codex-rs/core/src/session/tests.rs+++ b/codex-rs/core/src/session/tests.rs@@ -6613,144 +6613,6 @@ async fn absolute_cwd_update_with_turn_environment_is_allowed() {);}-#[tokio::test]-async fn session_new_fails_when_zsh_fork_enabled_without_packaged_zsh() {- let codex_home = tempfile::tempdir().expect("create temp dir");- let mut config = build_test_config(codex_home.path()).await;- config- .features- .enable(Feature::ShellZshFork)- .expect("test config should allow shell_zsh_fork");- config.zsh_path = None;- let config = Arc::new(config);-- let auth_manager = AuthManager::from_auth_for_testing(CodexAuth::from_api_key("Test API Key"));- let models_manager = models_manager_with_provider(- config.codex_home.to_path_buf(),- auth_manager.clone(),- config.model_provider.clone(),- );- let model = get_model_offline_for_tests(config.model.as_deref());- let model_info =- construct_model_info_offline_for_tests(model.as_str(), &config.to_models_manager_config());- let collaboration_mode = CollaborationMode {- mode: ModeKind::Default,- settings: Settings {- model,- reasoning_effort: config.model_reasoning_effort.clone(),- developer_instructions: None,- },- };- let session_configuration = SessionConfiguration {- turn_extension_init: Default::default(),- provider: create_model_provider(- config.model_provider.clone(),- Some(Arc::clone(&auth_manager)),- ),- environments: Vec::new(),- step_settings: Arc::new(StepSettings {- collaboration_mode,- reasoning_summary: config.model_reasoning_summary,- service_tier: None,- personality: config.personality,- approval_policy: config.permissions.approval_policy.clone(),- approvals_reviewer: config.approvals_reviewer,- }),- model_info_overrides: config.to_models_manager_config().into(),- developer_instructions: config.developer_instructions.clone(),- base_instructions: config- .base_instructions- .clone()- .unwrap_or_else(|| render_model_instructions(&model_info)),- permission_profile_state: config.permissions.permission_profile_state().clone(),- allow_login_shell: config.permissions.allow_login_shell,- shell_environment_policy: config.permissions.shell_environment_policy.clone(),- windows_sandbox_level: WindowsSandboxLevel::from_config(&config),- windows_sandbox_type: config.permissions.windows_sandbox_type,- use_legacy_landlock: config.features.use_legacy_landlock(),- legacy_fallback_cwd: config.cwd.clone(),- runtime_workspace_roots: config.workspace_roots.clone(),- codex_home: config.codex_home.clone(),- thread_name: None,- disabled_plugin_ids: Vec::new(),- original_config_do_not_use: Arc::clone(&config),- metrics_service_name: None,- app_server_client_name: None,- app_server_client_version: None,- trusted_guardian_reviewer: false,- session_source: SessionSource::Exec,- history_mode: Default::default(),- forked_from_thread_id: None,- parent_thread_id: None,- thread_source: None,- originator: "test_originator".to_string(),- dynamic_tools: Vec::new(),- user_shell_override: None,- };-- let (tx_event, _rx_event) = async_channel::unbounded();- let (agent_status_tx, _agent_status_rx) = watch::channel(AgentStatus::PendingInit);- let plugins_manager = Arc::new(plugins_manager_for_config(- &config,- Arc::clone(&auth_manager),- ));- let mcp_manager = Arc::new(McpManager::new(Arc::clone(&plugins_manager)));- let skills_service = Arc::new(HostSkillsService::new(- config.codex_home.clone(),- /*bundled_skills_enabled*/ true,- ));- let environment_manager = Arc::new(EnvironmentManager::default_for_tests());- let result = Session::new(- /*startup*/ None,- session_configuration,- /*environment_selections*/ &[],- Arc::clone(&config),- SessionInstructions::default(),- "11111111-1111-4111-8111-111111111111".to_string(),- auth_manager,- models_manager,- Arc::default(),- model_info,- Arc::new(ExecPolicyManager::default()),- tx_event,- agent_status_tx,- InitialHistory::New,- ForkPersistence::Copied,- SessionSource::Exec,- skills_service,- plugins_manager,- mcp_manager,- Arc::new(codex_code_mode::DisabledCodeModeSessionProvider),- Arc::new(codex_extension_api::ExtensionRegistryBuilder::new().build()),- codex_extension_api::ExtensionDataInit::default(),- ClientMcpExtensions::default(),- LocalAgentControl::default().into(),- /*reserved_thread_id*/ None,- environment_manager,- /*inherited_environments*/ None,- /*analytics_events_client*/ None,- crate::passthrough_image_store(),- Arc::new(codex_thread_store::LocalThreadStore::new(- codex_thread_store::LocalThreadStoreConfig::from_config(config.as_ref()),- /*state_db*/ None,- )),- codex_rollout_trace::ThreadTraceContext::disabled(),- /*attestation_provider*/ None,- /*external_time_provider*/ None,- Some(config.multi_agent_version_from_features()),- GitEnrichmentPolicy::Fresh,- codex_sandboxing::WindowsSandboxProxySettingsMode::Reconcile,- )- .await;-- let err = match result {- Ok(_) => panic!("expected startup to fail"),- Err(err) => err,- };- let msg = format!("{err:#}");- assert!(msg.contains("zsh fork feature enabled, but no packaged zsh fork is available"));-}-async fn build_initial_context(session: &Session,turn_context: &Arc<TurnContext>,@@ -6978,8 +6840,6 @@ pub(crate) async fn make_session_and_context() -> (Session, TurnContext) {config.background_terminal_max_timeout,),elicitations: crate::elicitation::ElicitationService::new(),- shell_zsh_path: None,- main_execve_wrapper_exe: config.main_execve_wrapper_exe.clone(),analytics_events_client: AnalyticsEventsClient::new(Arc::clone(&auth_manager),config.chatgpt_base_url.trim_end_matches('/').to_string(),@@ -7132,9 +6992,6 @@ pub(crate) async fn make_session_and_context() -> (Session, TurnContext) {session_configuration.provider.clone(),&session_configuration,config.multi_agent_version_from_features(),- session.services.user_shell.as_ref(),- session.services.shell_zsh_path.as_ref(),- session.services.main_execve_wrapper_exe.as_ref(),per_turn_config,Arc::new(super::step_settings::ResolvedStepSettings::new(Arc::clone(&session_configuration.step_settings),@@ -9246,8 +9103,6 @@ whereconfig.background_terminal_max_timeout,),elicitations: crate::elicitation::ElicitationService::new(),- shell_zsh_path: None,- main_execve_wrapper_exe: config.main_execve_wrapper_exe.clone(),analytics_events_client: AnalyticsEventsClient::new(Arc::clone(&auth_manager),config.chatgpt_base_url.trim_end_matches('/').to_string(),@@ -9400,9 +9255,6 @@ wheresession_configuration.provider.clone(),&session_configuration,config.multi_agent_version_from_features(),- session.services.user_shell.as_ref(),- session.services.shell_zsh_path.as_ref(),- session.services.main_execve_wrapper_exe.as_ref(),per_turn_config,Arc::new(super::step_settings::ResolvedStepSettings::new(Arc::clone(&session_configuration.step_settings),diff --git a/codex-rs/core/src/session/turn_context.rs b/codex-rs/core/src/session/turn_context.rsindex d658e96e35..1e705c88eb 100644--- a/codex-rs/core/src/session/turn_context.rs+++ b/codex-rs/core/src/session/turn_context.rs@@ -367,7 +367,6 @@ pub struct TurnContext {// so owner-provided environment settings govern the remaining sandbox decisions.pub(crate) windows_sandbox_level: WindowsSandboxLevel,pub(crate) available_models: Vec<ModelPreset>,- pub(crate) unified_exec_shell_mode: UnifiedExecShellMode,pub(crate) final_output_json_schema: Option<Value>,pub(crate) dynamic_tools: Vec<DynamicToolSpec>,pub(crate) turn_metadata_state: Arc<TurnMetadataState>,@@ -415,7 +414,6 @@ impl TurnContext {config: Arc<Config>,step_settings: Arc<ResolvedStepSettings>,available_models: Vec<ModelPreset>,- unified_exec_shell_mode: UnifiedExecShellMode,turn_metadata_state: Arc<TurnMetadataState>,) -> Self {let session_telemetry = step_settings.telemetry(&self.session_telemetry);@@ -444,7 +442,6 @@ impl TurnContext {originator: self.originator.clone(),initial_environments: self.initial_environments.clone(),available_models,- unified_exec_shell_mode,current_date: self.current_date.clone(),timezone: self.timezone.clone(),app_server_client_name: self.app_server_client_name.clone(),@@ -853,7 +850,6 @@ impl TurnContext {network: self.network.clone(),windows_sandbox_level: self.windows_sandbox_level,available_models,- unified_exec_shell_mode: self.unified_exec_shell_mode.clone(),final_output_json_schema: self.final_output_json_schema.clone(),dynamic_tools: self.dynamic_tools.clone(),turn_metadata_state: self.turn_metadata_state.clone(),@@ -1023,9 +1019,6 @@ impl Session {provider: SharedModelProvider,session_configuration: &SessionConfiguration,multi_agent_version: MultiAgentVersion,- user_shell: &shell::Shell,- shell_zsh_path: Option<&PathBuf>,- main_execve_wrapper_exe: Option<&PathBuf>,per_turn_config: Config,step_settings: Arc<ResolvedStepSettings>,models_manager: &SharedModelsManager,@@ -1039,12 +1032,6 @@ impl Session {let session_telemetry_for_context = step_settings.telemetry(session_telemetry);let session_source = session_configuration.session_source.clone();let available_models = models_manager.try_list_models().unwrap_or_default();- let unified_exec_shell_mode = UnifiedExecShellMode::for_session(- per_turn_config.features.get(),- crate::tools::tool_user_shell_type(user_shell),- shell_zsh_path,- main_execve_wrapper_exe,- );let mut per_turn_config = per_turn_config;let configured_token_budget = per_turn_config.token_budget.clone();@@ -1134,7 +1121,6 @@ impl Session {network,windows_sandbox_level: session_configuration.windows_sandbox_level,available_models,- unified_exec_shell_mode,final_output_json_schema: None,dynamic_tools: session_configuration.dynamic_tools.clone(),turn_metadata_state,@@ -1350,9 +1336,6 @@ impl Session {session_configuration.provider.clone(),&session_configuration,multi_agent_version,- self.services.user_shell.as_ref(),- self.services.shell_zsh_path.as_ref(),- self.services.main_execve_wrapper_exe.as_ref(),per_turn_config,step_settings,&self.services.models_manager,diff --git a/codex-rs/core/src/spawn.rs b/codex-rs/core/src/spawn.rsindex 79526b8bfd..3ac3493f9b 100644--- a/codex-rs/core/src/spawn.rs+++ b/codex-rs/core/src/spawn.rs@@ -80,11 +80,6 @@ pub(crate) async fn spawn_child_async(request: SpawnChildRequest<'_>) -> std::ioif let Some(network) = network {network.apply_to_env(&mut env);}- // macOS fd cleanup must keep the shell escalation socket.- #[cfg(target_os = "macos")]- let inherited_fd = env- .get(codex_shell_escalation::ESCALATE_SOCKET_ENV_VAR)- .and_then(|fd| fd.parse().ok());cmd.env_clear();cmd.envs(env);@@ -113,9 +108,9 @@ pub(crate) async fn spawn_child_async(request: SpawnChildRequest<'_>) -> std::io// current parent dies."codex_utils_pty::process_group::set_parent_death_signal(parent_pid)?;}- // macOS cannot receive the fd with close-on-exec set atomically.+ // Close descriptors accidentally inherited by the child.#[cfg(target_os = "macos")]- codex_utils_pty::pty::close_inherited_fds_except(inherited_fd.as_slice());+ codex_utils_pty::pty::close_inherited_fds_except(&[]);Ok(())});}diff --git a/codex-rs/core/src/state/service.rs b/codex-rs/core/src/state/service.rsindex bd723c453f..3671386bd4 100644--- a/codex-rs/core/src/state/service.rs+++ b/codex-rs/core/src/state/service.rs@@ -1,5 +1,4 @@use std::collections::HashMap;-use std::path::PathBuf;use std::sync::Arc;use std::sync::Mutex as StdMutex;@@ -56,10 +55,6 @@ pub(crate) struct SessionServices {pub(crate) mcp_handler_cache: McpHandlerCache,pub(crate) unified_exec_manager: UnifiedExecProcessManager,pub(crate) elicitations: ElicitationService,- #[cfg_attr(not(unix), allow(dead_code))]- pub(crate) shell_zsh_path: Option<PathBuf>,- #[cfg_attr(not(unix), allow(dead_code))]- pub(crate) main_execve_wrapper_exe: Option<PathBuf>,pub(crate) analytics_events_client: AnalyticsEventsClient,pub(crate) hooks: ArcSwap<Hooks>,pub(crate) rollout_thread_trace: ThreadTraceContext,diff --git a/codex-rs/core/src/tools/approvals.rs b/codex-rs/core/src/tools/approvals.rsindex e892a6e805..16197b56d3 100644--- a/codex-rs/core/src/tools/approvals.rs+++ b/codex-rs/core/src/tools/approvals.rs@@ -26,8 +26,6 @@ use codex_otel::ToolDecisionSource;use codex_prompts::ResolvedModelMessages;use codex_protocol::approvals::ExecApprovalKind;use codex_protocol::approvals::ExecPolicyAmendment;-#[cfg(unix)]-use codex_protocol::approvals::GuardianCommandSource;use codex_protocol::approvals::NetworkApprovalContext;use codex_protocol::approvals::NetworkApprovalProtocol;use codex_protocol::config_types::ApprovalsReviewer;@@ -89,18 +87,6 @@ pub(crate) enum ApprovalAction {sandbox_permissions: SandboxPermissions,additional_permissions: Option<AdditionalPermissionProfile>,},- #[cfg(unix)]- Execve {- id: String,- approval_id: String,- environment_id: String,- source: GuardianCommandSource,- program: AbsolutePathBuf,- argv: Vec<String>,- command: Vec<String>,- cwd: AbsolutePathBuf,- additional_permissions: Option<AdditionalPermissionProfile>,- },ApplyPatch {id: String,environment_id: String,@@ -195,11 +181,6 @@ impl ApprovalAction {"additional_permissions": additional_permissions,}),},- #[cfg(unix)]- Self::Execve { command, .. } => PermissionRequestPayload::bash(- codex_shell_command::parse_command::shlex_join(command),- /*description*/ None,- ),Self::ApplyPatch { patch, .. } => PermissionRequestPayload {tool_name: HookToolName::apply_patch(),tool_input: serde_json::json!({ "command": patch }),@@ -255,8 +236,6 @@ impl ApprovalAction {sandbox_permissions: *sandbox_permissions,additional_permissions: additional_permissions.clone(),})],- #[cfg(unix)]- Self::Execve { .. } => Vec::new(),Self::McpToolCall { .. }| Self::NetworkAccess { .. }| Self::RequestPermissions { .. }@@ -331,25 +310,6 @@ impl ApprovalAction {sandbox_permissions,additional_permissions,},- #[cfg(unix)]- Self::Execve {- id,- environment_id,- source,- program,- argv,- cwd,- additional_permissions,- ..- } => crate::guardian::GuardianApprovalRequest::Execve {- id,- environment_id,- source,- program: program.to_string_lossy().into_owned(),- argv,- cwd,- additional_permissions,- },Self::ApplyPatch {id,environment_id,@@ -495,8 +455,6 @@ impl Session {let is_mcp_tool_call = matches!(&action, ApprovalAction::McpToolCall { .. });let is_network_approval = matches!(&action, ApprovalAction::NetworkAccess { .. });let permission_request_run_id = match &action {- #[cfg(unix)]- ApprovalAction::Execve { approval_id, .. } => approval_id.clone(),ApprovalAction::NetworkAccess { hook_run_id, .. } => hook_run_id.clone(),_ if ctx.retry_reason.is_some() => format!("{}:retry", ctx.call_id),_ => ctx.call_id.clone(),@@ -763,33 +721,6 @@ impl Session {).await}- #[cfg(unix)]- ApprovalAction::Execve {- approval_id,- environment_id,- command,- cwd,- additional_permissions,- ..- } => {- self.request_command_approval(- ctx.review_context.turn(),- ExecApprovalKind::Command,- ctx.review_context.model_context(),- ctx.call_id.clone(),- Some(approval_id.clone()),- Some(environment_id.clone()),- command.clone(),- cwd.clone().into(),- /*reason*/ None,- /*network_approval_context*/ None,- /*proposed_execpolicy_amendment*/ None,- additional_permissions.clone(),- Some(vec![ReviewDecision::Approved, ReviewDecision::Abort]),- /*plugin_attribution_override*/ None,- )- .await- }ApprovalAction::ApplyPatch {changes,permissions_preapproved,diff --git a/codex-rs/core/src/tools/handlers/unified_exec.rs b/codex-rs/core/src/tools/handlers/unified_exec.rsindex 763fa15576..6eeaf861c1 100644--- a/codex-rs/core/src/tools/handlers/unified_exec.rs+++ b/codex-rs/core/src/tools/handlers/unified_exec.rs@@ -1,16 +1,13 @@use crate::sandboxing::SandboxPermissions;use crate::shell::Shell;use crate::shell::ShellInvocation;-use crate::shell::ShellType;use crate::shell::get_shell_by_model_provided_path;use crate::tools::context::ToolInvocation;use crate::tools::context::ToolOutput;use crate::tools::context::ToolPayload;use crate::tools::hook_names::HookToolName;use crate::tools::registry::PostToolUsePayload;-use codex_exec_server::Environment;use codex_protocol::models::AdditionalPermissionProfile;-use codex_tools::UnifiedExecShellMode;use serde::Deserialize;use std::path::PathBuf;use std::sync::Arc;@@ -100,7 +97,6 @@ fn post_unified_exec_tool_use_payload(pub(crate) fn get_command(args: &ExecCommandArgs,session_shell: Arc<Shell>,- shell_mode: &UnifiedExecShellMode,allow_login_shell: bool,) -> Result<ResolvedCommand, String> {let use_login_shell = match args.login {@@ -113,24 +109,11 @@ pub(crate) fn get_command(None => allow_login_shell,};- let shell = match shell_mode {- UnifiedExecShellMode::Direct => args- .shell- .as_ref()- .map(|shell_str| get_shell_by_model_provided_path(&PathBuf::from(shell_str)))- .unwrap_or_else(|| session_shell.as_ref().clone()),- UnifiedExecShellMode::ZshFork(zsh_fork_config) => {- if args.shell.is_some() {- return Err(- "`shell` is not supported for local zsh-fork exec; omit `shell` to use zsh-fork, or target a remote environment where `shell` is supported.".to_string(),- );- }- Shell {- shell_type: ShellType::Zsh,- shell_path: zsh_fork_config.shell_zsh_path.as_path().to_path_buf(),- }- }- };+ let shell = args+ .shell+ .as_ref()+ .map(|shell_str| get_shell_by_model_provided_path(&PathBuf::from(shell_str)))+ .unwrap_or_else(|| session_shell.as_ref().clone());Ok(ResolvedCommand {command: shell.derive_exec_args(&args.cmd, use_login_shell),shell: ShellInvocation {@@ -140,17 +123,6 @@ pub(crate) fn get_command(})}-pub(crate) fn shell_mode_for_environment(- turn_shell_mode: &UnifiedExecShellMode,- environment: &Environment,-) -> UnifiedExecShellMode {- if environment.is_remote() {- UnifiedExecShellMode::Direct- } else {- turn_shell_mode.clone()- }-}-#[cfg(test)]#[path = "unified_exec_tests.rs"]mod tests;diff --git a/codex-rs/core/src/tools/handlers/unified_exec/exec_command.rs b/codex-rs/core/src/tools/handlers/unified_exec/exec_command.rsindex faf8b90848..502848230d 100644--- a/codex-rs/core/src/tools/handlers/unified_exec/exec_command.rs+++ b/codex-rs/core/src/tools/handlers/unified_exec/exec_command.rs@@ -51,7 +51,6 @@ use super::ExecCommandArgs;use super::ExecCommandEnvironmentArgs;use super::get_command;use super::post_unified_exec_tool_use_payload;-use super::shell_mode_for_environment;// A byte limit is a conservative hard token bound even for byte-fallback tokenizers.const EXEC_COMMAND_REJECTION_MAX_BYTES: usize = 900;@@ -257,8 +256,6 @@ impl ExecCommandHandler {&turn_environment.selection.environment_id,).await;- let shell_mode =- shell_mode_for_environment(&turn.unified_exec_shell_mode, environment.as_ref());// Remote environments may use a different OS and must build commands with their native// shell; fall back to the session shell when the environment did not report one.let shell = turn_environment@@ -285,13 +282,9 @@ impl ExecCommandHandler {)));}}- let resolved_command = get_command(- &args,- shell,- &shell_mode,- turn_environment.config().allow_login_shell,- )- .map_err(FunctionCallError::RespondToModel)?;+ let resolved_command =+ get_command(&args, shell, turn_environment.config().allow_login_shell)+ .map_err(FunctionCallError::RespondToModel)?;let command = resolved_command.command;let ExecCommandArgs {mut tty,@@ -420,7 +413,6 @@ impl ExecCommandHandler {cwd,sandbox_cwd: native_environment_cwd,turn_environment: turn_environment.clone(),- shell_mode,network: context.step_context.turn.network.clone(),tty,sandbox_permissions: effective_additional_permissions.sandbox_permissions,diff --git a/codex-rs/core/src/tools/handlers/unified_exec_tests.rs b/codex-rs/core/src/tools/handlers/unified_exec_tests.rsindex d834c24982..ecff8f5039 100644--- a/codex-rs/core/src/tools/handlers/unified_exec_tests.rs+++ b/codex-rs/core/src/tools/handlers/unified_exec_tests.rs@@ -2,10 +2,8 @@ use super::*;use crate::shell::ShellType;use crate::shell::default_user_shell;use crate::shell::get_shell;+#[cfg(not(windows))]use codex_exec_server::Environment;-use codex_tools::UnifiedExecShellMode;-use codex_tools::ZshForkConfig;-use codex_utils_absolute_path::AbsolutePathBuf;use codex_utils_output_truncation::TruncationPolicy;use codex_utils_path_uri::PathUri;use pretty_assertions::assert_eq;@@ -58,7 +56,6 @@ fn test_get_command_uses_default_shell_when_unspecified() -> anyhow::Result<()>let resolved = get_command(&args,Arc::new(default_user_shell()),- &UnifiedExecShellMode::Direct,/*allow_login_shell*/ true,).map_err(anyhow::Error::msg)?;@@ -80,7 +77,6 @@ fn test_get_command_respects_explicit_bash_shell() -> anyhow::Result<()> {let resolved = get_command(&args,Arc::new(default_user_shell()),- &UnifiedExecShellMode::Direct,/*allow_login_shell*/ true,).map_err(anyhow::Error::msg)?;@@ -122,13 +118,8 @@ fn test_get_command_keeps_path_prepends_after_login_startup() -> anyhow::Result<r#"{"cmd":"sh -c 'test \"$CODEX_TEST_LOGIN_PATH_RESET\" = 1 && printf \"%s\\n\" \"$PATH\" && command -v rg'"}"#,)?;let shell = Arc::new(get_shell(ShellType::Bash).expect("bash should be available"));- let resolved = get_command(- &args,- Arc::clone(&shell),- &UnifiedExecShellMode::Direct,- /*allow_login_shell*/ true,- )- .map_err(anyhow::Error::msg)?;+ let resolved = get_command(&args, Arc::clone(&shell), /*allow_login_shell*/ true)+ .map_err(anyhow::Error::msg)?;assert_eq!(resolved.command,shell.derive_exec_args(&args.cmd, /*use_login_shell*/ true)@@ -188,19 +179,15 @@ fn test_get_command_runs_login_shell_when_path_is_readonly() -> anyhow::Result<(r#"{"cmd":"shopt -q login_shell || exit 90; case $- in *e*) ;; *) exit 91 ;; esac; /bin/sh -c 'printf \"%s\\n\" \"$PATH\"'; exit 23","login":true}"#,)?;let shell = Arc::new(get_shell(ShellType::Bash).expect("bash should be available"));- let resolved = get_command(- &args,- shell,- &UnifiedExecShellMode::Direct,- /*allow_login_shell*/ true,- )- .map_err(anyhow::Error::msg)?;+ let resolved =+ get_command(&args, shell, /*allow_login_shell*/ true).map_err(anyhow::Error::msg)?;let command = resolved.shell.derive_exec_args_with_path_prepends(&args.cmd, &[path_dir]).expect("the reported directory can be put on PATH");let output = std::process::Command::new(&command[0]).args(&command[1..])+ .env("HOME", temp_dir.path()).env("BASH_ENV", startup).env("CODEX_TEST_LOGIN_HOME", temp_dir.path()).env_remove("SHLVL")@@ -249,13 +236,8 @@ fn test_get_command_does_not_change_nested_login_or_powershell() -> anyhow::Resushell_type,shell_path: PathBuf::from(shell_path),});- let resolved = get_command(- &args,- Arc::clone(&shell),- &UnifiedExecShellMode::Direct,- /*allow_login_shell*/ true,- )- .map_err(anyhow::Error::msg)?;+ let resolved = get_command(&args, Arc::clone(&shell), /*allow_login_shell*/ true)+ .map_err(anyhow::Error::msg)?;assert_eq!((resolved.command,@@ -294,7 +276,6 @@ fn test_get_command_resolves_powershell_by_type() -> anyhow::Result<()> {let resolved = get_command(&args,Arc::new(default_user_shell()),- &UnifiedExecShellMode::Direct,/*allow_login_shell*/ true,).map_err(anyhow::Error::msg)?;@@ -319,7 +300,6 @@ fn test_get_command_respects_explicit_cmd_shell() -> anyhow::Result<()> {let resolved = get_command(&args,Arc::new(default_user_shell()),- &UnifiedExecShellMode::Direct,/*allow_login_shell*/ true,).map_err(anyhow::Error::msg)?;@@ -337,7 +317,6 @@ fn test_get_command_rejects_explicit_login_when_disallowed() -> anyhow::Result<(let err = get_command(&args,Arc::new(default_user_shell()),- &UnifiedExecShellMode::Direct,/*allow_login_shell*/ false,).expect_err("explicit login should be rejected");@@ -389,71 +368,6 @@ async fn exec_command_rejects_login_when_selected_environment_disallows_it() {);}-#[test]-fn test_get_command_rejects_explicit_shell_in_zsh_fork_mode() -> anyhow::Result<()> {- let json = r#"{"cmd": "echo hello", "shell": "/bin/bash"}"#;- let args: ExecCommandArgs = parse_arguments(json)?;- let shell_zsh_path = AbsolutePathBuf::from_absolute_path(if cfg!(windows) {- r"C:\opt\codex\zsh"- } else {- "/opt/codex/zsh"- })?;- let shell_mode = UnifiedExecShellMode::ZshFork(ZshForkConfig {- shell_zsh_path,- main_execve_wrapper_exe: AbsolutePathBuf::from_absolute_path(if cfg!(windows) {- r"C:\opt\codex\codex-execve-wrapper"- } else {- "/opt/codex/codex-execve-wrapper"- })?,- });-- let err = get_command(- &args,- Arc::new(default_user_shell()),- &shell_mode,- /*allow_login_shell*/ true,- )- .expect_err("explicit shell should be rejected");-- assert!(- err.contains("`shell` is not supported for local zsh-fork exec"),- "unexpected error: {err}"- );- Ok(())-}--#[tokio::test]-async fn shell_mode_for_environment_uses_direct_mode_for_remote_environments() -> anyhow::Result<()>-{- let shell_zsh_path = AbsolutePathBuf::from_absolute_path(if cfg!(windows) {- r"C:\opt\codex\zsh"- } else {- "/opt/codex/zsh"- })?;- let shell_mode = UnifiedExecShellMode::ZshFork(ZshForkConfig {- shell_zsh_path,- main_execve_wrapper_exe: AbsolutePathBuf::from_absolute_path(if cfg!(windows) {- r"C:\opt\codex\codex-execve-wrapper"- } else {- "/opt/codex/codex-execve-wrapper"- })?,- });- let local_environment = Environment::default_for_tests();- let remote_environment =- Environment::create_for_tests(Some("ws://127.0.0.1:1/remote-exec-server".to_string()))?;-- assert_eq!(- shell_mode_for_environment(&shell_mode, &local_environment),- shell_mode- );- assert_eq!(- shell_mode_for_environment(&shell_mode, &remote_environment),- UnifiedExecShellMode::Direct- );-- Ok(())-}-#[tokio::test]#[cfg(not(windows))]async fn exec_command_reuses_foreign_windows_grant() {diff --git a/codex-rs/core/src/tools/mod.rs b/codex-rs/core/src/tools/mod.rsindex 41ed0189b8..501ce5fe4e 100644--- a/codex-rs/core/src/tools/mod.rs+++ b/codex-rs/core/src/tools/mod.rs@@ -60,18 +60,6 @@ pub(crate) fn flat_tool_name(tool_name: &ToolName) -> Cow<'_, str> {}}-pub(crate) fn tool_user_shell_type(- user_shell: &crate::shell::Shell,-) -> codex_tools::ToolUserShellType {- match user_shell.shell_type {- crate::shell::ShellType::Zsh => codex_tools::ToolUserShellType::Zsh,- crate::shell::ShellType::Bash => codex_tools::ToolUserShellType::Bash,- crate::shell::ShellType::PowerShell => codex_tools::ToolUserShellType::PowerShell,- crate::shell::ShellType::Sh => codex_tools::ToolUserShellType::Sh,- crate::shell::ShellType::Cmd => codex_tools::ToolUserShellType::Cmd,- }-}-pub(crate) fn requested_tool_mode(turn_context: &TurnContext, model_info: &ModelInfo) -> ToolMode {model_info.tool_mode.unwrap_or_else(|| {if turn_context.config.features.enabled(Feature::CodeModeOnly) {diff --git a/codex-rs/core/src/tools/runtimes/mod.rs b/codex-rs/core/src/tools/runtimes/mod.rsindex 17a427be2f..359bc770f2 100644--- a/codex-rs/core/src/tools/runtimes/mod.rs+++ b/codex-rs/core/src/tools/runtimes/mod.rs@@ -35,7 +35,6 @@ use std::path::Path;pub(crate) mod apply_patch;pub(crate) mod unified_exec;-pub(crate) mod zsh_fork;const SNAPSHOT_ORIGINAL_BASH_ENV_ENV_KEY: &str = "CODEX_NETWORK_PROXY_SNAPSHOT_ORIGINAL_BASH_ENV";const SNAPSHOT_ORIGINAL_POSIX_ENV_ENV_KEY: &str = "CODEX_NETWORK_PROXY_SNAPSHOT_ORIGINAL_POSIX_ENV";@@ -141,18 +140,6 @@ pub(crate) fn apply_package_path_prepend(runtime_path_prepends.prepend(env, path_dir.as_path());}-#[cfg(unix)]-pub(crate) fn apply_zsh_fork_path_prepend(- env: &mut HashMap<String, String>,- runtime_path_prepends: &mut RuntimePathPrepends,- shell_zsh_path: &Path,-) {- let Some(zsh_bin_dir) = shell_zsh_path.parent() else {- return;- };- runtime_path_prepends.prepend(env, zsh_bin_dir);-}-pub(crate) fn prepare_powershell_command_for_windows_sandbox(command: &[String],shell_type: Option<&ShellType>,diff --git a/codex-rs/core/src/tools/runtimes/mod_tests.rs b/codex-rs/core/src/tools/runtimes/mod_tests.rsindex e1a25d1d82..d5933281d8 100644--- a/codex-rs/core/src/tools/runtimes/mod_tests.rs+++ b/codex-rs/core/src/tools/runtimes/mod_tests.rs@@ -253,56 +253,6 @@ fn runtime_path_prepends_ignores_empty_path_entry() {);}-#[cfg(unix)]-#[test]-fn apply_zsh_fork_path_prepend_uses_shell_parent() {- let mut env = HashMap::from([("PATH".to_string(), "/usr/bin:/bin".to_string())]);- let mut runtime_path_prepends = RuntimePathPrepends::default();-- apply_zsh_fork_path_prepend(- &mut env,- &mut runtime_path_prepends,- PathBuf::from("/package/codex-resources/zsh/bin/zsh").as_path(),- );-- let expected = "/package/codex-resources/zsh/bin:/usr/bin:/bin";- assert_eq!(env.get("PATH").map(String::as_str), Some(expected));- assert_eq!(- runtime_path_prepends,- RuntimePathPrepends {- entries: vec!["/package/codex-resources/zsh/bin".to_string()]- }- );-}--#[cfg(unix)]-#[test]-fn apply_zsh_fork_path_prepend_moves_existing_shell_parent_to_front() {- let mut env = HashMap::from([(- "PATH".to_string(),- "/usr/bin:/package/codex-resources/zsh/bin:/bin:/package/codex-resources/zsh/bin"- .to_string(),- )]);- let mut runtime_path_prepends = RuntimePathPrepends::default();-- apply_zsh_fork_path_prepend(- &mut env,- &mut runtime_path_prepends,- PathBuf::from("/package/codex-resources/zsh/bin/zsh").as_path(),- );-- assert_eq!(- env.get("PATH").map(String::as_str),- Some("/package/codex-resources/zsh/bin:/usr/bin:/bin")- );- assert_eq!(- runtime_path_prepends,- RuntimePathPrepends {- entries: vec!["/package/codex-resources/zsh/bin".to_string()]- }- );-}-#[test]fn explicit_escalation_keeps_user_proxy_env_without_codex_marker() {let env = HashMap::from([@@ -1764,56 +1714,6 @@ fn run_snapshot_path_probe_with_runtime_path_prepend())}-#[cfg(unix)]-#[test]-fn maybe_wrap_shell_lc_with_snapshot_preserves_zsh_fork_path_prepend() {- let dir = tempdir().expect("create temp dir");- let snapshot_path = dir.path().join("snapshot.sh");- std::fs::write(- &snapshot_path,- "# Snapshot file\nexport PATH='/snapshot/bin'\n",- )- .expect("write snapshot");- let (session_shell, shell_snapshot) =- shell_with_snapshot(ShellType::Bash, "/bin/bash", snapshot_path.abs());- let command = vec![- "/bin/bash".to_string(),- "-lc".to_string(),- "printf '%s' \"$PATH\"".to_string(),- ];- let zsh_path = dir- .path()- .join("codex-resources")- .join("zsh")- .join("bin")- .join("zsh");- let zsh_bin_dir = zsh_path.parent().expect("zsh path should have parent");- let mut env = HashMap::from([("PATH".to_string(), "/worktree/bin".to_string())]);- let explicit_env_overrides = HashMap::new();- let mut runtime_path_prepends = RuntimePathPrepends::default();- apply_zsh_fork_path_prepend(&mut env, &mut runtime_path_prepends, zsh_path.as_path());- let rewritten = maybe_wrap_shell_lc_with_snapshot(- &command,- &session_shell,- Some(&shell_snapshot),- &explicit_env_overrides,- &env,- &runtime_path_prepends,- );- let output = Command::new(&rewritten[0])- .args(&rewritten[1..])- .env("PATH", env.get("PATH").expect("PATH should be set"))- .output()- .expect("run rewritten command");-- assert!(output.status.success(), "command failed: {output:?}");- assert_eq!(- String::from_utf8_lossy(&output.stdout),- format!("{}:/snapshot/bin", zsh_bin_dir.display()),- "zsh fork path prepend should replay ahead of snapshot PATH"- );-}-#[test]fn maybe_wrap_shell_lc_with_snapshot_does_not_embed_override_values_in_argv() {let dir = tempdir().expect("create temp dir");diff --git a/codex-rs/core/src/tools/runtimes/unified_exec.rs b/codex-rs/core/src/tools/runtimes/unified_exec.rsindex 57320382fb..61d66c6927 100644--- a/codex-rs/core/src/tools/runtimes/unified_exec.rs+++ b/codex-rs/core/src/tools/runtimes/unified_exec.rs@@ -21,12 +21,9 @@ use crate::shell_snapshot::snapshot_read_permissions;use crate::tools::flat_tool_name;use crate::tools::network_approval::NetworkApprovalSpec;use crate::tools::runtimes::RuntimePathPrepends;-#[cfg(unix)]-use crate::tools::runtimes::apply_zsh_fork_path_prepend;use crate::tools::runtimes::exec_env_for_sandbox_permissions;use crate::tools::runtimes::maybe_wrap_shell_lc_with_snapshot;use crate::tools::runtimes::prepare_powershell_command_for_windows_sandbox;-use crate::tools::runtimes::zsh_fork;use crate::tools::sandboxing::Approvable;use crate::tools::sandboxing::ApprovalAction;use crate::tools::sandboxing::ExecApprovalRequirement;@@ -38,10 +35,8 @@ use crate::tools::sandboxing::ToolRuntime;use crate::tools::sandboxing::executor_windows_sandbox_selection;use crate::tools::sandboxing::managed_network_for_sandbox_permissions;use crate::tools::sandboxing::sandbox_permissions_preserving_denied_reads;-use crate::unified_exec::NoopSpawnLifecycle;use crate::unified_exec::TerminalPermissions;use crate::unified_exec::TerminalSandboxSource;-use crate::unified_exec::UnifiedExecError;use crate::unified_exec::UnifiedExecProcess;use crate::unified_exec::UnifiedExecProcessManager;use codex_core_plugins::PluginMetricsSidecar;@@ -50,13 +45,11 @@ use codex_network_proxy::CREDENTIAL_BROKER_ACTIVE_ENV_KEY;use codex_network_proxy::ManagedNetworkSandboxContext;use codex_network_proxy::NetworkProxy;use codex_protocol::error::CodexErr;-use codex_protocol::error::SandboxErr;use codex_protocol::models::AdditionalPermissionProfile;use codex_sandboxing::SandboxCommand;use codex_sandboxing::SandboxablePreference;use codex_sandboxing::policy_transforms::merge_permission_profiles;use codex_shell_command::powershell::prefix_powershell_script_with_utf8;-use codex_tools::UnifiedExecShellMode;use codex_utils_path_uri::PathUri;use std::collections::HashMap;use std::io;@@ -90,8 +83,6 @@ pub struct UnifiedExecRequest {pub tty: bool,pub sandbox_permissions: SandboxPermissions,pub additional_permissions: Option<AdditionalPermissionProfile>,- #[cfg(unix)]- pub additional_permissions_preapproved: bool,pub justification: Option<String>,pub exec_approval_requirement: ExecApprovalRequirement,}@@ -113,7 +104,6 @@ pub struct UnifiedExecApprovalKey {/// unified-exec side while delegating process startup to the manager.pub struct UnifiedExecRuntime<'a> {manager: &'a UnifiedExecProcessManager,- shell_mode: UnifiedExecShellMode,}pub(crate) struct UnifiedExecAttempt {@@ -157,11 +147,8 @@ fn build_unified_exec_sandbox_command(impl<'a> UnifiedExecRuntime<'a> {/// Creates a runtime bound to the shared unified-exec process manager.- pub fn new(manager: &'a UnifiedExecProcessManager, shell_mode: UnifiedExecShellMode) -> Self {- Self {- manager,- shell_mode,- }+ pub fn new(manager: &'a UnifiedExecProcessManager) -> Self {+ Self { manager }}}@@ -301,24 +288,13 @@ impl<'a> ToolRuntime<UnifiedExecRequest, UnifiedExecAttempt> for UnifiedExecRunt.network.as_ref().is_some_and(crate::config::NetworkProxySpec::credential_broker_enabled);- if credential_broker_available- && managed_network.is_some()- && matches!(self.shell_mode, UnifiedExecShellMode::ZshFork(_))- {- return Err(ToolError::Rejected(- "credential brokerage does not yet support shell_zsh_fork; disable shell_zsh_fork to use the broker".to_string(),- ));- }let shell = if credential_broker_available {requested_shell} else {environment_shell};- let snapshot_metrics = snapshot_metrics::SnapshotMetrics::start(- req,- &ctx.step_context.turn.config,- &self.shell_mode,- );+ let snapshot_metrics =+ snapshot_metrics::SnapshotMetrics::start(req, &ctx.step_context.turn.config);let shell_snapshot = if environment_is_remote|| credential_broker_available&& launch_sandbox_permissions.requires_escalated_permissions()@@ -510,13 +486,6 @@ impl<'a> ToolRuntime<UnifiedExecRequest, UnifiedExecAttempt> for UnifiedExecRunt&mut runtime_path_prepends,);}- if let UnifiedExecShellMode::ZshFork(zsh_fork_config) = &self.shell_mode {- apply_zsh_fork_path_prepend(- &mut env,- &mut runtime_path_prepends,- zsh_fork_config.shell_zsh_path.as_path(),- );- }runtime_path_prepends};#[cfg(not(unix))]@@ -666,78 +635,6 @@ impl<'a> ToolRuntime<UnifiedExecRequest, UnifiedExecAttempt> for UnifiedExecRuntpermissions};- if let UnifiedExecShellMode::ZshFork(zsh_fork_config) = &self.shell_mode {- let command = build_unified_exec_sandbox_command(- &command,- &req.cwd,- &env,- managed_network_context.clone(),- additional_permissions.clone(),- )- .map_err(|error| match error {- ToolError::Rejected(_) => {- ToolError::Rejected("missing command line for PTY".to_string())- }- error @ ToolError::Codex(_) => error,- })?;- let options = unified_exec_options(attempt.network_denial_cancellation_token.clone());- let mut exec_env = attempt- .env_for(- command,- options,- managed_network,- Some(&req.turn_environment.selection.environment_id),- )- .await- .map_err(ToolError::Codex)?;- exec_env.exec_server_env_config = req.exec_server_env_config.clone();- match zsh_fork::maybe_prepare_unified_exec(req, attempt, ctx, exec_env, zsh_fork_config)- .await?- {- Some(prepared) => {- if req.turn_environment.environment.is_remote() {- return Err(ToolError::Rejected(- "unified_exec zsh-fork is not supported for remote environments"- .to_string(),- ));- }- let process = self- .manager- .open_session_with_prepared_exec_env(- req.process_id,- &prepared.exec_request,- Some(ctx),- windows_sandbox_proxy_settings_mode,- /*network_policy_decider*/ None,- req.tty,- prepared.spawn_lifecycle,- req.turn_environment.environment.as_ref(),- )- .await- .map_err(|err| match err {- UnifiedExecError::SandboxDenied { output, .. } => {- ToolError::Codex(CodexErr::Sandbox(SandboxErr::Denied {- output: Box::new(output),- network_policy_decision: None,- }))- }- other => ToolError::Rejected(other.to_string()),- });- let mut process = with_launch_failure_events(process, req, ctx).await?;- process._shell_snapshot = shell_snapshot;- return Ok(UnifiedExecAttempt {- process,- metrics_sidecar,- permissions,- });- }- None => {- tracing::warn!(- "UnifiedExec ZshFork backend specified, but conditions for using it were not met, falling back to direct execution",- );- }- }- }let command = build_unified_exec_sandbox_command(&command,&req.cwd,@@ -767,7 +664,6 @@ impl<'a> ToolRuntime<UnifiedExecRequest, UnifiedExecAttempt> for UnifiedExecRuntreq.shell_snapshot.clone(),windows_sandbox_proxy_settings_mode,req.tty,- Box::new(NoopSpawnLifecycle),req.turn_environment.environment.as_ref(),).await;@@ -796,7 +692,6 @@ mod tests {use codex_protocol::protocol::EnvironmentConfig;use codex_protocol::protocol::EnvironmentConfigState;use codex_protocol::protocol::TurnEnvironmentSelection;- use codex_tools::ZshForkConfig;use codex_utils_absolute_path::AbsolutePathBuf;use codex_utils_path_uri::PathUri;use pretty_assertions::assert_eq;@@ -858,7 +753,7 @@ mod tests {#[tokio::test]async fn approval_key_includes_environment_id() {let manager = UnifiedExecProcessManager::default();- let runtime = UnifiedExecRuntime::new(&manager, UnifiedExecShellMode::Direct);+ let runtime = UnifiedExecRuntime::new(&manager);let mut request = test_request(SandboxPermissions::UseDefault,ExecApprovalRequirement::Skip {@@ -889,7 +784,7 @@ mod tests {let sandbox_cwd = AbsolutePathBuf::try_from(sandbox_dir.path().to_path_buf()).expect("absolute sandbox temp dir");let manager = UnifiedExecProcessManager::default();- let runtime = UnifiedExecRuntime::new(&manager, UnifiedExecShellMode::Direct);+ let runtime = UnifiedExecRuntime::new(&manager);let request = UnifiedExecRequest {command: vec!["pwd".to_string()],shell: ShellInvocation {@@ -912,8 +807,6 @@ mod tests {tty: false,sandbox_permissions: SandboxPermissions::UseDefault,additional_permissions: None,- #[cfg(unix)]- additional_permissions_preapproved: false,justification: None,exec_approval_requirement: ExecApprovalRequirement::Skip {bypass_sandbox: false,@@ -927,72 +820,6 @@ mod tests {);}- #[tokio::test]- async fn zsh_fork_first_attempt_preserves_parent_sandbox_override() {- let manager = UnifiedExecProcessManager::default();- let request = test_request(- SandboxPermissions::RequireEscalated,- ExecApprovalRequirement::NeedsApproval {- reason: None,- proposed_execpolicy_amendment: None,- },- );- let direct_runtime = UnifiedExecRuntime::new(&manager, UnifiedExecShellMode::Direct);- let zsh_fork_runtime = UnifiedExecRuntime::new(&manager, zsh_fork_mode());-- assert_eq!(- direct_runtime.sandbox_permissions(&request),- SandboxPermissions::RequireEscalated,- "direct unified exec should preserve a parent require_escalated request"- );- assert_eq!(- zsh_fork_runtime.sandbox_permissions(&request),- SandboxPermissions::RequireEscalated,- "zsh-fork unified exec should preserve the same parent require_escalated request"- );- }-- #[tokio::test]- async fn zsh_fork_first_attempt_preserves_additional_permissions_request() {- let manager = UnifiedExecProcessManager::default();- let request = test_request(- SandboxPermissions::WithAdditionalPermissions,- ExecApprovalRequirement::NeedsApproval {- reason: None,- proposed_execpolicy_amendment: None,- },- );- let zsh_fork_runtime = UnifiedExecRuntime::new(&manager, zsh_fork_mode());-- assert_eq!(- zsh_fork_runtime.sandbox_permissions(&request),- SandboxPermissions::WithAdditionalPermissions,- "zsh-fork unified exec should keep bounded additional-permissions requests sandboxed"- );- }-- #[tokio::test]- async fn zsh_fork_execpolicy_allow_preserves_parent_sandbox_override() {- let manager = UnifiedExecProcessManager::default();- let request = test_request(- SandboxPermissions::UseDefault,- ExecApprovalRequirement::Skip {- bypass_sandbox: true,- proposed_execpolicy_amendment: None,- },- );- let runtime = UnifiedExecRuntime::new(&manager, zsh_fork_mode());-- assert_eq!(- runtime.exec_approval_requirement(&request),- Some(ExecApprovalRequirement::Skip {- bypass_sandbox: true,- proposed_execpolicy_amendment: None,- }),- "zsh-fork unified exec should preserve exec-policy allow decisions that bypass the sandbox"- );- }-fn test_request(sandbox_permissions: SandboxPermissions,exec_approval_requirement: ExecApprovalRequirement,@@ -1021,19 +848,8 @@ mod tests {tty: false,sandbox_permissions,additional_permissions: None,- #[cfg(unix)]- additional_permissions_preapproved: false,justification: None,exec_approval_requirement,}}-- fn zsh_fork_mode() -> UnifiedExecShellMode {- let cwd = std::env::current_dir().expect("read current dir");- UnifiedExecShellMode::ZshFork(ZshForkConfig {- shell_zsh_path: AbsolutePathBuf::try_from(cwd.join("zsh")).expect("absolute zsh path"),- main_execve_wrapper_exe: AbsolutePathBuf::try_from(cwd.join("execve-wrapper"))- .expect("absolute wrapper path"),- })- }}diff --git a/codex-rs/core/src/tools/runtimes/unified_exec/snapshot_metrics.rs b/codex-rs/core/src/tools/runtimes/unified_exec/snapshot_metrics.rsindex 2f5ff3ecd1..e5b8c8f60a 100644--- a/codex-rs/core/src/tools/runtimes/unified_exec/snapshot_metrics.rs+++ b/codex-rs/core/src/tools/runtimes/unified_exec/snapshot_metrics.rs@@ -6,7 +6,6 @@ use std::time::Instant;use codex_features::Feature;use codex_otel::SessionTelemetry;-use codex_tools::UnifiedExecShellMode;use super::UnifiedExecRequest;use crate::config::Config;@@ -17,11 +16,7 @@ pub(super) struct SnapshotMetrics {}impl SnapshotMetrics {- pub(super) fn start(- req: &UnifiedExecRequest,- config: &Config,- shell_mode: &UnifiedExecShellMode,- ) -> Option<Self> {+ pub(super) fn start(req: &UnifiedExecRequest, config: &Config) -> Option<Self> {let brokered = config.permissions.network@@ -33,7 +28,6 @@ impl SnapshotMetrics {|| req.shell_snapshot.is_some()|| req.turn_environment.environment.is_remote()|| !config.features.enabled(Feature::ShellSnapshot)- || !matches!(shell_mode, UnifiedExecShellMode::Direct)|| !req.shell.is_posix_login()|| (req.cwd != req.turn_environment.selection.cwd && !brokered){diff --git a/codex-rs/core/src/tools/runtimes/zsh_fork.rs b/codex-rs/core/src/tools/runtimes/zsh_fork.rsdeleted file mode 100644index 4daa0f18b0..0000000000--- a/codex-rs/core/src/tools/runtimes/zsh_fork.rs+++ /dev/null@@ -1,105 +0,0 @@-use crate::sandboxing::ExecRequest;-use crate::tools::runtimes::unified_exec::UnifiedExecRequest;-use crate::tools::sandboxing::SandboxAttempt;-use crate::tools::sandboxing::ToolCtx;-use crate::tools::sandboxing::ToolError;-use crate::unified_exec::SpawnLifecycleHandle;-use codex_tools::ZshForkConfig;--pub(crate) struct PreparedUnifiedExecSpawn {- pub(crate) exec_request: ExecRequest,- pub(crate) spawn_lifecycle: SpawnLifecycleHandle,-}--/// Prepares unified exec to launch through the zsh-fork backend when the-/// request matches a wrapped `zsh -c/-lc` command on a supported platform.-///-/// Returns the transformed `ExecRequest` plus a spawn lifecycle that keeps the-/// escalation server alive for the session and performs post-spawn cleanup.-/// Returns `Ok(None)` when unified exec should use its normal spawn path.-pub(crate) async fn maybe_prepare_unified_exec(- req: &UnifiedExecRequest,- attempt: &SandboxAttempt<'_>,- ctx: &ToolCtx,- exec_request: ExecRequest,- zsh_fork_config: &ZshForkConfig,-) -> Result<Option<PreparedUnifiedExecSpawn>, ToolError> {- imp::maybe_prepare_unified_exec(req, attempt, ctx, exec_request, zsh_fork_config).await-}--#[cfg(unix)]-#[path = "zsh_fork/unix_escalation.rs"]-mod unix_escalation;--#[cfg(unix)]-mod imp {- use super::*;- use crate::tools::runtimes::zsh_fork::unix_escalation;- use crate::unified_exec::SpawnLifecycle;- use codex_shell_escalation::ESCALATE_SOCKET_ENV_VAR;- use codex_shell_escalation::EscalationSession;-- #[derive(Debug)]- struct ZshForkSpawnLifecycle {- escalation_session: EscalationSession,- }-- impl SpawnLifecycle for ZshForkSpawnLifecycle {- fn inherited_fds(&self) -> Vec<i32> {- self.escalation_session- .env()- .get(ESCALATE_SOCKET_ENV_VAR)- .and_then(|fd| fd.parse().ok())- .into_iter()- .collect()- }-- fn after_spawn(&mut self) {- self.escalation_session.close_client_socket();- }- }-- pub(super) async fn maybe_prepare_unified_exec(- req: &UnifiedExecRequest,- attempt: &SandboxAttempt<'_>,- ctx: &ToolCtx,- exec_request: ExecRequest,- zsh_fork_config: &ZshForkConfig,- ) -> Result<Option<PreparedUnifiedExecSpawn>, ToolError> {- let Some(prepared) = unix_escalation::prepare_unified_exec_zsh_fork(- req,- attempt,- ctx,- exec_request,- zsh_fork_config.shell_zsh_path.as_path(),- zsh_fork_config.main_execve_wrapper_exe.as_path(),- )- .await?- else {- return Ok(None);- };-- Ok(Some(PreparedUnifiedExecSpawn {- exec_request: prepared.exec_request,- spawn_lifecycle: Box::new(ZshForkSpawnLifecycle {- escalation_session: prepared.escalation_session,- }),- }))- }-}--#[cfg(not(unix))]-mod imp {- use super::*;-- pub(super) async fn maybe_prepare_unified_exec(- req: &UnifiedExecRequest,- attempt: &SandboxAttempt<'_>,- ctx: &ToolCtx,- exec_request: ExecRequest,- zsh_fork_config: &ZshForkConfig,- ) -> Result<Option<PreparedUnifiedExecSpawn>, ToolError> {- let _ = (req, attempt, ctx, exec_request, zsh_fork_config);- Ok(None)- }-}diff --git a/codex-rs/core/src/tools/runtimes/zsh_fork/unix_escalation.rs b/codex-rs/core/src/tools/runtimes/zsh_fork/unix_escalation.rsdeleted file mode 100644index ef7d30e35d..0000000000--- a/codex-rs/core/src/tools/runtimes/zsh_fork/unix_escalation.rs+++ /dev/null@@ -1,879 +0,0 @@-use crate::exec::ExecCapturePolicy;-use crate::exec::ExecExpiration;-use crate::guardian::GuardianReviewContext;-use crate::sandboxing::ExecOptions;-use crate::sandboxing::ExecRequest;-use crate::sandboxing::SandboxPermissions;-use crate::tools::approvals::ApprovalAction;-use crate::tools::approvals::ApprovalContext;-use crate::tools::runtimes::exec_env_for_sandbox_permissions;-use crate::tools::sandboxing::SandboxAttempt;-use crate::tools::sandboxing::ToolCtx;-use crate::tools::sandboxing::ToolError;-use crate::tools::sandboxing::unsandboxed_execution_allowed;-use codex_execpolicy::Decision;-use codex_execpolicy::Evaluation;-use codex_execpolicy::MatchOptions;-use codex_execpolicy::Policy;-use codex_execpolicy::RuleMatch;-use codex_prompts::ResolvedModelMessages;-use codex_protocol::config_types::WindowsSandboxLevel;-use codex_protocol::error::CodexErr;-use codex_protocol::models::AdditionalPermissionProfile;-use codex_protocol::models::PermissionProfile;-use codex_protocol::protocol::AskForApproval;-use codex_protocol::protocol::GuardianCommandSource;-use codex_protocol::protocol::NetworkPolicyRuleAction;-use codex_protocol::protocol::ReviewDecision;-use codex_sandboxing::SandboxCommand;-use codex_sandboxing::SandboxManager;-use codex_sandboxing::SandboxTransformRequest;-use codex_sandboxing::SandboxType;-use codex_sandboxing::SandboxablePreference;-use codex_shell_command::bash::parse_shell_lc_plain_commands;-use codex_shell_escalation::EscalateServer;-use codex_shell_escalation::EscalationDecision;-use codex_shell_escalation::EscalationExecution;-use codex_shell_escalation::EscalationPermissions;-use codex_shell_escalation::EscalationPolicy;-use codex_shell_escalation::EscalationPolicyFuture;-use codex_shell_escalation::EscalationSession;-use codex_shell_escalation::ExecResult;-use codex_shell_escalation::PreparedExec;-use codex_shell_escalation::ResolvedPermissionProfile;-use codex_shell_escalation::ShellCommandExecutor;-use codex_shell_escalation::ShellCommandExecutorFuture;-use codex_shell_escalation::Stopwatch;-use codex_tools::ToolName;-use codex_utils_absolute_path::AbsolutePathBuf;-use codex_utils_path_uri::PathUri;-use std::collections::HashMap;-use std::io;-use std::path::PathBuf;-use std::sync::Arc;-use tokio::sync::RwLock;-use tokio_util::sync::CancellationToken;-use tracing::error;-use uuid::Uuid;--pub(crate) struct PreparedUnifiedExecZshFork {- pub(crate) exec_request: ExecRequest,- pub(crate) escalation_session: EscalationSession,-}--const PROMPT_CONFLICT_REASON: &str =- "approval required by policy, but AskForApproval is set to Never";-const REJECT_SANDBOX_APPROVAL_REASON: &str =- "approval required by policy, but AskForApproval::Granular.sandbox_approval is false";-const REJECT_RULES_APPROVAL_REASON: &str =- "approval required by policy rule, but AskForApproval::Granular.rules is false";-fn approval_sandbox_permissions(- sandbox_permissions: SandboxPermissions,- additional_permissions_preapproved: bool,-) -> SandboxPermissions {- if additional_permissions_preapproved- && matches!(- sandbox_permissions,- SandboxPermissions::WithAdditionalPermissions- )- {- SandboxPermissions::UseDefault- } else {- sandbox_permissions- }-}--pub(crate) async fn prepare_unified_exec_zsh_fork(- req: &crate::tools::runtimes::unified_exec::UnifiedExecRequest,- attempt: &SandboxAttempt<'_>,- ctx: &ToolCtx,- exec_request: ExecRequest,- shell_zsh_path: &std::path::Path,- main_execve_wrapper_exe: &std::path::Path,-) -> Result<Option<PreparedUnifiedExecZshFork>, ToolError> {- let parsed = match extract_shell_script(&exec_request.command) {- Ok(parsed) => parsed,- Err(err) => {- tracing::warn!("ZshFork unified exec fallback: {err:?}");- return Ok(None);- }- };- if parsed.program != shell_zsh_path.to_string_lossy() {- tracing::warn!(- "ZshFork backend specified, but unified exec command targets `{}` instead of `{}`.",- parsed.program,- shell_zsh_path.display(),- );- return Ok(None);- }-- let exec_policy = Arc::new(RwLock::new(- ctx.session- .services- .exec_policy- .current_for_environment(- req.turn_environment.config().exec_policy.as_ref(),- ctx.step_context.turn.allow_prefix_rules(),- )- .as_ref()- .clone(),- ));- // TODO(anp): Keep PathUri through the zsh-fork executor boundary.- let cwd = exec_request- .cwd- .to_abs_path()- .map_err(|err| ToolError::Rejected(err.to_string()))?;- // TODO(anp): Keep PathUri through the zsh-fork sandbox policy boundary.- let sandbox_policy_cwd = exec_request- .windows_sandbox_policy_cwd- .to_abs_path()- .map_err(|err| ToolError::Rejected(err.to_string()))?;- let command_executor = CoreShellCommandExecutor {- sandbox_manager: attempt.manager.clone(),- command: exec_request.command.clone(),- cwd,- permission_profile: exec_request.permission_profile.clone(),- sandbox: exec_request.sandbox,- env: exec_request.env.clone(),- network: exec_request.network.clone(),- network_environment_id: exec_request.network_environment_id.clone(),- windows_sandbox_level: exec_request.windows_sandbox_level,- arg0: exec_request.arg0.clone(),- sandbox_policy_cwd,- windows_sandbox_workspace_roots: exec_request.windows_sandbox_workspace_roots.clone(),- codex_linux_sandbox_exe: ctx.step_context.turn.config.codex_linux_sandbox_exe.clone(),- use_legacy_landlock: req.turn_environment.config().use_legacy_landlock,- };- let escalation_policy = CoreShellActionProvider {- policy: Arc::clone(&exec_policy),- session: Arc::clone(&ctx.session),- review_context: GuardianReviewContext::from(&ctx.step_context),- call_id: ctx.call_id.clone(),- environment_id: req.turn_environment.selection.environment_id.clone(),- source: GuardianCommandSource::UnifiedExec,- tool_name: ctx.tool_name.clone(),- approval_policy: ctx.step_context.settings.approval_policy(),- permission_profile: exec_request.permission_profile.clone(),- sandbox_permissions: req.sandbox_permissions,- approval_sandbox_permissions: approval_sandbox_permissions(- req.sandbox_permissions,- req.additional_permissions_preapproved,- ),- prompt_permissions: req.additional_permissions.clone(),- stopwatch: Stopwatch::unlimited(),- };-- let escalate_server = EscalateServer::new(- shell_zsh_path.to_path_buf(),- main_execve_wrapper_exe.to_path_buf(),- escalation_policy,- );- let escalation_session = escalate_server- .start_session(CancellationToken::new(), Arc::new(command_executor))- .map_err(|err| ToolError::Rejected(err.to_string()))?;- let mut exec_request = exec_request;- exec_request.env.extend(escalation_session.env().clone());- Ok(Some(PreparedUnifiedExecZshFork {- exec_request,- escalation_session,- }))-}--struct CoreShellActionProvider {- policy: Arc<RwLock<Policy>>,- session: Arc<crate::session::session::Session>,- review_context: GuardianReviewContext,- call_id: String,- environment_id: String,- source: GuardianCommandSource,- tool_name: ToolName,- approval_policy: AskForApproval,- permission_profile: PermissionProfile,- sandbox_permissions: SandboxPermissions,- approval_sandbox_permissions: SandboxPermissions,- prompt_permissions: Option<AdditionalPermissionProfile>,- stopwatch: Stopwatch,-}--#[allow(clippy::large_enum_variant)]-enum DecisionSource {- PrefixRule,- /// Derived from the unmatched-command sandbox fallback.- UnmatchedCommandFallback,-}--fn execve_prompt_is_rejected_by_policy(- approval_policy: AskForApproval,- decision_source: &DecisionSource,-) -> Option<&'static str> {- match (approval_policy, decision_source) {- (AskForApproval::Never, _) => Some(PROMPT_CONFLICT_REASON),- (AskForApproval::Granular(granular_config), DecisionSource::PrefixRule)- if !granular_config.allows_rules_approval() =>- {- Some(REJECT_RULES_APPROVAL_REASON)- }- (AskForApproval::Granular(granular_config), DecisionSource::UnmatchedCommandFallback)- if !granular_config.allows_sandbox_approval() =>- {- Some(REJECT_SANDBOX_APPROVAL_REASON)- }- _ => None,- }-}--impl CoreShellActionProvider {- fn decision_driven_by_policy(matched_rules: &[RuleMatch], decision: Decision) -> bool {- matched_rules.iter().any(|rule_match| {- !matches!(rule_match, RuleMatch::HeuristicsRuleMatch { .. })- && rule_match.decision() == decision- })- }-- fn shell_request_escalation_execution(- sandbox_permissions: SandboxPermissions,- permission_profile: &PermissionProfile,- additional_permissions: Option<&AdditionalPermissionProfile>,- ) -> EscalationExecution {- match sandbox_permissions {- SandboxPermissions::UseDefault => EscalationExecution::TurnDefault,- SandboxPermissions::RequireEscalated => {- if unsandboxed_execution_allowed(&permission_profile.file_system_sandbox_policy()) {- EscalationExecution::Unsandboxed- } else {- EscalationExecution::TurnDefault- }- }- SandboxPermissions::WithAdditionalPermissions => additional_permissions- .map(|_| {- // Shell request additional permissions were already normalized and- // merged into the first-attempt sandbox policy.- EscalationExecution::Permissions(- EscalationPermissions::ResolvedPermissionProfile(- ResolvedPermissionProfile {- permission_profile: permission_profile.clone(),- },- ),- )- })- .unwrap_or(EscalationExecution::TurnDefault),- }- }-- async fn prompt(- &self,- program: &AbsolutePathBuf,- argv: &[String],- workdir: &AbsolutePathBuf,- stopwatch: &Stopwatch,- additional_permissions: Option<AdditionalPermissionProfile>,- ) -> anyhow::Result<ReviewDecision> {- let command = join_program_and_argv(program, argv);- let action = ApprovalAction::Execve {- id: self.call_id.clone(),- approval_id: Uuid::new_v4().to_string(),- environment_id: self.environment_id.clone(),- source: self.source,- program: program.clone(),- argv: argv.to_vec(),- command,- cwd: workdir.clone(),- additional_permissions,- };- match stopwatch- .pause_for(async {- let (turn_context, settings, _, strict_auto_review) = self- .session- .active_turn_context_and_strict_auto_review()- .await- .ok_or_else(|| {- ToolError::Rejected(- "cannot approve intercepted execution without an active turn"- .to_string(),- )- })?;- let approval_ctx = ApprovalContext {- review_context: GuardianReviewContext::from_resolved_settings(- Arc::clone(&turn_context),- &settings,- self.review_context.environments(),- ),- // The running process can outlive its launching tool or code-mode cell.- cancellation_token: None,- call_id: self.call_id.clone(),- tool_name: self.tool_name.clone(),- strict_auto_review,- approval_reason: None,- retry_reason: None,- network_approval_context: None,- };- self.session.request_approval(action, approval_ctx).await- })- .await- {- Ok(decision) => Ok(decision),- Err(ToolError::Rejected(rejection)) => Ok(ReviewDecision::denied(rejection)),- Err(ToolError::Codex(err)) => Err(err.into()),- }- }-- #[allow(clippy::too_many_arguments)]- async fn process_decision(- &self,- decision: Decision,- needs_escalation: bool,- program: &AbsolutePathBuf,- argv: &[String],- workdir: &AbsolutePathBuf,- prompt_permissions: Option<AdditionalPermissionProfile>,- escalation_execution: EscalationExecution,- decision_source: DecisionSource,- ) -> anyhow::Result<EscalationDecision> {- let action = match decision {- Decision::Forbidden => {- EscalationDecision::deny(Some("Execution forbidden by policy".to_string()))- }- Decision::Prompt => {- if execve_prompt_is_rejected_by_policy(self.approval_policy, &decision_source)- .is_some()- {- EscalationDecision::deny(Some("Execution forbidden by policy".to_string()))- } else {- let decision = self- .prompt(program, argv, workdir, &self.stopwatch, prompt_permissions)- .await?;- match decision {- ReviewDecision::Approved- | ReviewDecision::ApprovedForSession- | ReviewDecision::ApprovedExecpolicyAmendment { .. } => {- if needs_escalation {- EscalationDecision::escalate(escalation_execution.clone())- } else {- EscalationDecision::run()- }- }- ReviewDecision::NetworkPolicyAmendment {- network_policy_amendment,- } => match network_policy_amendment.action {- NetworkPolicyRuleAction::Allow => {- if needs_escalation {- EscalationDecision::escalate(escalation_execution.clone())- } else {- EscalationDecision::run()- }- }- NetworkPolicyRuleAction::Deny => {- EscalationDecision::deny(Some("User denied execution".to_string()))- }- },- ReviewDecision::Denied { rejection } => {- EscalationDecision::deny(Some(rejection))- }- ReviewDecision::TimedOut => EscalationDecision::deny(Some(- ResolvedModelMessages::from_model(- self.review_context.turn().model_info(),- )- .auto_review()- .timeout_instructions- .to_string(),- )),- ReviewDecision::ApprovedMcpPolicyAmendment => {- error!("Shell escalation received ApprovedMcpPolicyAmendment");-- EscalationDecision::deny(Some(- "Error while requesting approval".to_string(),- ))- }- ReviewDecision::Abort => {- EscalationDecision::deny(Some("User cancelled execution".to_string()))- }- }- }- }- Decision::Allow => {- if needs_escalation {- EscalationDecision::escalate(escalation_execution)- } else {- EscalationDecision::run()- }- }- };- tracing::debug!(- "Policy decision for command {program:?} is {decision:?}, leading to escalation action {action:?}",- );- Ok(action)- }-}--// Shell-wrapper parsing is weaker than direct exec interception because it can-// only see the script text, not the final resolved executable path. Keep it-// disabled by default so path-sensitive rules rely on the later authoritative-// execve interception.-const ENABLE_INTERCEPTED_EXEC_POLICY_SHELL_WRAPPER_PARSING: bool = false;--impl CoreShellActionProvider {- async fn determine_action(- &self,- program: &AbsolutePathBuf,- argv: &[String],- workdir: &AbsolutePathBuf,- ) -> anyhow::Result<EscalationDecision> {- tracing::debug!(- "Determining escalation action for command {program:?} with args {argv:?} in {workdir:?}"- );-- let evaluation = {- let policy = self.policy.read().await;- evaluate_intercepted_exec_policy(- &policy,- program,- argv,- InterceptedExecPolicyContext {- approval_policy: self.approval_policy,- permission_profile: self.permission_profile.clone(),- windows_sandbox_level: self.review_context.turn().windows_sandbox_level,- sandbox_permissions: self.approval_sandbox_permissions,- enable_shell_wrapper_parsing:- ENABLE_INTERCEPTED_EXEC_POLICY_SHELL_WRAPPER_PARSING,- },- )- };- // When true, means the Evaluation was due to *.rules, not the- // fallback function.- let decision_driven_by_policy =- Self::decision_driven_by_policy(&evaluation.matched_rules, evaluation.decision);- let unsandboxed_allowed =- unsandboxed_execution_allowed(&self.permission_profile.file_system_sandbox_policy());- let needs_escalation = match self.sandbox_permissions {- SandboxPermissions::UseDefault => unsandboxed_allowed && decision_driven_by_policy,- SandboxPermissions::RequireEscalated => unsandboxed_allowed,- SandboxPermissions::WithAdditionalPermissions => true,- };-- let decision_source = if decision_driven_by_policy {- DecisionSource::PrefixRule- } else {- DecisionSource::UnmatchedCommandFallback- };- let escalation_execution = match decision_source {- DecisionSource::PrefixRule if unsandboxed_allowed => EscalationExecution::Unsandboxed,- DecisionSource::PrefixRule => EscalationExecution::TurnDefault,- DecisionSource::UnmatchedCommandFallback => Self::shell_request_escalation_execution(- self.sandbox_permissions,- &self.permission_profile,- self.prompt_permissions.as_ref(),- ),- };- self.process_decision(- evaluation.decision,- needs_escalation,- program,- argv,- workdir,- self.prompt_permissions.clone(),- escalation_execution,- decision_source,- )- .await- }-}--impl EscalationPolicy for CoreShellActionProvider {- fn determine_action<'a>(- &'a self,- program: &'a AbsolutePathBuf,- argv: &'a [String],- workdir: &'a AbsolutePathBuf,- ) -> EscalationPolicyFuture<'a> {- Box::pin(CoreShellActionProvider::determine_action(- self, program, argv, workdir,- ))- }-}--fn evaluate_intercepted_exec_policy(- policy: &Policy,- program: &AbsolutePathBuf,- argv: &[String],- context: InterceptedExecPolicyContext,-) -> Evaluation {- let InterceptedExecPolicyContext {- approval_policy,- permission_profile,- windows_sandbox_level,- sandbox_permissions,- enable_shell_wrapper_parsing,- } = context;- let commands = if enable_shell_wrapper_parsing {- // In this codepath, the first argument in `commands` could be a bare- // name like `find` instead of an absolute path like `/usr/bin/find`.- // It could also be a shell built-in like `echo`.- commands_for_intercepted_exec_policy(program, argv)- } else {- // In this codepath, `commands` has a single entry where the program- // is always an absolute path.- vec![join_program_and_argv(program, argv)]- };-- let fallback = |cmd: &[String]| {- crate::exec_policy::render_decision_for_unmatched_command(- cmd,- crate::exec_policy::UnmatchedCommandContext {- approval_policy,- permission_profile: &permission_profile,- windows_sandbox_level,- sandbox_permissions,- command_origin: crate::exec_policy::ExecPolicyCommandOrigin::Generic,- },- )- };-- policy.check_multiple_with_options(- commands.iter(),- &fallback,- &MatchOptions {- resolve_host_executables: true,- },- )-}--#[derive(Clone)]-struct InterceptedExecPolicyContext {- approval_policy: AskForApproval,- permission_profile: PermissionProfile,- // TODO(anp): Reconcile this policy input with TurnEnvironment::sandbox_context- // so intercepted commands use the selected environment's Windows backend.- windows_sandbox_level: WindowsSandboxLevel,- sandbox_permissions: SandboxPermissions,- enable_shell_wrapper_parsing: bool,-}--fn commands_for_intercepted_exec_policy(- program: &AbsolutePathBuf,- argv: &[String],-) -> Vec<Vec<String>> {- if let [_, flag, script] = argv {- let shell_command = [- program.to_string_lossy().to_string(),- flag.clone(),- script.clone(),- ];- if let Some(commands) = parse_shell_lc_plain_commands(&shell_command)- && !commands.is_empty()- {- return commands;- }- }-- vec![join_program_and_argv(program, argv)]-}--// TODO(anp): Capture these Windows and Landlock settings from-// TurnEnvironment::sandbox_context when preparing this executor, preserving its snapshot.-struct CoreShellCommandExecutor {- sandbox_manager: SandboxManager,- command: Vec<String>,- cwd: AbsolutePathBuf,- permission_profile: PermissionProfile,- sandbox: SandboxType,- env: HashMap<String, String>,- network: Option<codex_network_proxy::NetworkProxy>,- network_environment_id: Option<String>,- windows_sandbox_level: WindowsSandboxLevel,- arg0: Option<String>,- sandbox_policy_cwd: AbsolutePathBuf,- windows_sandbox_workspace_roots: Vec<AbsolutePathBuf>,- codex_linux_sandbox_exe: Option<PathBuf>,- use_legacy_landlock: bool,-}--struct PrepareSandboxedExecParams<'a> {- command: Vec<String>,- workdir: &'a AbsolutePathBuf,- env: HashMap<String, String>,- permission_profile: &'a PermissionProfile,- additional_permissions: Option<AdditionalPermissionProfile>,-}--impl ShellCommandExecutor for CoreShellCommandExecutor {- fn run(- &self,- _command: Vec<String>,- _cwd: PathBuf,- env_overlay: HashMap<String, String>,- cancel_rx: CancellationToken,- after_spawn: Option<Box<dyn FnOnce() + Send>>,- ) -> ShellCommandExecutorFuture<'_, ExecResult> {- Box::pin(CoreShellCommandExecutor::run(- self,- env_overlay,- cancel_rx,- after_spawn,- ))- }-- fn prepare_escalated_exec<'a>(- &'a self,- program: &'a AbsolutePathBuf,- argv: &'a [String],- workdir: &'a AbsolutePathBuf,- env: HashMap<String, String>,- execution: EscalationExecution,- ) -> ShellCommandExecutorFuture<'a, PreparedExec> {- Box::pin(CoreShellCommandExecutor::prepare_escalated_exec(- self, program, argv, workdir, env, execution,- ))- }-}--impl CoreShellCommandExecutor {- async fn run(- &self,- env_overlay: HashMap<String, String>,- cancel_rx: CancellationToken,- after_spawn: Option<Box<dyn FnOnce() + Send>>,- ) -> anyhow::Result<ExecResult> {- let mut exec_env = self.env.clone();- // `env_overlay` comes from `EscalationSession::env()`, so merge only the- // wrapper/socket variables into the base shell environment.- for var in ["CODEX_ESCALATE_SOCKET", "EXEC_WRAPPER"] {- if let Some(value) = env_overlay.get(var) {- exec_env.insert(var.to_string(), value.clone());- }- }-- let result = crate::sandboxing::execute_exec_request_with_after_spawn(- crate::sandboxing::ExecRequest {- command: self.command.clone(),- cwd: self.cwd.clone().into(),- env: exec_env,- exec_server_env_config: None,- exec_server_shell_snapshot: None,- network: self.network.clone(),- network_environment_id: self.network_environment_id.clone(),- expiration: ExecExpiration::Cancellation(cancel_rx),- capture_policy: ExecCapturePolicy::ShellTool,- sandbox: self.sandbox,- windows_sandbox_policy_cwd: self.sandbox_policy_cwd.clone().into(),- windows_sandbox_workspace_roots: self.windows_sandbox_workspace_roots.clone(),- windows_sandbox_level: self.windows_sandbox_level,- permission_profile: self.permission_profile.clone(),- windows_sandbox_filesystem_overrides: None,- arg0: self.arg0.clone(),- exec_server_sandbox: None,- exec_server_enforce_managed_network: false,- exec_server_managed_network: None,- exec_server_network_proxy: None,- },- /*stdout_stream*/ None,- after_spawn,- )- .await?;-- Ok(ExecResult {- exit_code: result.exit_code,- stdout: result.stdout.text,- stderr: result.stderr.text,- output: result.aggregated_output.text,- duration: result.duration,- timed_out: result.timed_out,- })- }-- async fn prepare_escalated_exec(- &self,- program: &AbsolutePathBuf,- argv: &[String],- workdir: &AbsolutePathBuf,- mut env: HashMap<String, String>,- execution: EscalationExecution,- ) -> anyhow::Result<PreparedExec> {- let command = join_program_and_argv(program, argv);- let Some(first_arg) = argv.first() else {- return Err(anyhow::anyhow!(- "intercepted exec request must contain argv[0]"- ));- };-- let prepared = match execution {- EscalationExecution::Unsandboxed => {- if let Some(network) = self.network.as_ref() {- network.restore_brokered_credentials(&mut env, &mut []);- }- PreparedExec {- command,- cwd: workdir.to_path_buf(),- env: exec_env_for_sandbox_permissions(- &env,- SandboxPermissions::RequireEscalated,- ),- arg0: Some(first_arg.clone()),- }- }- EscalationExecution::TurnDefault => {- self.prepare_sandboxed_exec(PrepareSandboxedExecParams {- command,- workdir,- env,- permission_profile: &self.permission_profile,- additional_permissions: None,- })- .await?- }- EscalationExecution::Permissions(- EscalationPermissions::AdditionalPermissionProfile(permission_profile),- ) => {- // Merge additive permissions into the existing turn/request sandbox policy.- self.prepare_sandboxed_exec(PrepareSandboxedExecParams {- command,- workdir,- env,- permission_profile: &self.permission_profile,- additional_permissions: Some(permission_profile),- })- .await?- }- EscalationExecution::Permissions(EscalationPermissions::ResolvedPermissionProfile(- permissions,- )) => {- // Use a fully specified permission profile instead of merging into the turn policy.- self.prepare_sandboxed_exec(PrepareSandboxedExecParams {- command,- workdir,- env,- permission_profile: &permissions.permission_profile,- additional_permissions: None,- })- .await?- }- };-- Ok(prepared)- }-- #[allow(clippy::too_many_arguments)]- async fn prepare_sandboxed_exec(- &self,- params: PrepareSandboxedExecParams<'_>,- ) -> anyhow::Result<PreparedExec> {- let PrepareSandboxedExecParams {- command,- workdir,- env,- permission_profile,- additional_permissions,- } = params;- let (program, args) = command- .split_first()- .ok_or_else(|| anyhow::anyhow!("prepared command must not be empty"))?;- let sandbox_manager = &self.sandbox_manager;- let sandbox = sandbox_manager.select_initial(- permission_profile,- SandboxablePreference::Auto,- SandboxType::None,- self.network.is_some(),- );- let cwd = PathUri::from_abs_path(workdir);- let sandbox_policy_cwd = PathUri::from_abs_path(&self.sandbox_policy_cwd);- let command = SandboxCommand {- program: program.clone().into(),- args: args.to_vec(),- cwd,- env,- managed_network: None,- additional_permissions,- };- let options = ExecOptions {- expiration: ExecExpiration::DefaultTimeout,- capture_policy: ExecCapturePolicy::ShellTool,- };- let exec_request = sandbox_manager.transform(SandboxTransformRequest {- command,- permissions: permission_profile,- sandbox,- enforce_managed_network: self.network.is_some(),- environment_id: self.network_environment_id.as_deref(),- network: self.network.as_ref(),- sandbox_policy_cwd: &sandbox_policy_cwd,- sandbox_exe: self.codex_linux_sandbox_exe.as_deref(),- use_legacy_landlock: self.use_legacy_landlock,- windows_sandbox_level: self.windows_sandbox_level,- })?;- let mut exec_request = crate::sandboxing::ExecRequest::from_sandbox_exec_request(- exec_request,- options,- self.windows_sandbox_workspace_roots.clone(),- )- .await?;- if let Some(network) = exec_request.network.as_ref() {- network- .apply_to_env_for_optional_environment(- &mut exec_request.env,- self.network_environment_id.as_deref(),- )- .map_err(|err| {- let environment_id =- self.network_environment_id.as_deref().unwrap_or("default");- CodexErr::Io(io::Error::other(format!(- "failed to prepare network proxy for environment `{environment_id}`: {err}"- )))- })?;- }-- Ok(PreparedExec {- command: exec_request.command,- // TODO(anp): Keep PathUri through the execve-wrapper boundary.- cwd: exec_request.cwd.to_abs_path()?.to_path_buf(),- env: exec_request.env,- arg0: exec_request.arg0,- })- }-}--#[derive(Debug, Eq, PartialEq)]-struct ParsedShellCommand {- program: String,- script: String,- login: bool,-}--fn extract_shell_script(command: &[String]) -> Result<ParsedShellCommand, ToolError> {- // Commands reaching zsh-fork can be wrapped by environment/sandbox helpers, so- // we search for the first `-c`/`-lc` triple anywhere in the argv rather- // than assuming it is the first positional form.- if let Some((program, script, login)) = command.windows(3).find_map(|parts| match parts {- [program, flag, script] if flag == "-c" => {- Some((program.to_owned(), script.to_owned(), false))- }- [program, flag, script] if flag == "-lc" => {- Some((program.to_owned(), script.to_owned(), true))- }- _ => None,- }) {- return Ok(ParsedShellCommand {- program,- script,- login,- });- }-- Err(ToolError::Rejected(- "unexpected shell command format for zsh-fork execution".to_string(),- ))-}--/// Convert an intercepted exec `(program, argv)` into a command vector suitable-/// for display and policy parsing.-///-/// The intercepted `argv` includes `argv[0]`, but once we have normalized the-/// executable path in `program`, we should replace the original `argv[0]`-/// rather than duplicating it as an apparent user argument.-fn join_program_and_argv(program: &AbsolutePathBuf, argv: &[String]) -> Vec<String> {- std::iter::once(program.to_string_lossy().to_string())- .chain(argv.iter().skip(1).cloned())- .collect::<Vec<_>>()-}--#[cfg(test)]-#[path = "unix_escalation_tests.rs"]-mod tests;diff --git a/codex-rs/core/src/tools/runtimes/zsh_fork/unix_escalation_tests.rs b/codex-rs/core/src/tools/runtimes/zsh_fork/unix_escalation_tests.rsdeleted file mode 100644index ca282cd696..0000000000--- a/codex-rs/core/src/tools/runtimes/zsh_fork/unix_escalation_tests.rs+++ /dev/null@@ -1,967 +0,0 @@-use super::CoreShellActionProvider;-use super::CoreShellCommandExecutor;-use super::InterceptedExecPolicyContext;-use super::ParsedShellCommand;-use super::commands_for_intercepted_exec_policy;-use super::evaluate_intercepted_exec_policy;-use super::extract_shell_script;-use super::join_program_and_argv;-use crate::config::Constrained;-use crate::guardian::GuardianReviewContext;-use crate::sandboxing::SandboxPermissions;-use crate::session::tests::make_session_and_context;-use crate::tools::runtimes::tests::test_credential_broker_network_proxy;-use anyhow::Context;-use codex_execpolicy::Decision;-use codex_execpolicy::Evaluation;-use codex_execpolicy::PolicyParser;-use codex_execpolicy::RuleMatch;-use codex_hooks::HooksConfig;-use codex_network_proxy::PROXY_ACTIVE_ENV_KEY;-use codex_network_proxy::PROXY_ENV_KEYS;-use codex_protocol::config_types::WindowsSandboxLevel;-use codex_protocol::models::AdditionalPermissionProfile;-use codex_protocol::models::FileSystemPermissions;-use codex_protocol::models::PermissionProfile;-use codex_protocol::permissions::FileSystemAccessMode;-use codex_protocol::permissions::FileSystemPath;-use codex_protocol::permissions::FileSystemSandboxEntry;-use codex_protocol::permissions::FileSystemSandboxPolicy;-use codex_protocol::permissions::FileSystemSpecialPath;-use codex_protocol::permissions::NetworkSandboxPolicy;-use codex_protocol::protocol::AskForApproval;-use codex_protocol::protocol::GranularApprovalConfig;-use codex_protocol::protocol::GuardianCommandSource;-use codex_sandboxing::SandboxType;-use codex_sandboxing::policy_transforms::effective_permission_profile;-use codex_shell_escalation::EscalationExecution;-use codex_shell_escalation::EscalationPermissions;-use codex_shell_escalation::ResolvedPermissionProfile;-use codex_tools::ToolName;-use codex_utils_absolute_path::AbsolutePathBuf;-use pretty_assertions::assert_eq;-use serde_json::Value;-use std::collections::HashMap;-use std::path::PathBuf;-use std::sync::Arc;-use std::time::Duration;-use tokio::sync::RwLock;--fn host_absolute_path(segments: &[&str]) -> String {- let mut path = if cfg!(windows) {- PathBuf::from(r"C:\")- } else {- PathBuf::from("/")- };- for segment in segments {- path.push(segment);- }- path.to_string_lossy().into_owned()-}--fn starlark_string(value: &str) -> String {- value.replace('\\', "\\\\").replace('"', "\\\"")-}--fn read_only_file_system_sandbox_policy() -> FileSystemSandboxPolicy {- FileSystemSandboxPolicy::restricted(vec![FileSystemSandboxEntry {- path: FileSystemPath::Special {- value: FileSystemSpecialPath::Root,- },- access: FileSystemAccessMode::Read,- missing_path_behavior: None,- }])-}--fn denied_read_file_system_sandbox_policy() -> FileSystemSandboxPolicy {- FileSystemSandboxPolicy::restricted(vec![- FileSystemSandboxEntry {- path: FileSystemPath::Special {- value: FileSystemSpecialPath::Root,- },- access: FileSystemAccessMode::Read,- missing_path_behavior: None,- },- FileSystemSandboxEntry {- path: FileSystemPath::GlobPattern {- pattern: "**/*.env".to_string(),- },- access: FileSystemAccessMode::Deny,- missing_path_behavior: None,- },- ])-}--fn test_sandbox_cwd() -> AbsolutePathBuf {- AbsolutePathBuf::try_from(host_absolute_path(&["workspace"])).unwrap()-}--#[test]-fn execve_prompt_rejection_keeps_prefix_rules_on_rules_flag() {- assert_eq!(- super::execve_prompt_is_rejected_by_policy(- AskForApproval::Granular(GranularApprovalConfig {- sandbox_approval: true,- rules: false,- skill_approval: true,- request_permissions: true,- mcp_elicitations: true,- }),- &super::DecisionSource::PrefixRule,- ),- Some("approval required by policy rule, but AskForApproval::Granular.rules is false"),- );-}--#[test]-fn execve_prompt_rejection_keeps_unmatched_commands_on_sandbox_flag() {- assert_eq!(- super::execve_prompt_is_rejected_by_policy(- AskForApproval::Granular(GranularApprovalConfig {- sandbox_approval: false,- rules: true,- skill_approval: true,- request_permissions: true,- mcp_elicitations: true,- }),- &super::DecisionSource::UnmatchedCommandFallback,- ),- Some("approval required by policy, but AskForApproval::Granular.sandbox_approval is false"),- );-}--#[test]-fn approval_sandbox_permissions_only_downgrades_preapproved_additional_permissions() {- assert_eq!(- super::approval_sandbox_permissions(- SandboxPermissions::WithAdditionalPermissions,- /*additional_permissions_preapproved*/ true- ),- SandboxPermissions::UseDefault,- );- assert_eq!(- super::approval_sandbox_permissions(- SandboxPermissions::WithAdditionalPermissions,- /*additional_permissions_preapproved*/ false- ),- SandboxPermissions::WithAdditionalPermissions,- );- assert_eq!(- super::approval_sandbox_permissions(- SandboxPermissions::RequireEscalated,- /*additional_permissions_preapproved*/ true- ),- SandboxPermissions::RequireEscalated,- );-}--#[test]-fn extract_shell_script_preserves_login_flag() {- assert_eq!(- extract_shell_script(&["/bin/zsh".into(), "-lc".into(), "echo hi".into()]).unwrap(),- ParsedShellCommand {- program: "/bin/zsh".to_string(),- script: "echo hi".to_string(),- login: true,- }- );- assert_eq!(- extract_shell_script(&["/bin/zsh".into(), "-c".into(), "echo hi".into()]).unwrap(),- ParsedShellCommand {- program: "/bin/zsh".to_string(),- script: "echo hi".to_string(),- login: false,- }- );-}--#[test]-fn extract_shell_script_supports_wrapped_command_prefixes() {- assert_eq!(- extract_shell_script(&[- "/usr/bin/env".into(),- "CODEX_EXECVE_WRAPPER=1".into(),- "/bin/zsh".into(),- "-lc".into(),- "echo hello".into()- ])- .unwrap(),- ParsedShellCommand {- program: "/bin/zsh".to_string(),- script: "echo hello".to_string(),- login: true,- }- );-- assert_eq!(- extract_shell_script(&[- "sandbox-exec".into(),- "-p".into(),- "sandbox_policy".into(),- "/bin/zsh".into(),- "-c".into(),- "pwd".into(),- ])- .unwrap(),- ParsedShellCommand {- program: "/bin/zsh".to_string(),- script: "pwd".to_string(),- login: false,- }- );-}--#[test]-fn extract_shell_script_rejects_unsupported_shell_invocation() {- let err = extract_shell_script(&[- "sandbox-exec".into(),- "-fc".into(),- "echo not supported".into(),- ])- .unwrap_err();- assert!(matches!(err, super::ToolError::Rejected(_)));- assert_eq!(- match err {- super::ToolError::Rejected(reason) => reason,- _ => "".to_string(),- },- "unexpected shell command format for zsh-fork execution"- );-}--#[test]-fn join_program_and_argv_replaces_original_argv_zero() {- assert_eq!(- join_program_and_argv(- &AbsolutePathBuf::from_absolute_path("/tmp/tool").unwrap(),- &["./tool".into(), "--flag".into(), "value".into()],- ),- vec!["/tmp/tool", "--flag", "value"]- );- assert_eq!(- join_program_and_argv(- &AbsolutePathBuf::from_absolute_path("/tmp/tool").unwrap(),- &["./tool".into()]- ),- vec!["/tmp/tool"]- );-}--#[test]-fn commands_for_intercepted_exec_policy_parses_plain_shell_wrappers() {- let program = AbsolutePathBuf::try_from(host_absolute_path(&["bin", "bash"])).unwrap();- let candidate_commands = commands_for_intercepted_exec_policy(- &program,- &["not-bash".into(), "-lc".into(), "git status && pwd".into()],- );-- assert_eq!(- candidate_commands,- vec![- vec!["git".to_string(), "status".to_string()],- vec!["pwd".to_string()],- ]- );-}--#[test]-fn commands_for_intercepted_exec_policy_preserves_unparsed_shell_wrappers() {- let program = AbsolutePathBuf::try_from(host_absolute_path(&["bin", "bash"])).unwrap();- for script in ["", " \n\t", "cat <<'EOF'\nhello\nEOF"] {- let argv = ["not-bash".into(), "-lc".into(), script.into()];- assert_eq!(- commands_for_intercepted_exec_policy(&program, &argv),- vec![join_program_and_argv(&program, &argv)]- );- }-}--#[test]-fn shell_request_escalation_execution_is_explicit() {- let requested_permissions = AdditionalPermissionProfile {- file_system: Some(FileSystemPermissions::from_read_write_roots(- /*read*/ None,- Some(vec![- AbsolutePathBuf::from_absolute_path("/tmp/output").unwrap(),- ]),- )),- ..Default::default()- };- let file_system_sandbox_policy = FileSystemSandboxPolicy::restricted(vec![- FileSystemSandboxEntry {- path: FileSystemPath::Path {- path: AbsolutePathBuf::from_absolute_path("/tmp/original/output")- .unwrap()- .into(),- },- access: FileSystemAccessMode::Write,- missing_path_behavior: None,- },- FileSystemSandboxEntry {- path: FileSystemPath::Path {- path: AbsolutePathBuf::from_absolute_path("/tmp/secret")- .unwrap()- .into(),- },- access: FileSystemAccessMode::Deny,- missing_path_behavior: None,- },- ]);- let network_sandbox_policy = NetworkSandboxPolicy::Restricted;- let permission_profile = PermissionProfile::from_runtime_permissions(- &file_system_sandbox_policy,- network_sandbox_policy,- );- let read_only_permission_profile = PermissionProfile::from_runtime_permissions(- &read_only_file_system_sandbox_policy(),- network_sandbox_policy,- );-- assert_eq!(- CoreShellActionProvider::shell_request_escalation_execution(- crate::sandboxing::SandboxPermissions::UseDefault,- &permission_profile,- /*additional_permissions*/ None,- ),- EscalationExecution::TurnDefault,- );- assert_eq!(- CoreShellActionProvider::shell_request_escalation_execution(- crate::sandboxing::SandboxPermissions::RequireEscalated,- &read_only_permission_profile,- /*additional_permissions*/ None,- ),- EscalationExecution::Unsandboxed,- );- assert_eq!(- CoreShellActionProvider::shell_request_escalation_execution(- crate::sandboxing::SandboxPermissions::RequireEscalated,- &permission_profile,- /*additional_permissions*/ None,- ),- EscalationExecution::TurnDefault,- );- assert_eq!(- CoreShellActionProvider::shell_request_escalation_execution(- crate::sandboxing::SandboxPermissions::WithAdditionalPermissions,- &permission_profile,- Some(&requested_permissions),- ),- EscalationExecution::Permissions(EscalationPermissions::ResolvedPermissionProfile(- ResolvedPermissionProfile { permission_profile },- )),- );-}--#[tokio::test]-async fn unsandboxed_intercepted_exec_strips_managed_network_env() -> anyhow::Result<()> {- let workdir = test_sandbox_cwd();- let network = test_credential_broker_network_proxy().await?;- let executor = CoreShellCommandExecutor {- sandbox_manager: codex_sandboxing::SandboxManager::new(),- command: Vec::new(),- cwd: workdir.clone(),- permission_profile: PermissionProfile::workspace_write(),- sandbox: SandboxType::None,- env: HashMap::new(),- network: Some(network.clone()),- network_environment_id: None,- windows_sandbox_level: WindowsSandboxLevel::Disabled,- arg0: None,- sandbox_policy_cwd: workdir.clone(),- windows_sandbox_workspace_roots: vec![workdir.clone()],- codex_linux_sandbox_exe: None,- use_legacy_landlock: false,- };- let mut env = HashMap::new();- env.insert("GH_TOKEN".to_string(), "ghp-real".to_string());- env.insert(PROXY_ACTIVE_ENV_KEY.to_string(), "1".to_string());- for key in PROXY_ENV_KEYS {- env.insert((*key).to_string(), format!("proxy-{key}"));- }- network.apply_to_env(&mut env);- assert_ne!(env.get("GH_TOKEN").map(String::as_str), Some("ghp-real"));- let dummy = env.get("GH_TOKEN").expect("brokered token").clone();-- let prepared = executor- .prepare_escalated_exec(- &AbsolutePathBuf::from_absolute_path("/usr/bin/curl")?,- &[- "curl".to_string(),- "-H".to_string(),- format!("Authorization: Bearer {dummy}"),- "example.com".to_string(),- ],- &workdir,- env,- EscalationExecution::Unsandboxed,- )- .await?;-- assert!(- !prepared.env.contains_key(PROXY_ACTIVE_ENV_KEY),- "unsandboxed intercepted exec should strip the managed-network active marker"- );- for key in PROXY_ENV_KEYS {- assert!(- !prepared.env.contains_key(*key),- "unsandboxed intercepted exec should strip managed-network proxy env var {key}"- );- }- assert_eq!(- prepared.env.get("GH_TOKEN").map(String::as_str),- Some("ghp-real")- );- assert_eq!(- prepared.command,- vec![- "/usr/bin/curl".to_string(),- "-H".to_string(),- format!("Authorization: Bearer {dummy}"),- "example.com".to_string(),- ]- );-- Ok(())-}--#[tokio::test]-async fn preapproved_additional_permissions_escalate_intercepted_exec() -> anyhow::Result<()> {- let (session, turn_context) = make_session_and_context().await;- let requested_permissions = AdditionalPermissionProfile {- file_system: Some(FileSystemPermissions::from_read_write_roots(- /*read*/ None,- Some(vec![- AbsolutePathBuf::from_absolute_path("/tmp/output").unwrap(),- ]),- )),- ..Default::default()- };- let workdir = test_sandbox_cwd();- let permission_profile = effective_permission_profile(- &PermissionProfile::workspace_write(),- Some(&requested_permissions),- );- let provider = CoreShellActionProvider {- policy: Arc::new(RwLock::new(codex_execpolicy::Policy::empty())),- session: Arc::new(session),- review_context: GuardianReviewContext::from(Arc::new(turn_context)),- call_id: "preapproved-additional-permissions".to_string(),- environment_id: "local".to_string(),- source: GuardianCommandSource::UnifiedExec,- tool_name: ToolName::plain("exec_command"),- approval_policy: AskForApproval::OnRequest,- permission_profile: permission_profile.clone(),- sandbox_permissions: SandboxPermissions::WithAdditionalPermissions,- approval_sandbox_permissions: SandboxPermissions::UseDefault,- prompt_permissions: Some(requested_permissions),- stopwatch: codex_shell_escalation::Stopwatch::new(Duration::from_secs(1)),- };-- let action = codex_shell_escalation::EscalationPolicy::determine_action(- &provider,- &AbsolutePathBuf::from_absolute_path("/usr/bin/printf")?,- &["printf".to_string(), "hello".to_string()],- &workdir,- )- .await?;-- let expected = codex_shell_escalation::EscalationDecision::Escalate(- EscalationExecution::Permissions(EscalationPermissions::ResolvedPermissionProfile(- ResolvedPermissionProfile { permission_profile },- )),- );- assert_eq!(- action, expected,- "preapproved with_additional_permissions should escalate through the resolved permission profile"- );-- Ok(())-}--#[tokio::test(flavor = "current_thread")]-async fn execve_permission_request_hook_short_circuits_prompt() -> anyhow::Result<()> {- let (session, mut turn_context) = make_session_and_context().await;- std::fs::create_dir_all(&turn_context.config.codex_home)- .context("recreate codex home for hook fixtures")?;- let script_path = turn_context- .config- .codex_home- .join("permission_request_hook.py");- let log_path = turn_context- .config- .codex_home- .join("permission_request_hook_log.jsonl");- codex_utils_cargo_bin::write_executable(- &script_path,- &format!(- "#!/bin/sh\ncat > {log_path}\nprintf '%s\\n' '{response}'\n",- log_path = shlex::try_quote(log_path.to_string_lossy().as_ref())?,- response = "{\"hookSpecificOutput\":{\"hookEventName\":\"PermissionRequest\",\"decision\":{\"behavior\":\"allow\"}}}",- ),- )- .with_context(|| format!("write hook script to {}", script_path.display()))?;- std::fs::write(- turn_context.config.codex_home.join("hooks.json"),- serde_json::json!({- "hooks": {- "PermissionRequest": [{- "hooks": [{- "type": "command",- "command": script_path.display().to_string(),- }]- }]- }- })- .to_string(),- )- .context("write hooks.json")?;- let config_toml_path = turn_context- .config- .codex_home- .join(codex_config::CONFIG_TOML_FILE);- let hook_list = codex_hooks::list_hooks(HooksConfig {- feature_enabled: true,- config_layer_stack: Some(turn_context.config.config_layer_stack.clone()),- ..HooksConfig::default()- });- assert_eq!(hook_list.hooks.len(), 1);- let trusted_config_layer_stack = turn_context.config.config_layer_stack.with_user_config(- &config_toml_path,- serde_json::from_value(serde_json::json!({- "hooks": {- "state": {- hook_list.hooks[0].key.clone(): {- "trusted_hash": hook_list.hooks[0].current_hash.clone(),- },- },- },- }))- .context("build trusted hook state")?,- )?;-- let mut hook_shell_argv = session- .user_shell()- .derive_exec_args("", /*use_login_shell*/ false);- let hook_shell_program = hook_shell_argv.remove(0);- let _ = hook_shell_argv.pop();- let hooks = session.hooks().reconfigured(HooksConfig {- feature_enabled: true,- config_layer_stack: Some(trusted_config_layer_stack),- shell_program: Some(hook_shell_program),- shell_args: hook_shell_argv,- ..HooksConfig::default()- });- session.services.hooks.store(Arc::new(hooks));-- Arc::make_mut(&mut turn_context.config)- .permissions- .approval_policy = Constrained::allow_any(AskForApproval::OnRequest);- Arc::make_mut(&mut turn_context.config)- .permissions- .set_permission_profile(PermissionProfile::from_runtime_permissions(- &read_only_file_system_sandbox_policy(),- NetworkSandboxPolicy::Restricted,- ))- .expect("test setup should allow updating permission profile");- let workdir = AbsolutePathBuf::try_from(std::env::current_dir()?)?;- let target = std::env::temp_dir().join("execve-hook-short-circuit.txt");- let target_str = target.display().to_string();- let command = vec!["touch".to_string(), target_str.clone()];- let expected_hook_command =- codex_shell_command::parse_command::shlex_join(&["/usr/bin/touch".to_string(), target_str]);-- struct PendingApprovalTask;-- impl crate::tasks::SessionTask for PendingApprovalTask {- fn kind(&self) -> crate::state::TaskKind {- crate::state::TaskKind::Regular- }-- fn span_name(&self) -> &'static str {- "session_task.pending_execve_approval"- }-- async fn run(- self: Arc<Self>,- _session: Arc<crate::session::session::Session>,- _turn_context: Arc<crate::session::turn_context::TurnContext>,- _input: Vec<crate::session::TurnInput>,- cancellation_token: tokio_util::sync::CancellationToken,- ) -> crate::tasks::SessionTaskResult {- cancellation_token.cancelled().await;- Ok(None)- }- }-- let session = Arc::new(session);- let turn_context = Arc::new(turn_context);- session- .spawn_task(Arc::clone(&turn_context), Vec::new(), PendingApprovalTask)- .await;- let provider = CoreShellActionProvider {- policy: std::sync::Arc::new(RwLock::new(codex_execpolicy::Policy::empty())),- session: Arc::clone(&session),- review_context: GuardianReviewContext::from(turn_context),- call_id: "execve-hook-call".to_string(),- environment_id: "local".to_string(),- source: GuardianCommandSource::UnifiedExec,- tool_name: ToolName::plain("exec_command"),- approval_policy: AskForApproval::OnRequest,- permission_profile: PermissionProfile::read_only(),- sandbox_permissions: SandboxPermissions::RequireEscalated,- approval_sandbox_permissions: SandboxPermissions::RequireEscalated,- prompt_permissions: None,- stopwatch: codex_shell_escalation::Stopwatch::new(Duration::from_secs(1)),- };-- let action = tokio::time::timeout(- Duration::from_secs(5),- codex_shell_escalation::EscalationPolicy::determine_action(- &provider,- &AbsolutePathBuf::from_absolute_path("/usr/bin/touch")- .context("build touch absolute path")?,- &command,- &workdir,- ),- )- .await- .context("timed out waiting for execve permission hook decision")??;- assert!(matches!(- action,- codex_shell_escalation::EscalationDecision::Escalate(- codex_shell_escalation::EscalationExecution::Unsandboxed- )- ));-- let hook_inputs: Vec<Value> = std::fs::read_to_string(&log_path)- .with_context(|| format!("read hook log at {}", log_path.display()))?- .lines()- .map(serde_json::from_str)- .collect::<serde_json::Result<_>>()- .context("parse hook log")?;- assert_eq!(hook_inputs.len(), 1);- assert_eq!(- hook_inputs[0]["tool_input"]["command"],- expected_hook_command- );- assert_eq!(- hook_inputs[0]["tool_input"]["description"],- serde_json::Value::Null- );-- Ok(())-}--#[test]-fn evaluate_intercepted_exec_policy_uses_wrapper_command_when_shell_wrapper_parsing_disabled() {- let policy_src = r#"prefix_rule(pattern = ["npm", "publish"], decision = "prompt")"#;- let mut parser = PolicyParser::new();- parser.parse("test.rules", policy_src).unwrap();- let policy = parser.build();- let program = AbsolutePathBuf::try_from(host_absolute_path(&["bin", "zsh"])).unwrap();-- let enable_intercepted_exec_policy_shell_wrapper_parsing = false;- let evaluation = evaluate_intercepted_exec_policy(- &policy,- &program,- &[- "zsh".to_string(),- "-lc".to_string(),- "npm publish".to_string(),- ],- InterceptedExecPolicyContext {- approval_policy: AskForApproval::OnRequest,- permission_profile: PermissionProfile::read_only(),- windows_sandbox_level: WindowsSandboxLevel::Disabled,- sandbox_permissions: SandboxPermissions::UseDefault,- enable_shell_wrapper_parsing: enable_intercepted_exec_policy_shell_wrapper_parsing,- },- );-- assert!(- matches!(- evaluation.matched_rules.as_slice(),- [RuleMatch::HeuristicsRuleMatch { command, decision: Decision::Allow }]- if command == &vec![- program.to_string_lossy().to_string(),- "-lc".to_string(),- "npm publish".to_string(),- ]- ),- r#"This is allowed because when shell wrapper parsing is disabled,-the policy evaluation does not try to parse the shell command and instead-matches the whole command line with the resolved program path, which in this-case is `/bin/zsh` followed by some arguments.--Because there is no policy rule for `/bin/zsh` or `zsh`, the decision is to-allow the command and let the sandbox be responsible for enforcing any-restrictions.--That said, if /bin/zsh is the zsh-fork, then the execve wrapper should-ultimately intercept the `npm publish` command and apply the policy rules to it.-"#- );-}--#[test]-fn evaluate_intercepted_exec_policy_matches_inner_shell_commands_when_enabled() {- let policy_src = r#"prefix_rule(pattern = ["npm", "publish"], decision = "prompt")"#;- let mut parser = PolicyParser::new();- parser.parse("test.rules", policy_src).unwrap();- let policy = parser.build();- let program = AbsolutePathBuf::try_from(host_absolute_path(&["bin", "bash"])).unwrap();-- let enable_intercepted_exec_policy_shell_wrapper_parsing = true;- let evaluation = evaluate_intercepted_exec_policy(- &policy,- &program,- &[- "bash".to_string(),- "-lc".to_string(),- "npm publish".to_string(),- ],- InterceptedExecPolicyContext {- approval_policy: AskForApproval::OnRequest,- permission_profile: PermissionProfile::read_only(),- windows_sandbox_level: WindowsSandboxLevel::Disabled,- sandbox_permissions: SandboxPermissions::UseDefault,- enable_shell_wrapper_parsing: enable_intercepted_exec_policy_shell_wrapper_parsing,- },- );-- assert_eq!(- evaluation,- Evaluation {- decision: Decision::Prompt,- matched_rules: vec![RuleMatch::PrefixRuleMatch {- matched_prefix: vec!["npm".to_string(), "publish".to_string()],- decision: Decision::Prompt,- resolved_program: None,- justification: None,- }],- }- );-}--#[test]-fn intercepted_exec_policy_uses_host_executable_mappings() {- let git_path = host_absolute_path(&["usr", "bin", "git"]);- let git_path_literal = starlark_string(&git_path);- let policy_src = format!(- r#"-prefix_rule(pattern = ["git", "status"], decision = "prompt")-host_executable(name = "git", paths = ["{git_path_literal}"])-"#- );- let mut parser = PolicyParser::new();- parser.parse("test.rules", &policy_src).unwrap();- let policy = parser.build();- let program = AbsolutePathBuf::try_from(git_path).unwrap();-- let evaluation = evaluate_intercepted_exec_policy(- &policy,- &program,- &["git".to_string(), "status".to_string()],- InterceptedExecPolicyContext {- approval_policy: AskForApproval::OnRequest,- permission_profile: PermissionProfile::read_only(),- windows_sandbox_level: WindowsSandboxLevel::Disabled,- sandbox_permissions: SandboxPermissions::UseDefault,- enable_shell_wrapper_parsing: false,- },- );-- assert_eq!(- evaluation,- Evaluation {- decision: Decision::Prompt,- matched_rules: vec![RuleMatch::PrefixRuleMatch {- matched_prefix: vec!["git".to_string(), "status".to_string()],- decision: Decision::Prompt,- resolved_program: Some(program),- justification: None,- }],- }- );- assert!(CoreShellActionProvider::decision_driven_by_policy(- &evaluation.matched_rules,- evaluation.decision- ));-}--#[tokio::test(flavor = "current_thread")]-async fn denied_reads_keep_prefix_rule_allow_inside_sandbox() -> anyhow::Result<()> {- let cat_path = host_absolute_path(&["usr", "bin", "cat"]);- let cat_path_literal = starlark_string(&cat_path);- let policy_src = format!(- r#"-prefix_rule(pattern = ["{cat_path_literal}"], decision = "allow")-"#- );- let mut parser = PolicyParser::new();- parser.parse("test.rules", &policy_src).unwrap();- let policy = parser.build();-- let (session, turn_context) = make_session_and_context().await;- let file_system_sandbox_policy = denied_read_file_system_sandbox_policy();- let permission_profile = PermissionProfile::from_runtime_permissions(- &file_system_sandbox_policy,- NetworkSandboxPolicy::Restricted,- );- let workdir = test_sandbox_cwd();- let provider = CoreShellActionProvider {- policy: Arc::new(RwLock::new(policy)),- session: Arc::new(session),- review_context: GuardianReviewContext::from(Arc::new(turn_context)),- call_id: "deny-read-prefix-allow".to_string(),- environment_id: "local".to_string(),- source: GuardianCommandSource::UnifiedExec,- tool_name: ToolName::plain("exec_command"),- approval_policy: AskForApproval::OnRequest,- permission_profile,- sandbox_permissions: SandboxPermissions::UseDefault,- approval_sandbox_permissions: SandboxPermissions::UseDefault,- prompt_permissions: None,- stopwatch: codex_shell_escalation::Stopwatch::new(Duration::from_secs(1)),- };-- let action = codex_shell_escalation::EscalationPolicy::determine_action(- &provider,- &AbsolutePathBuf::try_from(cat_path).unwrap(),- &["cat".to_string(), "/tmp/visible.txt".to_string()],- &workdir,- )- .await?;-- assert_eq!(action, codex_shell_escalation::EscalationDecision::Run);- Ok(())-}--#[tokio::test(flavor = "current_thread")]-async fn denied_reads_keep_granular_sandbox_rejection_for_escalation() -> anyhow::Result<()> {- let (session, turn_context) = make_session_and_context().await;- let file_system_sandbox_policy = denied_read_file_system_sandbox_policy();- let permission_profile = PermissionProfile::from_runtime_permissions(- &file_system_sandbox_policy,- NetworkSandboxPolicy::Restricted,- );- let workdir = test_sandbox_cwd();- let provider = CoreShellActionProvider {- policy: Arc::new(RwLock::new(PolicyParser::new().build())),- session: Arc::new(session),- review_context: GuardianReviewContext::from(Arc::new(turn_context)),- call_id: "deny-read-granular-sandbox-reject".to_string(),- environment_id: "local".to_string(),- source: GuardianCommandSource::UnifiedExec,- tool_name: ToolName::plain("exec_command"),- approval_policy: AskForApproval::Granular(GranularApprovalConfig {- sandbox_approval: false,- rules: true,- skill_approval: true,- request_permissions: true,- mcp_elicitations: true,- }),- permission_profile,- sandbox_permissions: SandboxPermissions::RequireEscalated,- approval_sandbox_permissions: SandboxPermissions::RequireEscalated,- prompt_permissions: None,- stopwatch: codex_shell_escalation::Stopwatch::new(Duration::from_secs(1)),- };-- let action = codex_shell_escalation::EscalationPolicy::determine_action(- &provider,- &AbsolutePathBuf::try_from(host_absolute_path(&["usr", "bin", "printf"])).unwrap(),- &["printf".to_string(), "hello".to_string()],- &workdir,- )- .await?;-- assert_eq!(- action,- codex_shell_escalation::EscalationDecision::Deny {- reason: Some("Execution forbidden by policy".to_string())- }- );- Ok(())-}--#[test]-fn intercepted_exec_policy_treats_preapproved_additional_permissions_as_default() {- let policy = PolicyParser::new().build();- let program = AbsolutePathBuf::try_from(host_absolute_path(&["usr", "bin", "printf"])).unwrap();- let argv = ["printf".to_string(), "hello".to_string()];- let approval_policy = AskForApproval::OnRequest;- let permission_profile = PermissionProfile::workspace_write();-- let preapproved = evaluate_intercepted_exec_policy(- &policy,- &program,- &argv,- InterceptedExecPolicyContext {- approval_policy,- permission_profile: permission_profile.clone(),- windows_sandbox_level: WindowsSandboxLevel::Disabled,- sandbox_permissions: super::approval_sandbox_permissions(- SandboxPermissions::WithAdditionalPermissions,- /*additional_permissions_preapproved*/ true,- ),- enable_shell_wrapper_parsing: false,- },- );- let fresh_request = evaluate_intercepted_exec_policy(- &policy,- &program,- &argv,- InterceptedExecPolicyContext {- approval_policy,- permission_profile,- windows_sandbox_level: WindowsSandboxLevel::Disabled,- sandbox_permissions: SandboxPermissions::WithAdditionalPermissions,- enable_shell_wrapper_parsing: false,- },- );-- assert_eq!(preapproved.decision, Decision::Allow);- assert_eq!(fresh_request.decision, Decision::Prompt);-}--#[test]-fn intercepted_exec_policy_rejects_disallowed_host_executable_mapping() {- let allowed_git = host_absolute_path(&["usr", "bin", "git"]);- let other_git = host_absolute_path(&["opt", "homebrew", "bin", "git"]);- let allowed_git_literal = starlark_string(&allowed_git);- let policy_src = format!(- r#"-prefix_rule(pattern = ["git", "status"], decision = "prompt")-host_executable(name = "git", paths = ["{allowed_git_literal}"])-"#- );- let mut parser = PolicyParser::new();- parser.parse("test.rules", &policy_src).unwrap();- let policy = parser.build();- let program = AbsolutePathBuf::try_from(other_git.clone()).unwrap();-- let evaluation = evaluate_intercepted_exec_policy(- &policy,- &program,- &["git".to_string(), "status".to_string()],- InterceptedExecPolicyContext {- approval_policy: AskForApproval::OnRequest,- permission_profile: PermissionProfile::read_only(),- windows_sandbox_level: WindowsSandboxLevel::Disabled,- sandbox_permissions: SandboxPermissions::UseDefault,- enable_shell_wrapper_parsing: false,- },- );-- assert!(matches!(- evaluation.matched_rules.as_slice(),- [RuleMatch::HeuristicsRuleMatch { command, .. }]- if command == &vec![other_git, "status".to_string()]- ));- assert!(!CoreShellActionProvider::decision_driven_by_policy(- &evaluation.matched_rules,- evaluation.decision- ));-}diff --git a/codex-rs/core/src/tools/spec_plan.rs b/codex-rs/core/src/tools/spec_plan.rsindex 5c83302ca6..00fe53e244 100644--- a/codex-rs/core/src/tools/spec_plan.rs+++ b/codex-rs/core/src/tools/spec_plan.rs@@ -88,7 +88,6 @@ use codex_tools::ToolExecutor;use codex_tools::ToolExposures;use codex_tools::ToolName;use codex_tools::ToolSpec;-use codex_tools::UnifiedExecShellMode;use codex_tools::can_request_original_image_detail;use codex_tools::collect_code_mode_exec_prompt_tool_definitions;use codex_tools::collect_request_plugin_install_entries;@@ -1287,15 +1286,7 @@ fn add_shell_tools(context: &CoreToolPlanContext<'_>, registry: &mut ToolRegistr.environments.turn_environments().any(|environment| environment.config().allow_login_shell),- include_shell_parameter: stable_environment_tools- || !matches!(- &turn_context.unified_exec_shell_mode,- UnifiedExecShellMode::ZshFork(_)- )- || context- .environments- .turn_environments()- .any(|environment| environment.environment.is_remote()),+ include_shell_parameter: true,allow_tty: features.enabled(Feature::UnifiedExecTty),exec_permission_approvals_enabled,include_environment_id,diff --git a/codex-rs/core/src/tools/spec_plan_tests.rs b/codex-rs/core/src/tools/spec_plan_tests.rsindex 1ccb81393b..1a8a066187 100644--- a/codex-rs/core/src/tools/spec_plan_tests.rs+++ b/codex-rs/core/src/tools/spec_plan_tests.rs@@ -960,7 +960,6 @@ async fn request_user_input_stays_direct_in_code_mode_only() {async fn shell_family_registers_only_unified_exec_tools() {let plan = probe(|turn| {set_features(turn, &[Feature::ShellTool]);- set_feature(turn, Feature::ShellZshFork, /*enabled*/ false);update_turn_settings_for_test(turn, |settings| {Arc::make_mut(&mut settings.model_info).shell_type = ConfigShellToolType::UnifiedExec;});@@ -984,7 +983,6 @@ async fn exec_command_guidance_follows_executor_platform_and_fallbacks() {] {let plan = probe(|turn| {set_features(turn, &[Feature::ShellTool, Feature::UnifiedExec]);- set_feature(turn, Feature::ShellZshFork, /*enabled*/ false);update_turn_settings_for_test(turn, |settings| {Arc::make_mut(&mut settings.model_info).shell_type =ConfigShellToolType::UnifiedExec;@@ -1081,40 +1079,6 @@ async fn dynamic_tools_cannot_reclaim_the_reserved_exec_command_name() {);}-#[tokio::test]-async fn shell_zsh_fork_keeps_unified_exec_available() {- let without_composition = probe(|turn| {- set_features(turn, &[Feature::ShellTool]);- set_feature(turn, Feature::ShellZshFork, /*enabled*/ true);- set_feature(turn, Feature::UnifiedExecZshFork, /*enabled*/ false);- update_turn_settings_for_test(turn, |settings| {- Arc::make_mut(&mut settings.model_info).shell_type = ConfigShellToolType::UnifiedExec;- });- })- .await;-- without_composition.assert_visible_contains(&["exec_command", "write_stdin"]);- without_composition.assert_registered_contains(&["exec_command", "write_stdin"]);-- let composed = probe(|turn| {- set_features(- turn,- &[- Feature::ShellTool,- Feature::ShellZshFork,- Feature::UnifiedExecZshFork,- ],- );- update_turn_settings_for_test(turn, |settings| {- Arc::make_mut(&mut settings.model_info).shell_type = ConfigShellToolType::UnifiedExec;- });- })- .await;-- composed.assert_visible_contains(&["exec_command", "write_stdin"]);- composed.assert_registered_contains(&["exec_command", "write_stdin"]);-}-#[tokio::test]async fn multiple_environments_expose_environment_selectors() {let multiple_environments = probe(|turn| {@@ -1804,7 +1768,6 @@ async fn unified_tool_runtimes_preserve_source_order_and_collision_priority() {let plan = probe_with(|turn| {set_features(turn, &[Feature::ShellTool]);- set_feature(turn, Feature::ShellZshFork, /*enabled*/ false);update_turn_settings_for_test(turn, |settings| {Arc::make_mut(&mut settings.model_info).shell_type =ConfigShellToolType::UnifiedExec;diff --git a/codex-rs/core/src/unified_exec/async_watcher_tests.rs b/codex-rs/core/src/unified_exec/async_watcher_tests.rsindex 8443994551..5e9973c75e 100644--- a/codex-rs/core/src/unified_exec/async_watcher_tests.rs+++ b/codex-rs/core/src/unified_exec/async_watcher_tests.rs@@ -9,7 +9,6 @@ use super::utf8_boundary;use crate::session::tests::make_session_and_context_with_rx;use crate::unified_exec::UnifiedExecContext;use crate::unified_exec::UnifiedExecProcessManager;-use crate::unified_exec::process::NoopSpawnLifecycle;use crate::unified_exec::process::OutputBuffers;use crate::unified_exec::process::UnifiedExecProcess;use codex_protocol::items::CommandExecutionStatus;@@ -48,10 +47,7 @@ async fn streaming_output_harness() -> anyhow::Result<StreamingOutputHarness> {#[cfg(windows)]tty: false,});- let process = Arc::new(- UnifiedExecProcess::from_spawned(spawned, SandboxType::None, Box::new(NoopSpawnLifecycle))- .await?,- );+ let process = Arc::new(UnifiedExecProcess::from_spawned(spawned, SandboxType::None).await?);let (session, turn, rx_event) = make_session_and_context_with_rx().await;let context = UnifiedExecContext::new(session,diff --git a/codex-rs/core/src/unified_exec/mod.rs b/codex-rs/core/src/unified_exec/mod.rsindex 28af9b0229..c4ea0991ab 100644--- a/codex-rs/core/src/unified_exec/mod.rs+++ b/codex-rs/core/src/unified_exec/mod.rs@@ -30,7 +30,6 @@ use std::sync::Weak;use codex_network_proxy::NetworkProxy;use codex_protocol::models::AdditionalPermissionProfile;-use codex_tools::UnifiedExecShellMode;use codex_utils_output_truncation::TruncationPolicy;use codex_utils_path_uri::PathUri;use rand::Rng;@@ -62,10 +61,6 @@ pub(crate) fn set_deterministic_process_ids_for_tests(enabled: bool) {}pub(crate) use errors::UnifiedExecError;-pub(crate) use process::NoopSpawnLifecycle;-#[cfg(unix)]-pub(crate) use process::SpawnLifecycle;-pub(crate) use process::SpawnLifecycleHandle;pub(crate) use process::UnifiedExecProcess;pub(crate) use stdin_approval::TerminalPermissions;pub(crate) use stdin_approval::TerminalSandboxSource;@@ -121,7 +116,6 @@ pub(crate) struct ExecCommandRequest {pub cwd: PathUri,pub sandbox_cwd: PathUri,pub turn_environment: TurnEnvironment,- pub shell_mode: UnifiedExecShellMode,pub network: Option<NetworkProxy>,pub tty: bool,pub sandbox_permissions: SandboxPermissions,diff --git a/codex-rs/core/src/unified_exec/mod_tests.rs b/codex-rs/core/src/unified_exec/mod_tests.rsindex 1b8af5bc0d..3bc0ad0189 100644--- a/codex-rs/core/src/unified_exec/mod_tests.rs+++ b/codex-rs/core/src/unified_exec/mod_tests.rs@@ -1,6 +1,5 @@use super::*;use crate::codex_thread::BackgroundTerminalInfo;-use crate::environment_selection::TurnEnvironmentState;use crate::exec::ExecCapturePolicy;use crate::exec::ExecExpiration;use crate::sandboxing::ExecRequest;@@ -118,7 +117,6 @@ async fn exec_command_with_tty(codex_sandboxing::WindowsSandboxProxySettingsMode::Reconcile,/*network_policy_decider*/ None,tty,- Box::new(NoopSpawnLifecycle),turn.initial_environments.primary().expect("turn environment")@@ -218,17 +216,6 @@ async fn exec_command_with_tty(})}-#[derive(Debug)]-struct TestSpawnLifecycle {- inherited_fds: Vec<i32>,-}--impl SpawnLifecycle for TestSpawnLifecycle {- fn inherited_fds(&self) -> Vec<i32> {- self.inherited_fds.clone()- }-}-struct BlockingTerminateExecProcess {process_id: ProcessId,terminate_started: watch::Sender<bool>,@@ -787,7 +774,6 @@ async fn completed_pipe_commands_preserve_exit_code() -> anyhow::Result<()> {codex_sandboxing::WindowsSandboxProxySettingsMode::Reconcile,/*network_policy_decider*/ None,/*tty*/ false,- Box::new(NoopSpawnLifecycle),&environment,).await?;@@ -830,7 +816,6 @@ async fn unified_exec_uses_remote_exec_server_when_configured() -> anyhow::Resulcodex_sandboxing::WindowsSandboxProxySettingsMode::Reconcile,/*network_policy_decider*/ None,/*tty*/ true,- Box::new(NoopSpawnLifecycle),remote_test_env.environment(),).await?;@@ -850,56 +835,6 @@ async fn unified_exec_uses_remote_exec_server_when_configured() -> anyhow::ResulOk(())}-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]-async fn remote_exec_server_rejects_inherited_fd_launches() -> anyhow::Result<()> {- skip_if_sandbox!(Ok(()));- skip_if_no_remote_env!(Ok(()));-- let remote_test_env = remote_test_env().await?;- let (_, mut turn) = make_session_and_context().await;- let TurnEnvironmentState::Ready(environment) = &mut turn.initial_environments.environments[0]- else {- panic!("expected ready primary environment");- };- environment.environment = Arc::new(remote_test_env.environment().clone());-- #[allow(deprecated)]- let cwd = turn.cwd.clone();- let request = test_exec_request(- &turn,- vec!["bash".to_string(), "-lc".to_string(), "echo ok".to_string()],- cwd,- shell_env(),- );-- let manager = UnifiedExecProcessManager::default();- let err = manager- .open_session_with_prepared_exec_env(- /*process_id*/ 1234,- &request,- /*tool_ctx*/ None,- codex_sandboxing::WindowsSandboxProxySettingsMode::Reconcile,- /*network_policy_decider*/ None,- /*tty*/ true,- Box::new(TestSpawnLifecycle {- inherited_fds: vec![42],- }),- turn.initial_environments- .primary()- .expect("turn environment")- .environment- .as_ref(),- )- .await- .expect_err("expected inherited fd rejection");-- assert_eq!(- err.to_string(),- "Failed to create unified exec process: remote exec-server does not support inherited file descriptors"- );- Ok(())-}-#[tokio::test]async fn stdin_approval_preserves_the_reviewed_terminal() -> anyhow::Result<()> {use crate::session::tests::make_session_and_context_with_auth_and_config_and_rx;diff --git a/codex-rs/core/src/unified_exec/process.rs b/codex-rs/core/src/unified_exec/process.rsindex 8305c02894..51afaa36d0 100644--- a/codex-rs/core/src/unified_exec/process.rs+++ b/codex-rs/core/src/unified_exec/process.rs@@ -37,27 +37,6 @@ use super::process_state::ProcessState;use crate::shell_snapshot::ShellSnapshotFile;const EARLY_EXIT_GRACE_PERIOD: Duration = Duration::from_millis(150);-pub(crate) trait SpawnLifecycle: std::fmt::Debug + Send + Sync {- /// Returns file descriptors that must stay open across the child `exec()`.- ///- /// The returned descriptors must already be valid in the parent process and- /// stay valid until `after_spawn()` runs, which is the first point where- /// the parent may release its copies.- fn inherited_fds(&self) -> Vec<i32> {- Vec::new()- }-- fn after_spawn(&mut self) {}-}--pub(crate) type SpawnLifecycleHandle = Box<dyn SpawnLifecycle>;--#[derive(Debug, Default)]-/// Spawn lifecycle that performs no extra setup around process launch.-pub(crate) struct NoopSpawnLifecycle;--impl SpawnLifecycle for NoopSpawnLifecycle {}-/// Output pending model polling and the retained completion transcript./// Append both under the same lock so cancellation cannot split an update.#[derive(Default)]@@ -114,7 +93,6 @@ pub(crate) struct UnifiedExecProcess {output_task: Option<JoinHandle<()>>,sandbox_type: Option<SandboxType>,timed_out: AtomicBool,- _spawn_lifecycle: Option<SpawnLifecycleHandle>,// The shell may still need to replay this file after process startup returns.pub(crate) _shell_snapshot: Option<Arc<ShellSnapshotFile>>,}@@ -130,11 +108,7 @@ impl std::fmt::Debug for UnifiedExecProcess {}impl UnifiedExecProcess {- fn new(- process_handle: ProcessHandle,- sandbox_type: Option<SandboxType>,- spawn_lifecycle: Option<SpawnLifecycleHandle>,- ) -> Self {+ fn new(process_handle: ProcessHandle, sandbox_type: Option<SandboxType>) -> Self {let output = OutputHandles {output_buffer: Arc::new(Mutex::new(OutputBuffers::default())),output_notify: Arc::new(Notify::new()),@@ -157,7 +131,6 @@ impl UnifiedExecProcess {output_task: None,sandbox_type,timed_out: AtomicBool::new(false),- _spawn_lifecycle: spawn_lifecycle,_shell_snapshot: None,}}@@ -358,7 +331,6 @@ impl UnifiedExecProcess {pub(super) async fn from_spawned(spawned: SpawnedPty,sandbox_type: SandboxType,- spawn_lifecycle: SpawnLifecycleHandle,) -> Result<Self, UnifiedExecError> {let SpawnedPty {session: process_handle,@@ -370,7 +342,6 @@ impl UnifiedExecProcess {let mut managed = Self::new(ProcessHandle::Local(Box::new(process_handle)),Some(sandbox_type),- Some(spawn_lifecycle),);managed.output_task = Some(Self::spawn_local_output_task(output_rx,@@ -419,7 +390,7 @@ impl UnifiedExecProcess {// Older peers do not report this field. In that case, skip local// classification rather than attributing a violation to a guessed backend.let sandbox_type = started.sandbox_type;- let mut managed = Self::new(process_handle, sandbox_type, /*spawn_lifecycle*/ None);+ let mut managed = Self::new(process_handle, sandbox_type);let output_handles = managed.output_handles().clone();managed.output_task = Some(Self::spawn_exec_server_output_task(started,diff --git a/codex-rs/core/src/unified_exec/process_manager.rs b/codex-rs/core/src/unified_exec/process_manager.rsindex 35a94ac959..80a34ce6a1 100644--- a/codex-rs/core/src/unified_exec/process_manager.rs+++ b/codex-rs/core/src/unified_exec/process_manager.rs@@ -65,7 +65,6 @@ use crate::unified_exec::generate_chunk_id;use crate::unified_exec::head_tail_buffer::HeadTailBuffer;use crate::unified_exec::process::OutputBuffers;use crate::unified_exec::process::OutputHandles;-use crate::unified_exec::process::SpawnLifecycleHandle;use crate::unified_exec::process::UnifiedExecProcess;use crate::unified_exec::shell_snapshot::shell_snapshot_request;use crate::unified_exec::take_plugin_metrics_sidecar;@@ -1265,7 +1264,6 @@ impl UnifiedExecProcessManager {shell_snapshot: Option<codex_exec_server::ShellSnapshotRequest>,windows_sandbox_proxy_settings_mode: codex_sandboxing::WindowsSandboxProxySettingsMode,tty: bool,- spawn_lifecycle: SpawnLifecycleHandle,environment: &codex_exec_server::Environment,) -> Result<UnifiedExecProcess, ToolError> {let mut request = if environment.is_remote() || shell_snapshot.is_some() {@@ -1293,7 +1291,6 @@ impl UnifiedExecProcessManager {windows_sandbox_proxy_settings_mode,network_policy_decider,tty,- spawn_lifecycle,environment,).await@@ -1317,18 +1314,9 @@ impl UnifiedExecProcessManager {windows_sandbox_proxy_settings_mode: codex_sandboxing::WindowsSandboxProxySettingsMode,network_policy_decider: Option<Arc<dyn NetworkPolicyDecider>>,tty: bool,- mut spawn_lifecycle: SpawnLifecycleHandle,environment: &codex_exec_server::Environment,) -> Result<UnifiedExecProcess, UnifiedExecError> {- let inherited_fds = spawn_lifecycle.inherited_fds();-if environment.is_remote() || request.exec_server_shell_snapshot.is_some() {- if !inherited_fds.is_empty() {- return Err(UnifiedExecError::create_process(- "remote exec-server does not support inherited file descriptors".to_string(),- ));- }-let backend = environment.get_exec_backend();let params = exec_server_params_for_request(process_id,@@ -1355,7 +1343,6 @@ impl UnifiedExecProcessManager {None => backend.start(params).await,}.map_err(|err| UnifiedExecError::create_process(err.to_string()))?;- spawn_lifecycle.after_spawn();return UnifiedExecProcess::from_exec_server_started(started).await;}@@ -1422,13 +1409,12 @@ impl UnifiedExecProcessManager {windows_sandbox,tty,stdin_open: tty,- inherited_fds: codex_utils_pty::ChildFds::Inherited(&inherited_fds),+ inherited_fds: codex_utils_pty::ChildFds::Inherited(&[]),}).await;- spawn_lifecycle.after_spawn();let spawned =spawn_result.map_err(|err| UnifiedExecError::create_process(err.to_string()))?;- UnifiedExecProcess::from_spawned(spawned, request.sandbox, spawn_lifecycle).await+ UnifiedExecProcess::from_spawned(spawned, request.sandbox).await}#[tracing::instrument(@@ -1467,7 +1453,7 @@ impl UnifiedExecProcessManager {};let shell_snapshot = shell_snapshot_request(request, &cwd, context);let mut orchestrator = ToolOrchestrator::new();- let mut runtime = UnifiedExecRuntime::new(self, request.shell_mode.clone());+ let mut runtime = UnifiedExecRuntime::new(self);let session_shell = context.session.user_shell();let configured_shell = request.turn_environment@@ -1504,7 +1490,6 @@ impl UnifiedExecProcessManager {allow_prefix_rules: context.step_context.turn.allow_prefix_rules(),},configured_shell,- &request.shell_mode,command_platform,).await;@@ -1524,8 +1509,6 @@ impl UnifiedExecProcessManager {tty: request.tty,sandbox_permissions: request.sandbox_permissions,additional_permissions: request.additional_permissions.clone(),- #[cfg(unix)]- additional_permissions_preapproved: request.additional_permissions_preapproved,justification: request.justification.clone(),exec_approval_requirement,};diff --git a/codex-rs/core/src/unified_exec/process_manager_tests.rs b/codex-rs/core/src/unified_exec/process_manager_tests.rsindex ce56681e68..081ab93599 100644--- a/codex-rs/core/src/unified_exec/process_manager_tests.rs+++ b/codex-rs/core/src/unified_exec/process_manager_tests.rs@@ -482,7 +482,6 @@ async fn failed_initial_end_for_unstored_process_uses_fallback_output() {.primary().cloned().expect("primary environment"),- shell_mode: codex_tools::UnifiedExecShellMode::Direct,network: None,tty: true,sandbox_permissions: crate::sandboxing::SandboxPermissions::UseDefault,diff --git a/codex-rs/core/src/unified_exec/shell_snapshot.rs b/codex-rs/core/src/unified_exec/shell_snapshot.rsindex c7cd928984..6606f6786d 100644--- a/codex-rs/core/src/unified_exec/shell_snapshot.rs+++ b/codex-rs/core/src/unified_exec/shell_snapshot.rs@@ -11,7 +11,6 @@ use codex_protocol::sandbox::SandboxOverride;use codex_sandboxing::SandboxManager;use codex_sandboxing::SandboxablePreference;use codex_tools::ToolName;-use codex_tools::UnifiedExecShellMode;use codex_utils_path_uri::PathUri;use tokio_util::task::AbortOnDropHandle;use uuid::Uuid;@@ -57,10 +56,6 @@ impl Session {.network.as_ref().is_some_and(NetworkProxySpec::enabled)- || !matches!(- step_context.turn.unified_exec_shell_mode,- UnifiedExecShellMode::Direct- ){return None;}@@ -180,7 +175,6 @@ pub(super) fn shell_snapshot_request(if !context.session.features().enabled(Feature::ShellSnapshotV2)|| !request.turn_environment.shell_snapshot_v2_supported|| request.turn_environment.selection.cwd != *cwd- || !matches!(request.shell_mode, UnifiedExecShellMode::Direct)|| !request.shell.is_posix_login(){return None;diff --git a/codex-rs/core/tests/common/lib.rs b/codex-rs/core/tests/common/lib.rsindex 0b05675541..1f76febcee 100644--- a/codex-rs/core/tests/common/lib.rs+++ b/codex-rs/core/tests/common/lib.rs@@ -35,7 +35,6 @@ pub mod test_codex;pub mod test_codex_exec;mod test_environment;pub mod tracing;-pub mod zsh_fork;pub(crate) use test_environment::TestEnvironment;pub use test_environment::TestTargetOs;diff --git a/codex-rs/core/tests/common/zsh_fork.rs b/codex-rs/core/tests/common/zsh_fork.rsdeleted file mode 100644index 225867d8c7..0000000000--- a/codex-rs/core/tests/common/zsh_fork.rs+++ /dev/null@@ -1,131 +0,0 @@-use std::path::Path;-use std::path::PathBuf;--use anyhow::Result;-use codex_core::config::Config;-use codex_core::config::Constrained;-use codex_features::Feature;-use codex_protocol::models::PermissionProfile;-use codex_protocol::permissions::NetworkSandboxPolicy;-use codex_protocol::protocol::AskForApproval;--use crate::test_codex::TestCodex;-use crate::test_codex::TestCodexBuilder;-use crate::test_codex::test_codex;--#[derive(Clone)]-pub struct ZshForkRuntime {- zsh_path: PathBuf,- main_execve_wrapper_exe: PathBuf,-}--impl ZshForkRuntime {- fn apply_to_config(&self, config: &mut Config, approval_policy: AskForApproval) {- config- .features- .enable(Feature::ShellTool)- .expect("test config should allow feature update");- config- .features- .enable(Feature::ShellZshFork)- .expect("test config should allow feature update");- config.zsh_path = Some(self.zsh_path.clone());- config.main_execve_wrapper_exe = Some(self.main_execve_wrapper_exe.clone());- config.permissions.allow_login_shell = false;- config.permissions.approval_policy = Constrained::allow_any(approval_policy);- }-}--pub fn restrictive_workspace_write_profile() -> PermissionProfile {- PermissionProfile::workspace_write_with(- &[],- NetworkSandboxPolicy::Restricted,- /*exclude_tmpdir_env_var*/ true,- /*exclude_slash_tmp*/ true,- )-}--pub fn zsh_fork_runtime(test_name: &str) -> Result<Option<ZshForkRuntime>> {- let Some(zsh_path) = find_test_zsh_path()? else {- return Ok(None);- };- if !supports_exec_wrapper_intercept(&zsh_path) {- eprintln!(- "skipping {test_name}: zsh does not support EXEC_WRAPPER intercepts ({})",- zsh_path.display()- );- return Ok(None);- }- let Ok(main_execve_wrapper_exe) = codex_utils_cargo_bin::cargo_bin("codex-execve-wrapper")- else {- eprintln!("skipping {test_name}: unable to resolve `codex-execve-wrapper` binary");- return Ok(None);- };-- Ok(Some(ZshForkRuntime {- zsh_path,- main_execve_wrapper_exe,- }))-}--pub async fn build_zsh_fork_test<F>(- server: &wiremock::MockServer,- runtime: ZshForkRuntime,- approval_policy: AskForApproval,- permission_profile: PermissionProfile,- pre_build_hook: F,-) -> Result<TestCodex>-where- F: FnOnce(&Path) + Send + 'static,-{- let mut builder = zsh_fork_test_builder(runtime, approval_policy)- .with_pre_build_hook(pre_build_hook)- .with_config(move |config| {- config- .permissions- .set_permission_profile(permission_profile)- .expect("set permission profile");- });- builder.build(server).await-}--pub fn zsh_fork_test_builder(- runtime: ZshForkRuntime,- approval_policy: AskForApproval,-) -> TestCodexBuilder {- test_codex().with_config(move |config| {- runtime.apply_to_config(config, approval_policy);- })-}--fn find_test_zsh_path() -> Result<Option<PathBuf>> {- let repo_root = codex_utils_cargo_bin::repo_root()?;- let dotslash_zsh = repo_root.join("codex-rs/app-server/tests/suite/zsh");- if !dotslash_zsh.is_file() {- eprintln!(- "skipping zsh-fork test: shared zsh DotSlash file not found at {}",- dotslash_zsh.display()- );- return Ok(None);- }-- match crate::fetch_dotslash_file(&dotslash_zsh, /*dotslash_cache*/ None) {- Ok(path) => Ok(Some(path)),- Err(error) => {- eprintln!("skipping zsh-fork test: failed to fetch zsh via dotslash: {error:#}");- Ok(None)- }- }-}--fn supports_exec_wrapper_intercept(zsh_path: &Path) -> bool {- let status = std::process::Command::new(zsh_path)- .arg("-fc")- .arg("/usr/bin/true")- .env("EXEC_WRAPPER", "/usr/bin/false")- .status();- match status {- Ok(status) => !status.success(),- Err(_) => false,- }-}diff --git a/codex-rs/core/tests/suite/approvals.rs b/codex-rs/core/tests/suite/approvals.rsindex 99836ced45..074adbbd03 100644--- a/codex-rs/core/tests/suite/approvals.rs+++ b/codex-rs/core/tests/suite/approvals.rs@@ -54,10 +54,6 @@ use core_test_support::test_codex::test_codex;use core_test_support::test_codex::turn_permission_fields;use core_test_support::wait_for_event;use core_test_support::wait_for_event_with_timeout;-use core_test_support::zsh_fork::build_zsh_fork_test;-use core_test_support::zsh_fork::restrictive_workspace_write_profile;-use core_test_support::zsh_fork::zsh_fork_runtime;-use core_test_support::zsh_fork::zsh_fork_test_builder;use pretty_assertions::assert_eq;use regex_lite::Regex;use serde_json::Value;@@ -2741,7 +2737,6 @@ async fn spawned_subagent_execpolicy_amendment_propagates_to_parent_session() ->}#[cfg(unix)]-#[test_case("zsh_fork", false, false; "zsh_fork_unsupported")]#[test_case("direct", false, false; "explicit_zsh")]#[test_case("direct", true, false; "non_login_in_login_enabled_session")]#[test_case("direct", true, true; "login_startup")]@@ -2776,14 +2771,8 @@ async fn shell_startup_credentials_are_brokered(AskForApproval::Never};let global_startup = matches!(shell_mode, "filtered_startup" | "startup_override");- let direct = shell_mode == "direct" || global_startup || request_extra_permissions;- let builder = if shell_mode == "zsh_fork" {- let Some(runtime) = zsh_fork_runtime("zsh-fork credential broker environment test")? else {- return Ok(());- };- zsh_fork_test_builder(runtime, AskForApproval::Never)- } else {+ let builder = {let Some(zsh) = codex_core::shell::get_shell(codex_core::shell::ShellType::Zsh) else {return Ok(());};@@ -2876,7 +2865,7 @@ ZDOTDIR = "{}"let mut builder = builder.with_home(home).with_cloud_config_bundle(managed_network_requirements_loader());- if direct && !allow_login_shell {+ if !allow_login_shell {let Some(bash) = codex_core::shell::get_shell(codex_core::shell::ShellType::Bash) else {return Ok(());};@@ -2915,12 +2904,6 @@ ZDOTDIR = "{}".features.enable(Feature::ShellSnapshot).expect("test config should allow ShellSnapshot override");- if direct {- config- .features- .disable(Feature::ShellZshFork)- .expect("test config should allow direct shell execution");- }});let server = start_mock_server().await;let mut test = builder.build(&server).await?;@@ -2940,14 +2923,14 @@ ZDOTDIR = "{}"None};let snapshot_dir = test.home.path().join("shell_snapshots");- let workdir = if (allow_login_shell && !login) || shell_mode == "zsh_fork" {+ let workdir = if allow_login_shell && !login {test.cwd.path().to_path_buf()} else {let workdir = test.cwd.path().join("brokered-subdirectory");fs::create_dir(&workdir)?;workdir};- let call_id = "zsh-fork-brokered-github-credential";+ let call_id = "shell-brokered-github-credential";let command = r#"printf '%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n' "$GH_HOST" "$GH_ENTERPRISE_TOKEN" "$CUSTOM_HOST" "$CUSTOM_API_KEY" "$CODEX_NETWORK_PROXY_CREDENTIAL_BROKER_ACTIVE" "$PWD" "$BROKERED_STARTUP_CWD" "${LOGIN_SNAPSHOT_READY-unset}" "$AUTH_HEADER""#;let command = format!("APP_SETTING=production; EXCLUDED_SETTING=denied; [ \"$(/usr/bin/printenv APP_SETTING)\" = production ] || exit 1; if /usr/bin/printenv EXCLUDED_SETTING >/dev/null; then exit 1; fi; {command}"@@ -2960,28 +2943,19 @@ ZDOTDIR = "{}"};let snapshot_dir_arg = shlex::try_join([snapshot_dir.to_string_lossy().as_ref()])?;let command = format!("{command}; /bin/cat {snapshot_dir_arg}/*.sh > captured-snapshot");- let mut arguments = if direct {- let Some(zsh) = codex_core::shell::get_shell(codex_core::shell::ShellType::Zsh) else {- return Ok(());- };- json!({- "cmd": command,- "shell": startup_shell.map_or_else(- || zsh.derive_exec_args("", /*use_login_shell*/ false)[0].clone(),- |path| path.display().to_string(),- ),- "workdir": workdir,- "login": login,- "yield_time_ms": 10_000,- })- } else {- json!({- "cmd": command,- "workdir": workdir,- "login": login,- "yield_time_ms": 10_000,- })+ let Some(zsh) = codex_core::shell::get_shell(codex_core::shell::ShellType::Zsh) else {+ return Ok(());};+ let mut arguments = json!({+ "cmd": command,+ "shell": startup_shell.map_or_else(+ || zsh.derive_exec_args("", /*use_login_shell*/ false)[0].clone(),+ |path| path.display().to_string(),+ ),+ "workdir": workdir,+ "login": login,+ "yield_time_ms": 10_000,+ });if request_extra_permissions {let approved_dir = test.home.path().join("approved-command");fs::create_dir(&approved_dir)?;@@ -2993,13 +2967,13 @@ ZDOTDIR = "{}"&server,vec![sse(vec![- ev_response_created("resp-zsh-fork-broker-1"),+ ev_response_created("resp-shell-broker-1"),event,- ev_completed("resp-zsh-fork-broker-1"),+ ev_completed("resp-shell-broker-1"),]),sse(vec![- ev_assistant_message("msg-zsh-fork-broker", "done"),- ev_completed("resp-zsh-fork-broker-2"),+ ev_assistant_message("msg-shell-broker", "done"),+ ev_completed("resp-shell-broker-2"),]),],)@@ -3039,13 +3013,6 @@ ZDOTDIR = "{}"}let output = responses.requests()[1].function_call_output(call_id);- if shell_mode == "zsh_fork" {- let output = output.to_string();- assert!(output.contains("credential brokerage does not yet support shell_zsh_fork"));- assert!(!workdir.join("captured-snapshot").exists());- assert!(!output.contains(REAL_GITHUB_TOKEN));- return Ok(());- }let result = parse_result(&output);assert_eq!(result.exit_code, Some(0), "command failed: {result:?}");if let Some(metrics) = metrics {@@ -3221,10 +3188,6 @@ GH_TOKEN = "{REAL_GITHUB_TOKEN}"config.features.enable(Feature::ShellSnapshot)}.expect("test config should allow ShellSnapshot override");- config- .features- .disable(Feature::ShellZshFork)- .expect("test config should allow direct shell execution");});let test = builder.build(&server).await?;@@ -3439,7 +3402,6 @@ ENV = "{}"config.permissions.approval_policy = Constrained::allow_any(AskForApproval::Never);config.permissions.allow_login_shell = true;config.features.enable(Feature::ShellSnapshot).unwrap();- config.features.disable(Feature::ShellZshFork).unwrap();if !credential_startup {config.permissions@@ -3504,259 +3466,6 @@ ENV = "{}"Ok(())}-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]-#[cfg(unix)]-async fn env_zsh_script_spawned_by_python_can_request_escalation_under_zsh_fork() -> Result<()> {- skip_if_no_network!(Ok(()));-- let Some(runtime) = zsh_fork_runtime("zsh-fork env zsh nested escalation test")? else {- return Ok(());- };-- let approval_policy = AskForApproval::OnRequest;- let permission_profile = restrictive_workspace_write_profile();- let outside_dir = tempfile::tempdir_in(std::env::current_dir()?)?;- let outside_path = outside_dir.path().join("zsh-fork-env-zsh-escalated.txt");- let outside_path_arg = shlex::try_join([outside_path.to_string_lossy().as_ref()])?;- let rules = r#"prefix_rule(pattern=["touch"], decision="prompt")"#.to_string();-- let server = start_mock_server().await;- let outside_path_for_hook = outside_path.clone();- let test = build_zsh_fork_test(- &server,- runtime,- approval_policy,- permission_profile.clone(),- move |home| {- let _ = fs::remove_file(&outside_path_for_hook);- let rules_dir = home.join("rules");- fs::create_dir_all(&rules_dir).unwrap();- fs::write(rules_dir.join("default.rules"), &rules).unwrap();- },- )- .await?;-- let script_path = test.cwd.path().join("runs-under-env-zsh");- codex_utils_cargo_bin::write_executable(- &script_path,- &format!(- "#!/usr/bin/env zsh\ntouch {outside_path_arg}\nprint -r -- nested-env-zsh-complete\n"- ),- )?;-- let script_literal = serde_json::to_string(script_path.to_string_lossy().as_ref())?;- let python_script = format!(- "import subprocess; subprocess.run([{script_literal}], check=True, close_fds=False)"- );- let command = shlex::try_join(["python3", "-c", python_script.as_str()])?;-- let call_id = "zsh-fork-env-zsh-nested-escalation";- let event = shell_event(- call_id,- &command,- /*timeout_ms*/ 30_000,- SandboxPermissions::UseDefault,- )?;- let _ = mount_sse_once(- &server,- sse(vec![- ev_response_created("resp-zsh-fork-env-zsh-1"),- event,- ev_completed("resp-zsh-fork-env-zsh-1"),- ]),- )- .await;- let results = mount_sse_once(- &server,- sse(vec![- ev_assistant_message("msg-zsh-fork-env-zsh-1", "done"),- ev_completed("resp-zsh-fork-env-zsh-2"),- ]),- )- .await;-- let session_model = test.session_configured.model.clone();- let (sandbox_policy, permission_profile) =- turn_permission_fields(permission_profile, test.cwd.path());- test.codex- .start_or_steer_turn(- TurnInputRequest::user_input(vec![UserInput::Text {- text: "run nested env zsh script through python".into(),- text_elements: Vec::new(),- }])- .with_thread_settings(ThreadSettingsOverrides {- environments: Some(local_requests(test.config.cwd.clone())),- approval_policy: Some(approval_policy),- approvals_reviewer: Some(ApprovalsReviewer::User),- sandbox_policy: Some(sandbox_policy),- permission_profile,- collaboration_mode: Some(CollaborationMode {- mode: ModeKind::Default,- settings: Settings {- model: session_model,- reasoning_effort: None,- developer_instructions: None,- },- }),- ..Default::default()- }),- )- .await?;-- let approval_event = wait_for_event_with_timeout(- &test.codex,- |event| {- matches!(- event,- EventMsg::ExecApprovalRequest(_) | EventMsg::TurnComplete(_)- )- },- Duration::from_secs(10),- )- .await;- let EventMsg::ExecApprovalRequest(approval) = approval_event else {- panic!("expected nested zsh script to request approval before completion");- };- assert!(- approval.command.iter().any(|arg| arg.ends_with("/touch"))- && approval- .command- .iter()- .any(|arg| arg == outside_path.to_string_lossy().as_ref()),- "expected approval for nested touch command, got: {:?}",- approval.command- );-- test.codex- .submit(Op::ExecApproval {- id: approval.effective_approval_id(),- turn_id: None,- decision: ReviewDecision::Approved,- })- .await?;-- wait_for_completion(&test).await;-- let result = parse_result(&results.single_request().function_call_output(call_id));- assert_eq!(- result.exit_code.unwrap_or(0),- 0,- "nested env zsh script should complete successfully: {}",- result.stdout- );- assert!(- result.stdout.contains("nested-env-zsh-complete"),- "nested script did not report completion: {}",- result.stdout- );- assert!(- outside_path.exists(),- "approved nested touch should create the out-of-workspace file"- );-- Ok(())-}--#[tokio::test(flavor = "multi_thread", worker_threads = 2)]-#[cfg(unix)]-async fn matched_prefix_rule_runs_unsandboxed_under_zsh_fork() -> Result<()> {- skip_if_no_network!(Ok(()));-- let Some(runtime) = zsh_fork_runtime("zsh-fork prefix rule unsandboxed test")? else {- return Ok(());- };-- let approval_policy = AskForApproval::Never;- let permission_profile = restrictive_workspace_write_profile();- let outside_dir = tempfile::tempdir_in(std::env::current_dir()?)?;- let outside_path = outside_dir- .path()- .join("zsh-fork-prefix-rule-unsandboxed.txt");- let command = format!("touch {outside_path:?}");- let rules = r#"prefix_rule(pattern=["touch"], decision="allow")"#.to_string();-- let server = start_mock_server().await;- let outside_path_for_hook = outside_path.clone();- let test = build_zsh_fork_test(- &server,- runtime,- approval_policy,- permission_profile.clone(),- move |home| {- let _ = fs::remove_file(&outside_path_for_hook);- let rules_dir = home.join("rules");- fs::create_dir_all(&rules_dir).unwrap();- fs::write(rules_dir.join("default.rules"), &rules).unwrap();- },- )- .await?;-- let call_id = "zsh-fork-prefix-rule-unsandboxed";- let event = shell_event(- call_id,- &command,- /*timeout_ms*/ 1_000,- SandboxPermissions::UseDefault,- )?;- let _ = mount_sse_once(- &server,- sse(vec![- ev_response_created("resp-zsh-fork-prefix-1"),- event,- ev_completed("resp-zsh-fork-prefix-1"),- ]),- )- .await;- let results = mount_sse_once(- &server,- sse(vec![- ev_assistant_message("msg-zsh-fork-prefix-1", "done"),- ev_completed("resp-zsh-fork-prefix-2"),- ]),- )- .await;-- let session_model = test.session_configured.model.clone();- let (sandbox_policy, permission_profile) =- turn_permission_fields(permission_profile, test.cwd.path());- test.codex- .start_or_steer_turn(- TurnInputRequest::user_input(vec![UserInput::Text {- text: "run allowed touch under zsh fork".into(),- text_elements: Vec::new(),- }])- .with_thread_settings(ThreadSettingsOverrides {- environments: Some(local_requests(test.config.cwd.clone())),- approval_policy: Some(approval_policy),- approvals_reviewer: Some(ApprovalsReviewer::User),- sandbox_policy: Some(sandbox_policy),- permission_profile,- collaboration_mode: Some(CollaborationMode {- mode: ModeKind::Default,- settings: Settings {- model: session_model,- reasoning_effort: None,- developer_instructions: None,- },- }),- ..Default::default()- }),- )- .await?;-- wait_for_completion_without_approval(&test).await;-- let result = parse_result(&results.single_request().function_call_output(call_id));- assert_eq!(result.exit_code.unwrap_or(0), 0);- assert!(- outside_path.exists(),- "expected matched prefix_rule to rerun touch unsandboxed; output: {}",- result.stdout- );-- Ok(())-}-/// Verifies that an allowlisted script retains the originating named profile/// when its shell tool call requests escalated, unsandboxed execution.///@@ -3885,9 +3594,13 @@ async fn explicit_escalation_with_denied_reads(decision: Option<ReviewDecision>).with_config(move |config| {config.permissions.approval_policy = Constrained::allow_any(approval_policy);config.features.enable(Feature::UnifiedExec).unwrap();- config.features.disable(Feature::ShellZshFork).unwrap();- let mut file_system =- restrictive_workspace_write_profile().file_system_sandbox_policy();+ let mut file_system = PermissionProfile::workspace_write_with(+ &[],+ NetworkSandboxPolicy::Restricted,+ /*exclude_tmpdir_env_var*/ true,+ /*exclude_slash_tmp*/ true,+ )+ .file_system_sandbox_policy();file_system.entries.push(FileSystemSandboxEntry::new(config.cwd.join("secret.txt").into(),FileSystemAccessMode::Deny,@@ -3956,217 +3669,6 @@ async fn explicit_escalation_with_denied_reads(decision: Option<ReviewDecision>)Ok(())}-/// Verifies that zsh-fork applies an inner script's allow rule even when the-/// model invokes an outer wrapper, and that the escalated script retains the-/// named profile needed to reconstruct the original sandbox remotely without-/// dropping managed enterprise requirements. The script treats the inherited-/// environment value as untrusted and accepts only explicitly allowlisted-/// profile names before passing one to `codex sandbox -P`.-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]-#[cfg(unix)]-async fn zsh_fork_inner_allowed_script_inherits_active_permission_profile() -> Result<()> {- skip_if_no_network!(Ok(()));-- let Some(runtime) = zsh_fork_runtime("zsh-fork remote sandbox wrapper test")? else {- return Ok(());- };-- const HOST: &str = "builder.example.com";- let approval_policy = AskForApproval::OnRequest;- let script_dir = tempfile::tempdir_in(std::env::current_dir()?)?;- let wrapper_path = script_dir.path().join("remote-bash");- let remote_bash_path = script_dir.path().join("remote_bash.py");- let outside_path = script_dir.path().join("remote-bash-unsandboxed-marker");- let outside_path_literal = serde_json::to_string(&outside_path.to_string_lossy())?;- codex_utils_cargo_bin::write_executable(- &remote_bash_path,- &format!(- r#"#!/usr/bin/env python3-import argparse-import os-from pathlib import Path-import re-import shlex-import sys--ALLOWED_HOSTS = ("builder.example.com",)-ALLOWED_PROFILES = (":workspace",)---def parse_args():- parser = argparse.ArgumentParser(- description="Print an ssh command that recreates the current Codex sandbox remotely."- )- parser.add_argument("--host", required=True)- try:- separator = sys.argv.index("--")- except ValueError:- parser.error("the remote command must follow --")- args = parser.parse_args(sys.argv[1:separator])- args.command = sys.argv[separator + 1:]- if not args.command:- parser.error("the remote command must not be empty")- if not re.fullmatch(r"[a-z0-9.-]+", args.host) or args.host not in ALLOWED_HOSTS:- parser.error("host is not allowlisted")- return args---def main():- args = parse_args()- profile_name = os.environ.get("CODEX_PERMISSION_PROFILE")- if not profile_name:- raise SystemExit("CODEX_PERMISSION_PROFILE must not be empty")- if profile_name not in ALLOWED_PROFILES:- raise SystemExit("CODEX_PERMISSION_PROFILE is not allowlisted")-- shell_command = shlex.join(args.command)- sandbox_command = shlex.join(- [- "codex",- "sandbox",- "-P",- profile_name,- "--include-managed-config",- "--",- "bash",- "-lc",- shell_command,- ]- )- print(shlex.join(["ssh", args.host, sandbox_command]))-- # Test-only proof that this inner script was allowed to run unsandboxed.- Path({outside_path_literal}).write_text("unsandboxed", encoding="utf-8")---if __name__ == "__main__":- main()-"#- ),- )?;- let remote_bash_exec = shlex::try_join([remote_bash_path.to_string_lossy().as_ref()])?;- codex_utils_cargo_bin::write_executable(- &wrapper_path,- &format!(- r#"#!/usr/bin/env zsh-exec {remote_bash_exec} "$@"-"#- ),- )?;-- let remote_bash_pattern = serde_json::to_string(&remote_bash_path.to_string_lossy())?;- let rules = format!(r#"prefix_rule(pattern=[{remote_bash_pattern}], decision="allow")"#);- let server = start_mock_server().await;- let mut builder =- zsh_fork_test_builder(runtime, approval_policy).with_pre_build_hook(move |home| {- fs::write(- home.join("config.toml"),- WORKSPACE_PERMISSION_PROFILE_CONFIG,- )- .expect("write config");- let rules_dir = home.join("rules");- fs::create_dir_all(&rules_dir).expect("create rules dir");- fs::write(rules_dir.join("default.rules"), rules).expect("write rules");- });- let test = builder.build(&server).await?;- assert!(!outside_path.starts_with(test.config.cwd.as_path()));- assert_active_workspace_permission_profile(&test);-- let command = shlex::try_join([- wrapper_path.to_string_lossy().as_ref(),- "--host",- HOST,- "--",- "printf",- "%s",- "hello world",- ])?;- let call_id = "zsh-fork-remote-sandbox-wrapper";- let event = shell_event(- call_id,- &command,- /*timeout_ms*/ 30_000,- SandboxPermissions::UseDefault,- )?;- let _ = mount_sse_once(- &server,- sse(vec![- ev_response_created("resp-zsh-fork-remote-wrapper-1"),- event,- ev_completed("resp-zsh-fork-remote-wrapper-1"),- ]),- )- .await;- let results = mount_sse_once(- &server,- sse(vec![- ev_assistant_message("msg-zsh-fork-remote-wrapper-1", "done"),- ev_completed("resp-zsh-fork-remote-wrapper-2"),- ]),- )- .await;-- submit_turn_preserving_active_permission_profile(- &test,- "run the remote sandbox wrapper",- approval_policy,- )- .await?;- wait_for_completion_without_approval(&test).await;-- let result = parse_result(&results.single_request().function_call_output(call_id));- assert_eq!(- result.exit_code.unwrap_or(0),- 0,- "the inner remote_bash.py script should run successfully: {}",- result.stdout- );- let ssh_argv = shlex::split(result.stdout.trim()).context("parse printed ssh command")?;- assert_eq!(- ssh_argv.len(),- 3,- "expected ssh HOST LONG_COMMAND, got: {}",- result.stdout- );- assert_eq!(- ssh_argv[..2],- ["ssh", HOST],- "remote_bash.py should target only the allowlisted host"- );- let sandbox_argv = shlex::split(&ssh_argv[2]).context("parse remote sandbox command")?;- assert_eq!(- sandbox_argv.len(),- 9,- "expected codex sandbox ... bash -lc CMD"- );- assert_eq!(- sandbox_argv[..8],- [- "codex",- "sandbox",- "-P",- BUILT_IN_PERMISSION_PROFILE_WORKSPACE,- "--include-managed-config",- "--",- "bash",- "-lc",- ],- "remote_bash.py should use the allowlisted inherited profile and managed configuration to reconstruct the Codex sandbox"- );- let command_argv = shlex::split(&sandbox_argv[8]).context("parse remote bash command")?;- assert_eq!(- command_argv,- ["printf", "%s", "hello world"],- "remote_bash.py should preserve every argument after --"- );- assert!(- outside_path.exists(),- "the inner allowlisted script should run outside the :workspace sandbox"- );-- Ok(())-}-#[tokio::test(flavor = "current_thread")]#[cfg(unix)]async fn invalid_requested_prefix_rule_falls_back_for_compound_command() -> Result<()> {diff --git a/codex-rs/core/tests/suite/cyber_exec_policy.rs b/codex-rs/core/tests/suite/cyber_exec_policy.rsindex f3e37df9a9..4c8c7d71d0 100644--- a/codex-rs/core/tests/suite/cyber_exec_policy.rs+++ b/codex-rs/core/tests/suite/cyber_exec_policy.rs@@ -20,7 +20,6 @@ use core_test_support::responses::mount_sse_sequence;use core_test_support::responses::sse;use core_test_support::responses::sse_completed;use core_test_support::responses::start_mock_server;-use core_test_support::skip_if_host_windows;use core_test_support::skip_if_no_network;use core_test_support::skip_if_sandbox;use core_test_support::skip_if_wine_exec;@@ -28,8 +27,6 @@ use core_test_support::submit_thread_settings;use core_test_support::test_codex::TestCodex;use core_test_support::test_codex::test_codex;use core_test_support::wait_for_event;-use core_test_support::zsh_fork::zsh_fork_runtime;-use core_test_support::zsh_fork::zsh_fork_test_builder;use pretty_assertions::assert_eq;use serde_json::json;use std::fs;@@ -44,12 +41,6 @@ enum ModelSpecialty {General,}-#[derive(Clone, Copy, Debug, Eq, PartialEq)]-enum ShellBackend {- Standard,- ZshFork,-}-fn configure_saved_prefix_and_guardian(config: &mut Config) {let policy_path = config.codex_home.join("rules/default.rules");fs::create_dir_all(policy_path.parent().expect("rules directory"))@@ -108,29 +99,18 @@ async fn submit_model_turn(test: &TestCodex, model: &str, prompt: &str) -> Resultest.submit_text_turn(prompt).await}-#[test_case(ModelSpecialty::Cyber, ShellBackend::Standard; "cyber unified exec is reviewed")]-#[test_case(ModelSpecialty::Cyber, ShellBackend::ZshFork; "cyber zsh unified exec is reviewed")]-#[test_case(ModelSpecialty::General, ShellBackend::Standard; "general unified exec keeps saved approval")]+#[test_case(ModelSpecialty::Cyber; "cyber unified exec is reviewed")]+#[test_case(ModelSpecialty::General; "general unified exec keeps saved approval")]#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn saved_prefix_only_bypasses_guardian_for_general_models(model_specialty: ModelSpecialty,- shell_backend: ShellBackend,) -> Result<()> {skip_if_no_network!(Ok(()));skip_if_sandbox!(Ok(()));skip_if_wine_exec!(Ok(()), "Guardian command reviews require host-native paths");let server = start_mock_server().await;- let builder = match shell_backend {- ShellBackend::Standard => test_codex(),- ShellBackend::ZshFork => {- skip_if_host_windows!(Ok(()));- let Some(runtime) = zsh_fork_runtime("cyber model zsh-fork saved prefix")? else {- return Ok(());- };- zsh_fork_test_builder(runtime, AskForApproval::OnRequest)- }- };+ let builder = test_codex();let mut builder = builder.with_model_info_override("gpt-5.4", move |model| {if model_specialty == ModelSpecialty::Cyber {@@ -139,10 +119,9 @@ async fn saved_prefix_only_bypasses_guardian_for_general_models(}).with_config(configure_saved_prefix_and_guardian);let test = builder.build_with_auto_env(&server).await?;- let expected_guardian_review_count = match (model_specialty, shell_backend) {- (ModelSpecialty::General, _) => 0,- (ModelSpecialty::Cyber, ShellBackend::Standard) => 1,- (ModelSpecialty::Cyber, ShellBackend::ZshFork) => 2,+ let expected_guardian_review_count = match model_specialty {+ ModelSpecialty::General => 0,+ ModelSpecialty::Cyber => 1,};let mut response_bodies = vec![command_response(diff --git a/codex-rs/core/tests/suite/deprecation_notice.rs b/codex-rs/core/tests/suite/deprecation_notice.rsindex 6858986f32..63501fee48 100644--- a/codex-rs/core/tests/suite/deprecation_notice.rs+++ b/codex-rs/core/tests/suite/deprecation_notice.rs@@ -1,9 +1,11 @@#![cfg(not(target_os = "windows"))]use anyhow::Ok;+use codex_config::test_support::CloudConfigBundleFixture;use codex_features::Feature;use codex_protocol::protocol::DeprecationNoticeEvent;use codex_protocol::protocol::EventMsg;+use core_test_support::responses;use core_test_support::responses::start_mock_server;use core_test_support::skip_if_no_network;use core_test_support::test_codex::TestCodex;@@ -139,3 +141,86 @@ async fn emits_deprecation_notice_for_use_legacy_landlock() -> anyhow::Result<()Ok(())}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn legacy_zsh_config_starts_session_with_migration_notices() -> anyhow::Result<()> {+ skip_if_no_network!(Ok(()));+ let server = start_mock_server().await;+ let mut builder = test_codex()+ .with_pre_build_hook(|home| {+ std::fs::write(+ home.join("config.toml"),+ r#"[features]+shell_zsh_fork = true+unified_exec_zsh_fork = true+"#,+ )+ .expect("write legacy configuration");+ })+ .with_cloud_config_bundle(+ CloudConfigBundleFixture::loader_with_enterprise_requirement(+ "[features]\nshell_zsh_fork = true\nunified_exec_zsh_fork = true\n",+ ),+ );+ let test = builder.build_with_auto_env(&server).await?;++ for feature in ["shell_zsh_fork", "unified_exec_zsh_fork"] {+ let expected = DeprecationNoticeEvent {+ summary: format!("`[features].{feature}` is deprecated and ignored."),+ details: Some(format!(+ "The patched zsh backend has been removed. Shell commands now use the standard shell executor. Remove `{feature}` from [features] in config.toml or profile configuration files."+ )),+ };+ let notice = wait_for_event_match(&test.codex, |event| match event {+ EventMsg::DeprecationNotice(notice) if notice.summary == expected.summary => {+ Some(notice.clone())+ }+ _ => None,+ })+ .await;+ assert_eq!(+ (notice.summary, notice.details),+ (expected.summary, expected.details)+ );+ }+ let shell = match core_test_support::test_target_os() {+ core_test_support::TestTargetOs::Linux | core_test_support::TestTargetOs::MacOs => {+ "/bin/sh"+ }+ core_test_support::TestTargetOs::Windows => "powershell",+ };+ let arguments = serde_json::json!({+ "cmd": "echo migrated-shell",+ "shell": shell,+ "login": false,+ "yield_time_ms": 10_000,+ });+ let mock = responses::mount_sse_sequence(+ &server,+ vec![+ responses::sse(vec![+ responses::ev_function_call(+ "shell-migration",+ "exec_command",+ &arguments.to_string(),+ ),+ responses::ev_completed("response-1"),+ ]),+ responses::sse(vec![responses::ev_completed("response-2")]),+ ],+ )+ .await;+ test.submit_turn("run a command with the configured shell")+ .await?;+ let output = mock+ .function_call_output_text("shell-migration")+ .expect("shell tool output");+ assert!(output.contains("Process exited with code 0\n"), "{output}");+ assert_eq!(+ output+ .split_once("Output:\n")+ .map(|(_, stdout)| stdout.trim()),+ Some("migrated-shell")+ );+ Ok(())+}diff --git a/codex-rs/core/tests/suite/mod.rs b/codex-rs/core/tests/suite/mod.rsindex d64c3a3ed2..5d2cd461ad 100644--- a/codex-rs/core/tests/suite/mod.rs+++ b/codex-rs/core/tests/suite/mod.rs@@ -205,7 +205,6 @@ mod search_tool;mod settings_commits;mod settings_constraints;mod shell_snapshot;-mod skill_approval;mod skills;mod skills_extension;mod spawn_agent_description;@@ -240,8 +239,6 @@ mod unified_exec_mxc_powershell;mod unified_exec_process_events;mod unified_exec_stdin_approval;mod unified_exec_stdin_review_size;-#[cfg(unix)]-mod unified_exec_zsh_fork_approvals;mod unstable_features_warning;mod user_notification;mod user_shell_cmd;diff --git a/codex-rs/core/tests/suite/model_provider_requirements_tests.rs b/codex-rs/core/tests/suite/model_provider_requirements_tests.rsindex 6bb8c9b68a..9d28aece9c 100644--- a/codex-rs/core/tests/suite/model_provider_requirements_tests.rs+++ b/codex-rs/core/tests/suite/model_provider_requirements_tests.rs@@ -183,11 +183,6 @@ X-Managed = "required"overridden.cwd.to_path_buf(),&overridden.config_layer_stack,overridden.codex_home.clone(),- overridden- .zsh_path- .clone()- .map(codex_utils_absolute_path::AbsolutePathBuf::try_from)- .transpose()?,).await?;assert_eq!(rebuilt.model_provider, test.config.model_provider);diff --git a/codex-rs/core/tests/suite/plugins.rs b/codex-rs/core/tests/suite/plugins.rsindex c93940599d..5749351983 100644--- a/codex-rs/core/tests/suite/plugins.rs+++ b/codex-rs/core/tests/suite/plugins.rs@@ -68,8 +68,6 @@ use core_test_support::test_codex::turn_permission_fields;use core_test_support::wait_for_event;use core_test_support::wait_for_event_match;use core_test_support::wait_for_mcp_server;-use core_test_support::zsh_fork::zsh_fork_runtime;-use core_test_support::zsh_fork::zsh_fork_test_builder;use pretty_assertions::assert_eq;use tempfile::TempDir;use test_case::test_case;@@ -466,12 +464,8 @@ async fn shared_analytics_client_preserves_session_products() -> Result<()> {Ok(())}-#[test_case(false; "classic shell")]-#[test_case(true; "zsh-fork shell")]#[tokio::test(flavor = "multi_thread", worker_threads = 2)]-async fn persisted_remote_plugin_command_attribution_flows_through_turn_context(- zsh_fork: bool,-) -> Result<()> {+async fn persisted_remote_plugin_command_attribution_flows_through_turn_context() -> Result<()> {skip_if_target_windows!(Ok(()), "executes a POSIX shell script");skip_if_no_network!(Ok(()));skip_if_remote!(@@ -495,14 +489,7 @@ async fn persisted_remote_plugin_command_attribution_flows_through_turn_context(plugin_root.join("analytics.yaml"),"version: 1\noperations: {scan: {path: ./scripts/run.sh, measurements: {files_scanned: {}}}}\n",)?;- let builder = if zsh_fork {- let Some(runtime) = zsh_fork_runtime("zsh-fork plugin measurement test")? else {- return Ok(());- };- zsh_fork_test_builder(runtime, AskForApproval::Never)- } else {- test_codex()- };+ let builder = test_codex();let command = shlex::try_join(["/bin/sh", script_path.to_string_lossy().as_ref()])?;let call_id = "remote-plugin-command";let arguments = serde_json::to_string(&serde_json::json!({diff --git a/codex-rs/core/tests/suite/remote_env.rs b/codex-rs/core/tests/suite/remote_env.rsindex 3dbaa5f376..273936769f 100644--- a/codex-rs/core/tests/suite/remote_env.rs+++ b/codex-rs/core/tests/suite/remote_env.rs@@ -1915,13 +1915,6 @@ async fn pending_attachment_installs_configuration_before_waiting_turn_resumes().enable(Feature::StableEnvironmentTools).expect("enable stable environment tools");assert!(config.features.enable(Feature::DeferredExecutor).is_ok());- if cfg!(unix) {- assert!(config.features.enable(Feature::ShellZshFork).is_ok());- // Calls stop at environment/login validation, so these paths are never executed.- let executable = std::env::current_exe().expect("current executable");- config.zsh_path = Some(executable.clone());- config.main_execve_wrapper_exe = Some(executable);- }assert!(config.featuresdiff --git a/codex-rs/core/tests/suite/skill_approval.rs b/codex-rs/core/tests/suite/skill_approval.rsdeleted file mode 100644index bc89d4acef..0000000000--- a/codex-rs/core/tests/suite/skill_approval.rs+++ /dev/null@@ -1,286 +0,0 @@-#![allow(clippy::unwrap_used)]-#![cfg(unix)]--use anyhow::Result;-use codex_core::TurnInputRequest;-use codex_protocol::config_types::CollaborationMode;-use codex_protocol::config_types::ModeKind;-use codex_protocol::config_types::Settings;-use codex_protocol::models::PermissionProfile;-use codex_protocol::protocol::AskForApproval;-use codex_protocol::protocol::EventMsg;-use codex_protocol::protocol::ExecApprovalRequestEvent;-use codex_protocol::protocol::GranularApprovalConfig;-use codex_protocol::protocol::ThreadSettingsOverrides;-use codex_protocol::user_input::UserInput;-use core_test_support::responses::mount_function_call_agent_response;-use core_test_support::responses::start_mock_server;-use core_test_support::skip_if_no_network;-use core_test_support::test_codex::TestCodex;-use core_test_support::test_codex::local_requests;-use core_test_support::test_codex::turn_permission_fields;-use core_test_support::wait_for_event;-use core_test_support::wait_for_event_match;-use core_test_support::zsh_fork::build_zsh_fork_test;-use core_test_support::zsh_fork::restrictive_workspace_write_profile;-use core_test_support::zsh_fork::zsh_fork_runtime;-use std::fs;-use std::path::Path;-use std::path::PathBuf;--fn write_skill_metadata(home: &Path, name: &str, contents: &str) -> Result<()> {- let metadata_dir = home.join("skills").join(name).join("agents");- fs::create_dir_all(&metadata_dir)?;- fs::write(metadata_dir.join("openai.yaml"), contents)?;- Ok(())-}--fn exec_command_arguments(command: &str) -> Result<String> {- Ok(serde_json::to_string(&serde_json::json!({- "cmd": command,- "yield_time_ms": 500,- }))?)-}--async fn submit_turn_with_policies(- test: &TestCodex,- prompt: &str,- approval_policy: AskForApproval,- permission_profile: PermissionProfile,-) -> Result<()> {- let (sandbox_policy, permission_profile) =- turn_permission_fields(permission_profile, test.cwd_path());- test.codex- .start_or_steer_turn(- TurnInputRequest::user_input(vec![UserInput::Text {- text: prompt.to_string(),- text_elements: Vec::new(),- }])- .with_thread_settings(ThreadSettingsOverrides {- environments: Some(local_requests(test.config.cwd.clone())),- approval_policy: Some(approval_policy),- sandbox_policy: Some(sandbox_policy),- permission_profile,- collaboration_mode: Some(CollaborationMode {- mode: ModeKind::Default,- settings: Settings {- model: test.session_configured.model.clone(),- reasoning_effort: None,- developer_instructions: None,- },- }),- ..Default::default()- }),- )- .await?;- Ok(())-}--#[cfg(unix)]-fn write_skill_with_shell_script_contents(- home: &Path,- name: &str,- script_name: &str,- script_contents: &str,-) -> Result<PathBuf> {- let skill_dir = home.join("skills").join(name);- let scripts_dir = skill_dir.join("scripts");- fs::create_dir_all(&scripts_dir)?;- fs::write(- skill_dir.join("SKILL.md"),- format!(- r#"----name: {name}-description: {name} skill-----"#- ),- )?;-- let script_path = scripts_dir.join(script_name);- codex_utils_cargo_bin::write_executable(&script_path, script_contents)?;- Ok(script_path)-}--fn skill_script_command(test: &TestCodex, script_name: &str) -> Result<String> {- let script_path = fs::canonicalize(- test.codex_home_path()- .join("skills/mbolin-test-skill/scripts")- .join(script_name),- )?;- Ok(shlex::try_join([script_path.to_string_lossy().as_ref()])?)-}--async fn wait_for_exec_approval_request(test: &TestCodex) -> Option<ExecApprovalRequestEvent> {- wait_for_event_match(test.codex.as_ref(), |event| match event {- EventMsg::ExecApprovalRequest(request) => Some(Some(request.clone())),- EventMsg::TurnComplete(_) => Some(None),- _ => None,- })- .await-}--async fn wait_for_turn_complete(test: &TestCodex) {- wait_for_event(test.codex.as_ref(), |event| {- matches!(event, EventMsg::TurnComplete(_))- })- .await;-}--fn output_shows_sandbox_denial(output: &str) -> bool {- output.contains("Permission denied")- || output.contains("Operation not permitted")- || output.contains("Read-only file system")-}--#[cfg(unix)]-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]-async fn shell_zsh_fork_skill_scripts_ignore_declared_permissions() -> Result<()> {- skip_if_no_network!(Ok(()));-- let Some(runtime) = zsh_fork_runtime("zsh-fork skill script ignores permissions test")? else {- return Ok(());- };-- let approval_policy = AskForApproval::Granular(GranularApprovalConfig {- sandbox_approval: true,- rules: true,- skill_approval: false,- request_permissions: true,- mcp_elicitations: true,- });- let workspace_write_profile = restrictive_workspace_write_profile();- let outside_dir = tempfile::tempdir_in(std::env::current_dir()?)?;- let allowed_dir = outside_dir.path().join("allowed-output");- fs::create_dir_all(&allowed_dir)?;- let allowed_path = allowed_dir.join("allowed.txt");- let allowed_path_quoted = shlex::try_join([allowed_path.to_string_lossy().as_ref()])?;- let script_contents = format!(- "#!/bin/sh\nprintf '%s' allowed > {allowed_path_quoted}\nif [ -f {allowed_path_quoted} ]; then cat {allowed_path_quoted}; fi\n"- );- let permissions_yaml = format!(- "permissions:\n file_system:\n write:\n - \"{}\"\n",- allowed_dir.display()- );-- let server = start_mock_server().await;- let allowed_path_for_hook = allowed_path.clone();- let script_contents_for_hook = script_contents.clone();- let test = build_zsh_fork_test(- &server,- runtime,- approval_policy,- workspace_write_profile.clone(),- move |home| {- let _ = fs::remove_file(&allowed_path_for_hook);- write_skill_with_shell_script_contents(- home,- "mbolin-test-skill",- "sandboxed.sh",- &script_contents_for_hook,- )- .unwrap();- write_skill_metadata(home, "mbolin-test-skill", &permissions_yaml).unwrap();- },- )- .await?;-- let command = skill_script_command(&test, "sandboxed.sh")?;- let call_id = "zsh-fork-skill-script-ignores-permissions";- let arguments = exec_command_arguments(&command)?;- let mocks =- mount_function_call_agent_response(&server, call_id, &arguments, "exec_command").await;-- submit_turn_with_policies(- &test,- "use $mbolin-test-skill",- approval_policy,- workspace_write_profile,- )- .await?;-- let approval = wait_for_exec_approval_request(&test).await;- assert!(- approval.is_none(),- "expected skill script execution to skip the removed skill approval path"- );-- wait_for_turn_complete(&test).await;-- let call_output = mocks- .completion- .single_request()- .function_call_output(call_id);- let output = call_output["output"].as_str().unwrap_or_default();- assert!(- !output.contains("Execution denied: Execution forbidden by policy"),- "skill script should now be governed by the turn sandbox, not the removed skill approval gate: {output:?}"- );- assert!(- output_shows_sandbox_denial(output) || !output.contains("allowed"),- "expected the turn sandbox to block the out-of-workspace write, got output: {output:?}"- );- assert!(- !allowed_path.exists(),- "declared skill permissions should not widen script execution beyond the turn sandbox"- );-- Ok(())-}--#[cfg(unix)]-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]-async fn shell_zsh_fork_still_enforces_workspace_write_sandbox() -> Result<()> {- skip_if_no_network!(Ok(()));-- let Some(runtime) = zsh_fork_runtime("zsh-fork workspace sandbox test")? else {- return Ok(());- };-- let server = start_mock_server().await;- let tool_call_id = "zsh-fork-workspace-write-deny";- let outside_path = "/tmp/codex-zsh-fork-workspace-write-deny.txt";- let workspace_write_profile = restrictive_workspace_write_profile();- let _ = fs::remove_file(outside_path);- let test = build_zsh_fork_test(- &server,- runtime,- AskForApproval::Never,- workspace_write_profile.clone(),- move |_| {- let _ = fs::remove_file(outside_path);- },- )- .await?;-- let command = format!("touch {outside_path}");- let arguments = exec_command_arguments(&command)?;- let mocks =- mount_function_call_agent_response(&server, tool_call_id, &arguments, "exec_command").await;-- submit_turn_with_policies(- &test,- "write outside workspace with zsh fork",- AskForApproval::Never,- workspace_write_profile,- )- .await?;-- wait_for_turn_complete(&test).await;-- let call_output = mocks- .completion- .single_request()- .function_call_output(tool_call_id);- let output = call_output["output"].as_str().unwrap_or_default();- assert!(- output_shows_sandbox_denial(output),- "expected sandbox denial, got output: {output:?}"- );- assert!(- !Path::new(outside_path).exists(),- "command should not write outside workspace under WorkspaceWrite policy"- );-- Ok(())-}diff --git a/codex-rs/core/tests/suite/unified_exec_launch_failure_tests.rs b/codex-rs/core/tests/suite/unified_exec_launch_failure_tests.rsindex 14815a3491..501c35f8db 100644--- a/codex-rs/core/tests/suite/unified_exec_launch_failure_tests.rs+++ b/codex-rs/core/tests/suite/unified_exec_launch_failure_tests.rs@@ -80,7 +80,6 @@ async fn interrupted_one_shot_launch_failure_completes_and_persists() -> Result<),).with_config(|config| {- config.features.disable(Feature::ShellZshFork).unwrap();config.features.disable(Feature::ShellSnapshot).unwrap();config.permissions.approval_policy = Constrained::allow_any(AskForApproval::Never);configdiff --git a/codex-rs/core/tests/suite/unified_exec_stdin_approval.rs b/codex-rs/core/tests/suite/unified_exec_stdin_approval.rsindex 6df66e35ff..705eccf35e 100644--- a/codex-rs/core/tests/suite/unified_exec_stdin_approval.rs+++ b/codex-rs/core/tests/suite/unified_exec_stdin_approval.rs@@ -209,7 +209,6 @@ async fn stdin_reviews_escalated_terminal_with_denied_reads_before_delivering_in.enable(Feature::ExecPermissionApprovals).unwrap();config.features.enable(Feature::UnifiedExec).unwrap();- config.features.disable(Feature::ShellZshFork).unwrap();config.permissions.approval_policy = Constrained::allow_any(AskForApproval::OnRequest);let mut file_system = PermissionProfile::read_only().file_system_sandbox_policy();file_system.entries.push(FileSystemSandboxEntry::new(diff --git a/codex-rs/core/tests/suite/unified_exec_zsh_fork_approvals.rs b/codex-rs/core/tests/suite/unified_exec_zsh_fork_approvals.rsdeleted file mode 100644index d41e2a26a7..0000000000--- a/codex-rs/core/tests/suite/unified_exec_zsh_fork_approvals.rs+++ /dev/null@@ -1,982 +0,0 @@-use anyhow::Context;-use anyhow::Result;-use codex_config::permissions_toml::FilesystemPermissionToml;-use codex_config::permissions_toml::PermissionProfileToml;-use codex_config::types::ApprovalsReviewer;-use codex_core::TurnInputRequest;-use codex_core::config::Config;-use codex_core::sandboxing::SandboxPermissions;-use codex_extension_api::ExtensionRegistryBuilder;-use codex_features::Feature;-use codex_protocol::config_types::CollaborationMode;-use codex_protocol::config_types::ModeKind;-use codex_protocol::config_types::Settings;-use codex_protocol::models::PermissionProfile;-use codex_protocol::permissions::FileSystemAccessMode;-use codex_protocol::permissions::FileSystemPath;-use codex_protocol::permissions::FileSystemSandboxEntry;-use codex_protocol::permissions::FileSystemSandboxPolicy;-use codex_protocol::permissions::FileSystemSpecialPath;-use codex_protocol::permissions::NetworkSandboxPolicy;-use codex_protocol::protocol::AskForApproval;-use codex_protocol::protocol::EventMsg;-use codex_protocol::protocol::ExecApprovalRequestEvent;-use codex_protocol::protocol::GuardianAssessmentAction;-use codex_protocol::protocol::GuardianAssessmentStatus;-use codex_protocol::protocol::GuardianCommandSource;-use codex_protocol::protocol::Op;-use codex_protocol::protocol::ReviewDecision;-use codex_protocol::protocol::ThreadSettingsOverrides;-use codex_protocol::user_input::UserInput;-use core_test_support::responses::ResponseMock;-use core_test_support::responses::ev_assistant_message;-use core_test_support::responses::ev_completed;-use core_test_support::responses::ev_function_call;-use core_test_support::responses::ev_response_created;-use core_test_support::responses::mount_sse_once;-use core_test_support::responses::mount_sse_sequence;-use core_test_support::responses::sse;-use core_test_support::responses::start_mock_server;-use core_test_support::skip_if_no_network;-use core_test_support::test_codex::TestCodex;-use core_test_support::test_codex::local_requests;-use core_test_support::test_codex::turn_permission_fields;-use core_test_support::wait_for_event;-use core_test_support::wait_for_event_with_timeout;-use core_test_support::zsh_fork::restrictive_workspace_write_profile;-use core_test_support::zsh_fork::zsh_fork_runtime;-use core_test_support::zsh_fork::zsh_fork_test_builder;-use pretty_assertions::assert_eq;-use regex_lite::Regex;-use serde_json::Value;-use serde_json::json;-use std::fs;-use std::path::Path;-use std::sync::Arc;-use std::time::Duration;-use toml_edit::Key as TomlKey;-use wiremock::MockServer;--#[tokio::test(flavor = "multi_thread", worker_threads = 2)]-async fn unified_exec_zsh_fork_parent_approval_preserves_denied_reads() -> Result<()> {- skip_if_no_network!(Ok(()));-- let denied_dir = tempfile::tempdir_in(std::env::current_dir()?)?;- let denied_path = denied_dir.path().join("secret.env");- let secret = "unified-exec-zsh-fork-denied-read-secret";- fs::write(&denied_path, format!("{secret}\n"))?;- let permission_profile = denied_read_permission_profile(&denied_path)?;- assert!(- permission_profile- .file_system_sandbox_policy()- .has_denied_read_restrictions(),- "test must exercise a permission profile with denied reads"- );-- let approval_policy = AskForApproval::OnRequest;- let command = format!("cat {denied_path:?}");- let Some((server, test)) = build_unified_exec_zsh_fork_test_or_skip(- "unified-exec zsh-fork denied-read approval test",- approval_policy,- permission_profile,- move |_home| {},- )- .await?- else {- return Ok(());- };-- let call_id = "uexec-zsh-fork-parent-approval-denied-read";- let results = mount_unified_exec_command(- &server,- "uexec-zsh-fork-denied-read",- call_id,- &command,- "attempt a denied read for the test",- )- .await?;- submit_turn_with_session_permissions(- &test,- "run approved unified exec denied read through zsh fork",- approval_policy,- ApprovalsReviewer::User,- )- .await?;- approve_expected_exec(&test, &command).await?;- wait_for_completion_without_approval(&test).await;-- let result = command_result(&results, call_id);- assert_ne!(- result.exit_code.unwrap_or(0),- 0,- "denied-read command should stay sandboxed after parent approval"- );- assert!(- !result.stdout.contains(secret),- "denied-read command unexpectedly printed the secret: {}",- result.stdout- );-- Ok(())-}--#[tokio::test(flavor = "multi_thread", worker_threads = 2)]-async fn unified_exec_zsh_fork_parent_approval_escalates_intercepted_exec() -> Result<()> {- skip_if_no_network!(Ok(()));-- let approval_policy = AskForApproval::OnRequest;- let permission_profile = restrictive_workspace_write_profile();- let outside_dir = tempfile::tempdir_in(std::env::current_dir()?)?;- let outside_path = outside_dir- .path()- .join("unified-exec-zsh-fork-parent-approval.txt");- let command = format!("printf hi > {outside_path:?}");-- let outside_path_for_hook = outside_path.clone();- let Some((server, test)) = build_unified_exec_zsh_fork_test_or_skip(- "unified-exec zsh-fork parent approval test",- approval_policy,- permission_profile,- move |_home| {- let _ = fs::remove_file(&outside_path_for_hook);- },- )- .await?- else {- return Ok(());- };-- let call_id = "uexec-zsh-fork-parent-approval";- let results = mount_unified_exec_command(- &server,- "uexec-zsh-fork-parent-approval",- call_id,- &command,- "write outside the workspace for the test",- )- .await?;- submit_turn_with_session_permissions(- &test,- "run approved unified exec through zsh fork",- approval_policy,- ApprovalsReviewer::User,- )- .await?;- approve_expected_exec(&test, &command).await?;- wait_for_completion_without_approval(&test).await;-- let result = command_result(&results, call_id);- assert_eq!(- result.exit_code.unwrap_or(0),- 0,- "approved unified exec zsh-fork command should complete: {}",- result.stdout- );- let contents = fs::read_to_string(&outside_path)- .with_context(|| format!("read {}", outside_path.display()))?;- assert_eq!(- contents, "hi",- "approved parent sandbox override should allow zsh-fork shell redirection to write outside the workspace"- );-- Ok(())-}--#[tokio::test(flavor = "multi_thread", worker_threads = 2)]-async fn unified_exec_zsh_fork_parent_approval_keeps_explicit_prompt_rule() -> Result<()> {- skip_if_no_network!(Ok(()));-- let approval_policy = AskForApproval::OnRequest;- let permission_profile = restrictive_workspace_write_profile();- let outside_dir = tempfile::tempdir_in(std::env::current_dir()?)?;- let outside_path = outside_dir- .path()- .join("unified-exec-zsh-fork-explicit-prompt-rule.txt");- let intercepted_command = format!("touch {outside_path:?}");- let command = format!("{intercepted_command} && {intercepted_command}");- let rules = r#"prefix_rule(pattern=["touch"], decision="prompt")"#.to_string();-- let outside_path_for_hook = outside_path.clone();- let Some((server, test)) = build_unified_exec_zsh_fork_test_or_skip(- "unified-exec zsh-fork prompt rule approval test",- approval_policy,- permission_profile,- move |home| {- let _ = fs::remove_file(&outside_path_for_hook);- let rules_dir = home.join("rules");- fs::create_dir_all(&rules_dir).unwrap();- fs::write(rules_dir.join("default.rules"), &rules).unwrap();- },- )- .await?- else {- return Ok(());- };-- let call_id = "uexec-zsh-fork-parent-approval-explicit-prompt-rule";- let results = mount_unified_exec_command(- &server,- "uexec-zsh-fork-prompt-rule",- call_id,- &command,- "write outside the workspace for the test",- )- .await?;- submit_turn_with_session_permissions(- &test,- "run approved unified exec prompt rule through zsh fork",- approval_policy,- ApprovalsReviewer::User,- )- .await?;- approve_expected_exec(&test, &command).await?;-- let mut intercepted_approval_ids = Vec::new();- for _ in 0..2 {- let approval_event = wait_for_event_with_timeout(- &test.codex,- |event| {- matches!(- event,- EventMsg::ExecApprovalRequest(_) | EventMsg::TurnComplete(_)- )- },- Duration::from_secs(10),- )- .await;- let EventMsg::ExecApprovalRequest(inner_approval) = approval_event else {- panic!("expected explicit prompt rule approval before completion");- };- assert_eq!(- (- inner_approval.call_id.as_str(),- inner_approval.environment_id.as_deref(),- inner_approval.available_decisions.as_deref(),- ),- (- call_id,- Some(codex_exec_server::LOCAL_ENVIRONMENT_ID),- Some([ReviewDecision::Approved, ReviewDecision::Abort].as_slice()),- )- );- let approval_id = inner_approval- .approval_id- .as_ref()- .context("intercepted execve should have a subprocess approval id")?;- assert_ne!(approval_id, call_id);- assert!(- !intercepted_approval_ids.contains(approval_id),- "identical intercepted commands must receive distinct approval ids"- );- intercepted_approval_ids.push(approval_id.clone());- assert!(- inner_approval- .command- .iter()- .any(|arg| arg.ends_with("/touch"))- && inner_approval- .command- .iter()- .any(|arg| arg == outside_path.to_string_lossy().as_ref()),- "expected explicit prompt rule approval for intercepted touch, got: {:?}",- inner_approval.command- );-- approve_exec(&test, inner_approval.effective_approval_id()).await?;- }- wait_for_completion(&test).await;-- let result = command_result(&results, call_id);- assert_eq!(- result.exit_code.unwrap_or(0),- 0,- "approved unified exec zsh-fork prompt-rule command should complete: {}",- result.stdout- );- assert!(- outside_path.exists(),- "approved intercepted touch should create the out-of-workspace file"- );-- Ok(())-}--#[tokio::test(flavor = "multi_thread", worker_threads = 2)]-async fn unified_exec_zsh_fork_guardian_reviews_intercepted_execve() -> Result<()> {- skip_if_no_network!(Ok(()));-- let approval_policy = AskForApproval::OnRequest;- let permission_profile = restrictive_workspace_write_profile();- let outside_dir = tempfile::tempdir_in(std::env::current_dir()?)?;- let outside_path = outside_dir- .path()- .join("unified-exec-zsh-fork-guardian-execve.txt");- let command = format!("touch {outside_path:?}");- let rules = r#"prefix_rule(pattern=["touch"], decision="prompt")"#.to_string();-- let outside_path_for_hook = outside_path.clone();- let Some((server, test)) = build_unified_exec_zsh_fork_test_or_skip(- "unified-exec zsh-fork guardian execve approval test",- approval_policy,- permission_profile,- move |home| {- let _ = fs::remove_file(&outside_path_for_hook);- let rules_dir = home.join("rules");- fs::create_dir_all(&rules_dir).unwrap();- fs::write(rules_dir.join("default.rules"), &rules).unwrap();- },- )- .await?- else {- return Ok(());- };-- let call_id = "uexec-zsh-fork-guardian-execve";- let parent_tool_call = exec_command_event(- call_id,- &command,- Some(30_000),- SandboxPermissions::RequireEscalated,- "exercise Guardian review of intercepted execve",- )?;- let responses = mount_sse_sequence(- &server,- vec![- sse(vec![- ev_response_created("resp-guardian-execve-parent"),- parent_tool_call,- ev_completed("resp-guardian-execve-parent"),- ]),- sse(vec![- ev_response_created("resp-guardian-parent-review"),- ev_assistant_message("msg-guardian-parent-review", r#"{"outcome":"allow"}"#),- ev_completed("resp-guardian-parent-review"),- ]),- sse(vec![- ev_response_created("resp-guardian-execve-review"),- ev_assistant_message("msg-guardian-execve-review", r#"{"outcome":"allow"}"#),- ev_completed("resp-guardian-execve-review"),- ]),- sse(vec![- ev_response_created("resp-guardian-execve-done"),- ev_assistant_message("msg-guardian-execve-done", "done"),- ev_completed("resp-guardian-execve-done"),- ]),- ],- )- .await;-- submit_turn_with_session_permissions(- &test,- "run unified exec with an intercepted command requiring Guardian review",- approval_policy,- ApprovalsReviewer::AutoReview,- )- .await?;-- let mut intercepted_assessments = Vec::new();- loop {- let event = tokio::time::timeout(Duration::from_secs(30), test.codex.next_event())- .await- .context("timed out waiting for intercepted execve Guardian review")??;- match event.msg {- EventMsg::GuardianAssessment(assessment)- if assessment.status == GuardianAssessmentStatus::Approved- && matches!(assessment.action, GuardianAssessmentAction::Execve { .. }) =>- {- intercepted_assessments.push(assessment);- }- EventMsg::ExecApprovalRequest(_) => {- panic!("Guardian-reviewed intercepted execution must not prompt the user")- }- EventMsg::TurnComplete(_) => break,- _ => {}- }- }-- let [assessment] = intercepted_assessments.as_slice() else {- panic!(- "expected one approved intercepted execve Guardian assessment, got {intercepted_assessments:?}"- );- };- let GuardianAssessmentAction::Execve {- source,- program,- argv,- cwd,- } = &assessment.action- else {- unreachable!("intercepted assessments contain only execve actions");- };- let expected_cwd = test.config.cwd.canonicalize()?;- assert_eq!(- (- *source,- argv.as_slice(),- cwd,- assessment.target_item_id.as_deref(),- ),- (- GuardianCommandSource::UnifiedExec,- [- "touch".to_string(),- outside_path.to_string_lossy().into_owned()- ]- .as_slice(),- &expected_cwd,- Some(call_id),- )- );- assert!(- program.ends_with("/touch"),- "unexpected execve program: {program}"- );-- let guardian_requests = responses- .requests()- .into_iter()- .filter(|request| {- request.body_json()["client_metadata"]["x-openai-subagent"].as_str() == Some("guardian")- })- .collect::<Vec<_>>();- assert_eq!(guardian_requests.len(), 2);- assert!(guardian_requests[1].body_contains_text(&outside_path.to_string_lossy()));- assert!(- outside_path.exists(),- "Guardian-approved intercepted touch should create the out-of-workspace file"- );-- Ok(())-}--#[tokio::test(flavor = "multi_thread", worker_threads = 2)]-async fn unified_exec_zsh_fork_guardian_reviews_persistent_terminal_in_current_turn() -> Result<()>-{- skip_if_no_network!(Ok(()));-- let approval_policy = AskForApproval::OnRequest;- let outside_dir = tempfile::tempdir_in(std::env::current_dir()?)?;- let outside_path = outside_dir- .path()- .join("unified-exec-zsh-fork-current-turn.txt");- let initial_denied_path = outside_dir.path().join("original-environment-private");- let permission_profile = denied_read_permission_profile(&initial_denied_path)?;- let rules = r#"prefix_rule(pattern=["touch"], decision="prompt")"#.to_string();-- let outside_path_for_hook = outside_path.clone();- let Some((server, test)) = build_unified_exec_zsh_fork_test_or_skip(- "unified-exec zsh-fork current-turn guardian approval test",- approval_policy,- permission_profile,- move |home| {- let _ = fs::remove_file(&outside_path_for_hook);- let rules_dir = home.join("rules");- fs::create_dir_all(&rules_dir).unwrap();- fs::write(rules_dir.join("default.rules"), &rules).unwrap();- },- )- .await?- else {- return Ok(());- };-- let open_call_id = "uexec-zsh-fork-cross-turn-open";- let open_command = "while IFS= read -r command; do eval \"$command\"; done";- let open_args = json!({- "cmd": open_command,- "yield_time_ms": 250,- "tty": true,- "sandbox_permissions": SandboxPermissions::RequireEscalated,- "justification": "start an interactive terminal for the next turn",- });- let write_call_id = "uexec-zsh-fork-cross-turn-write";- let write_args = json!({- "chars": format!("touch {outside_path:?}\nexit\n"),- "session_id": 1000,- "yield_time_ms": 5_000,- });- let responses = mount_sse_sequence(- &server,- vec![- sse(vec![- ev_response_created("resp-cross-turn-open"),- ev_function_call(- open_call_id,- "exec_command",- &serde_json::to_string(&open_args)?,- ),- ev_completed("resp-cross-turn-open"),- ]),- sse(vec![- ev_response_created("resp-cross-turn-first-done"),- ev_assistant_message("msg-cross-turn-first-done", "terminal is running"),- ev_completed("resp-cross-turn-first-done"),- ]),- sse(vec![- ev_response_created("resp-cross-turn-write"),- ev_function_call(- write_call_id,- "write_stdin",- &serde_json::to_string(&write_args)?,- ),- ev_completed("resp-cross-turn-write"),- ]),- sse(vec![- ev_response_created("resp-cross-turn-write-guardian"),- ev_assistant_message("msg-cross-turn-write-guardian", r#"{"outcome":"allow"}"#),- ev_completed("resp-cross-turn-write-guardian"),- ]),- sse(vec![- ev_response_created("resp-cross-turn-execve-guardian"),- ev_assistant_message("msg-cross-turn-execve-guardian", r#"{"outcome":"allow"}"#),- ev_completed("resp-cross-turn-execve-guardian"),- ]),- sse(vec![- ev_response_created("resp-cross-turn-second-done"),- ev_assistant_message("msg-cross-turn-second-done", "done"),- ev_completed("resp-cross-turn-second-done"),- ]),- ],- )- .await;-- submit_turn_with_session_permissions(- &test,- "start a persistent terminal with user approvals",- approval_policy,- ApprovalsReviewer::User,- )- .await?;- approve_expected_exec(&test, open_command).await?;- let first_completion = wait_for_event(&test.codex, |event| {- matches!(event, EventMsg::TurnComplete(_))- })- .await;- let EventMsg::TurnComplete(first_completion) = first_completion else {- unreachable!("completion wait only returns turn-complete events");- };-- let next_cwd = test.config.cwd.join("next-turn");- fs::create_dir(&next_cwd)?;- let next_denied_path = next_cwd.join("next-environment-private");- let (sandbox_policy, permission_profile) = turn_permission_fields(- denied_read_permission_profile(next_denied_path.as_path())?,- next_cwd.as_path(),- );- test.codex- .start_or_steer_turn(- TurnInputRequest::user_input(vec![UserInput::Text {- text: "run a command in the persistent terminal with Guardian approvals".into(),- text_elements: Vec::new(),- }])- .with_thread_settings(ThreadSettingsOverrides {- environments: Some(local_requests(next_cwd)),- approvals_reviewer: Some(ApprovalsReviewer::AutoReview),- sandbox_policy: Some(sandbox_policy),- permission_profile,- ..Default::default()- }),- )- .await?;-- let mut current_turn_id = None;- let mut stdin_assessment = None;- let mut intercepted_assessment = None;- loop {- let event = tokio::time::timeout(Duration::from_secs(30), test.codex.next_event())- .await- .context("timed out waiting for current-turn intercepted execve Guardian review")??;- match event.msg {- EventMsg::TurnStarted(started) => current_turn_id = Some(started.turn_id),- EventMsg::GuardianAssessment(assessment)- if assessment.status == GuardianAssessmentStatus::Approved- && matches!(- &assessment.action,- GuardianAssessmentAction::WriteStdin { approval_id, .. }- if approval_id == write_call_id- ) =>- {- stdin_assessment = Some(assessment);- }- EventMsg::GuardianAssessment(assessment)- if assessment.status == GuardianAssessmentStatus::Approved- && matches!(assessment.action, GuardianAssessmentAction::Execve { .. }) =>- {- intercepted_assessment = Some(assessment);- }- EventMsg::ExecApprovalRequest(_) => {- panic!("persistent-terminal approval used the previous turn's user reviewer")- }- EventMsg::TurnComplete(_) => break,- _ => {}- }- }-- let current_turn_id = current_turn_id.context("expected the second turn to start")?;- assert_ne!(current_turn_id, first_completion.turn_id);- let stdin_assessment =- stdin_assessment.context("expected an approved Guardian assessment for stdin")?;- assert_eq!(- (- stdin_assessment.turn_id.as_str(),- stdin_assessment.target_item_id.as_deref(),- ),- (current_turn_id.as_str(), Some(open_call_id)),- );- let assessment = intercepted_assessment- .context("expected an approved Guardian assessment for the persistent terminal")?;- assert_eq!(assessment.turn_id, current_turn_id);- assert_eq!(assessment.target_item_id.as_deref(), Some(open_call_id));- assert!(- outside_path.exists(),- "Guardian-approved command from the second turn should create the file"- );-- let guardian_requests = responses- .requests()- .into_iter()- .filter(|request| {- request.body_json()["client_metadata"]["x-openai-subagent"].as_str() == Some("guardian")- })- .collect::<Vec<_>>();- assert_eq!(guardian_requests.len(), 2);- assert!(guardian_requests[0].body_contains_text(&outside_path.to_string_lossy()));- let environment_id = &test.executor_environment().selection().environment_id;- let environment = format!(r#""environment_id": "{environment_id}""#);- assert!(guardian_requests[0].body_contains_text(&environment));- assert!(guardian_requests[0].body_contains_text("The `cwd` field is its launch directory"));- assert!(guardian_requests[1].body_contains_text(&outside_path.to_string_lossy()));- let guardian_text = guardian_requests[1].message_input_texts("user").join("");- let permissions = guardian_text- .split_once("PARENT TURN PERMISSION CONTEXT START")- .and_then(|(_, text)| text.split_once("PARENT TURN PERMISSION CONTEXT END"))- .map(|(permissions, _)| permissions)- .context("intercepted command's Guardian permissions")?;- assert!(permissions.contains(initial_denied_path.to_string_lossy().as_ref()));- assert!(!permissions.contains(next_denied_path.to_string_lossy().as_ref()));-- Ok(())-}--struct CommandResult {- exit_code: Option<i64>,- stdout: String,-}--async fn build_unified_exec_zsh_fork_test_or_skip<F>(- test_name: &str,- approval_policy: AskForApproval,- permission_profile: PermissionProfile,- pre_build_hook: F,-) -> Result<Option<(MockServer, TestCodex)>>-where- F: FnOnce(&Path) + Send + 'static,-{- let Some(runtime) = zsh_fork_runtime(test_name)? else {- return Ok(None);- };-- struct ExecveIdentityCheck;-- impl codex_extension_api::ApprovalReviewContributor for ExecveIdentityCheck {- fn decide<'a>(- &'a self,- input: &'a codex_extension_api::ApprovalDecisionInput<'_>,- ) -> codex_extension_api::ExtensionFuture<'a, Option<codex_extension_api::ApprovalDecision>>- {- if input.action.get("program").is_some() {- assert_eq!(input.tool_call_id, None);- }- Box::pin(async { None })- }- }-- let mut extensions = ExtensionRegistryBuilder::<Config>::new();- extensions.approval_review_contributor(Arc::new(ExecveIdentityCheck));- let server = start_mock_server().await;- let test = zsh_fork_test_builder(runtime, approval_policy)- .with_extensions(Arc::new(extensions.build()))- .with_pre_build_hook(pre_build_hook)- .with_config(move |config| {- config- .permissions- .set_permission_profile(permission_profile)- .expect("set permission profile");- assert!(config.features.enable(Feature::WriteStdinApproval).is_ok());- })- .build(&server)- .await?;- Ok(Some((server, test)))-}--fn denied_read_permission_profile(denied_path: &Path) -> Result<PermissionProfile> {- let denied_path_key = TomlKey::new(denied_path.to_string_lossy().into_owned());- permission_profile_from_toml(&format!(- r#"-[filesystem]-"/" = "read"-":project_roots" = "write"-{denied_path_key} = "deny"--[network]-enabled = false-"#- ))-}--fn permission_profile_from_toml(profile: &str) -> Result<PermissionProfile> {- let profile = toml::from_str::<PermissionProfileToml>(profile)- .context("test permission profile should deserialize")?;- let filesystem = profile- .filesystem- .as_ref()- .context("test permission profile should include filesystem entries")?;- let entries = filesystem- .entries- .iter()- .map(|(path, permission)| {- let FilesystemPermissionToml::Access(access) = permission else {- anyhow::bail!("unexpected scoped filesystem permission in test profile: {path}");- };- let path = match path.as_str() {- "/" => FileSystemPath::Special {- value: FileSystemSpecialPath::Root,- },- ":project_roots" => FileSystemPath::Special {- value: FileSystemSpecialPath::project_roots(/*subpath*/ None),- },- _ if *access == FileSystemAccessMode::Deny => FileSystemPath::GlobPattern {- pattern: path.clone(),- },- _ => anyhow::bail!("unexpected filesystem entry in test profile: {path}"),- };- Ok(FileSystemSandboxEntry {- path,- access: *access,- missing_path_behavior: None,- })- })- .collect::<Result<Vec<_>>>()?;- let mut file_system_sandbox_policy = FileSystemSandboxPolicy::restricted(entries);- file_system_sandbox_policy.glob_scan_max_depth = filesystem.glob_scan_max_depth;- let network_sandbox_policy = match profile.network.as_ref().and_then(|network| network.enabled)- {- Some(true) => NetworkSandboxPolicy::Enabled,- Some(false) | None => NetworkSandboxPolicy::Restricted,- };-- Ok(PermissionProfile::from_runtime_permissions(- &file_system_sandbox_policy,- network_sandbox_policy,- ))-}--async fn mount_unified_exec_command(- server: &MockServer,- response_prefix: &str,- call_id: &str,- command: &str,- justification: &str,-) -> Result<ResponseMock> {- let first_response_id = format!("resp-{response_prefix}-1");- let second_response_id = format!("resp-{response_prefix}-2");- let message_id = format!("msg-{response_prefix}-1");- let event = exec_command_event(- call_id,- command,- Some(30_000),- SandboxPermissions::RequireEscalated,- justification,- )?;- let _ = mount_sse_once(- server,- sse(vec![- ev_response_created(&first_response_id),- event,- ev_completed(&first_response_id),- ]),- )- .await;- let results = mount_sse_once(- server,- sse(vec![- ev_assistant_message(&message_id, "done"),- ev_completed(&second_response_id),- ]),- )- .await;- Ok(results)-}--async fn submit_turn_with_session_permissions(- test: &TestCodex,- prompt: &str,- approval_policy: AskForApproval,- approvals_reviewer: ApprovalsReviewer,-) -> Result<()> {- let session_model = test.session_configured.model.clone();- let (sandbox_policy, permission_profile) = turn_permission_fields(- test.session_configured.permission_profile.clone(),- test.cwd.path(),- );- test.codex- .start_or_steer_turn(- TurnInputRequest::user_input(vec![UserInput::Text {- text: prompt.into(),- text_elements: Vec::new(),- }])- .with_thread_settings(ThreadSettingsOverrides {- environments: Some(local_requests(test.config.cwd.clone())),- approval_policy: Some(approval_policy),- approvals_reviewer: Some(approvals_reviewer),- sandbox_policy: Some(sandbox_policy),- permission_profile,- collaboration_mode: Some(CollaborationMode {- mode: ModeKind::Default,- settings: Settings {- model: session_model,- reasoning_effort: None,- developer_instructions: None,- },- }),- ..Default::default()- }),- )- .await?;-- Ok(())-}--async fn approve_expected_exec(test: &TestCodex, expected_command: &str) -> Result<()> {- let approval = expect_exec_approval(test, expected_command).await;- approve_exec(test, approval.effective_approval_id()).await-}--async fn approve_exec(test: &TestCodex, approval_id: String) -> Result<()> {- test.codex- .submit(Op::ExecApproval {- id: approval_id,- turn_id: None,- decision: ReviewDecision::Approved,- })- .await?;- Ok(())-}--fn command_result(results: &ResponseMock, call_id: &str) -> CommandResult {- parse_result(&results.single_request().function_call_output(call_id))-}--fn exec_command_event(- call_id: &str,- cmd: &str,- yield_time_ms: Option<u64>,- sandbox_permissions: SandboxPermissions,- justification: &str,-) -> Result<Value> {- let mut args = json!({- "cmd": cmd.to_string(),- });- if let Some(yield_time_ms) = yield_time_ms {- args["yield_time_ms"] = json!(yield_time_ms);- }- if sandbox_permissions.requests_sandbox_override() {- args["sandbox_permissions"] = json!(sandbox_permissions);- args["justification"] = json!(justification);- }- let args_str = serde_json::to_string(&args)?;- Ok(ev_function_call(call_id, "exec_command", &args_str))-}--fn parse_result(item: &Value) -> CommandResult {- let Some(output_str) = item.get("output").and_then(Value::as_str) else {- return CommandResult {- exit_code: None,- stdout: String::new(),- };- };- match serde_json::from_str::<Value>(output_str) {- Ok(parsed) => {- let exit_code = parsed["metadata"]["exit_code"].as_i64();- let stdout = parsed["output"].as_str().unwrap_or_default().to_string();- CommandResult { exit_code, stdout }- }- Err(_) => parsed_regex_result(r"(?s)^Exit code:\s*(-?\d+).*?Output:\n(.*)$", output_str)- .or_else(|| {- parsed_regex_result(- r"(?s)^.*?Process exited with code (\d+)\n.*?Output:\n(.*)$",- output_str,- )- })- .unwrap_or_else(|| CommandResult {- exit_code: None,- stdout: output_str.to_string(),- }),- }-}--fn parsed_regex_result(pattern: &str, output_str: &str) -> Option<CommandResult> {- let regex = Regex::new(pattern).ok()?;- let captures = regex.captures(output_str)?;- let exit_code = captures.get(1)?.as_str().parse::<i64>().ok()?;- let output = captures.get(2)?.as_str();- Some(CommandResult {- exit_code: Some(exit_code),- stdout: output.to_string(),- })-}--async fn expect_exec_approval(- test: &TestCodex,- expected_command: &str,-) -> ExecApprovalRequestEvent {- let event = wait_for_event(&test.codex, |event| {- matches!(- event,- EventMsg::ExecApprovalRequest(_) | EventMsg::TurnComplete(_)- )- })- .await;-- match event {- EventMsg::ExecApprovalRequest(approval) => {- let last_arg = approval- .command- .last()- .map(std::string::String::as_str)- .unwrap_or_default();- assert_eq!(- last_arg, expected_command,- "approval request should be for the parent unified-exec command"- );- approval- }- EventMsg::TurnComplete(_) => panic!("expected approval request before completion"),- other => panic!("unexpected event: {other:?}"),- }-}--async fn wait_for_completion_without_approval(test: &TestCodex) {- let event = wait_for_event(&test.codex, |event| {- matches!(- event,- EventMsg::ExecApprovalRequest(_) | EventMsg::TurnComplete(_)- )- })- .await;-- match event {- EventMsg::TurnComplete(_) => {}- EventMsg::ExecApprovalRequest(event) => {- panic!("unexpected approval request: {:?}", event.command)- }- other => panic!("unexpected event: {other:?}"),- }-}--async fn wait_for_completion(test: &TestCodex) {- wait_for_event(&test.codex, |event| {- matches!(event, EventMsg::TurnComplete(_))- })- .await;-}diff --git a/codex-rs/exec/src/lib.rs b/codex-rs/exec/src/lib.rsindex ee7f379a97..df8e3bc53d 100644--- a/codex-rs/exec/src/lib.rs+++ b/codex-rs/exec/src/lib.rs@@ -600,8 +600,7 @@ pub async fn run_main(cli: Cli, arg0_paths: Arg0DispatchPaths) -> anyhow::Resultservice_tier: None,codex_self_exe: arg0_paths.codex_self_exe.clone(),codex_linux_sandbox_exe: arg0_paths.codex_linux_sandbox_exe.clone(),- main_execve_wrapper_exe: arg0_paths.main_execve_wrapper_exe.clone(),- default_zsh_path: None,+ main_execve_wrapper_exe: None,base_instructions: None,developer_instructions: None,personality: None,diff --git a/codex-rs/exec/tests/suite/apply_patch.rs b/codex-rs/exec/tests/suite/apply_patch.rsindex 8376b2e765..66c485d02b 100644--- a/codex-rs/exec/tests/suite/apply_patch.rs+++ b/codex-rs/exec/tests/suite/apply_patch.rs@@ -5,9 +5,11 @@ use assert_cmd::prelude::*;use codex_apply_patch::CODEX_CORE_APPLY_PATCH_ARG1;use core_test_support::responses::ev_apply_patch_custom_tool_call;use core_test_support::responses::ev_completed;+use core_test_support::responses::ev_exec_command_call_with_args;use core_test_support::responses::mount_sse_sequence;use core_test_support::responses::sse;use core_test_support::responses::start_mock_server;+use pretty_assertions::assert_eq;use std::fs;use std::process::Command;use tempfile::tempdir;@@ -92,6 +94,101 @@ async fn test_apply_patch_tool() -> anyhow::Result<()> {Ok(())}+#[cfg(unix)]+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]+async fn nested_apply_patch_alias_works_with_restricted_reads() -> anyhow::Result<()> {+ use core_test_support::skip_if_no_network;+ use core_test_support::skip_if_sandbox;+ use core_test_support::test_codex_exec::test_codex_exec;++ skip_if_no_network!(Ok(()));+ skip_if_sandbox!(Ok(()));+ #[cfg(target_os = "linux")]+ if super::sandbox::linux_sandbox_test_env().await.is_none() {+ return Ok(());+ }+ let test = test_codex_exec();+ let binary = codex_utils_cargo_bin::cargo_bin("codex-exec")?.canonicalize()?;+ let binary_dir = serde_json::to_string(binary.parent().expect("binary directory"))?;+ let codex_home = serde_json::to_string(test.home_path())?;+ fs::write(+ test.home_path().join("config.toml"),+ format!(+ r#"default_permissions = "aliases"+approval_policy = "never"+[features]+shell_snapshot = false+shell_snapshot_v2 = false+[permissions.aliases.filesystem]+":minimal" = "read"+":project_roots" = "write"+{binary_dir} = "read"+{codex_home} = "none"+"#+ ),+ )?;+ fs::write(+ test.home_path().join("outside-workspace.txt"),+ "must remain unreadable to the script",+ )?;+ fs::write(+ test.cwd_path().join("patch.sh"),+ "if cat \"$HOME/outside-workspace.txt\" >/dev/null 2>&1; then exit 99; fi\napply_patch <<'PATCH'\n*** Begin Patch\n*** Add File: patched.txt\n+through the nested alias\n*** End Patch\nPATCH\n",+ )?;+ let server = start_mock_server().await;+ let mock = mount_sse_sequence(+ &server,+ vec![+ sse(vec![+ ev_exec_command_call_with_args(+ "nested-patch",+ &serde_json::json!({+ "cmd": "/bin/sh patch.sh",+ "shell": "/bin/sh",+ "login": false,+ "yield_time_ms": 10_000,+ }),+ ),+ ev_completed("response-1"),+ ]),+ sse(vec![ev_completed("response-2")]),+ ],+ )+ .await;+ let run = test.cmd_with_server(&server)+ .env("HOME", test.home_path())+ .env_remove("CODEX_API_KEY")+ .env_remove("OPENAI_API_KEY")+ .arg("--skip-git-repo-check")+ .arg("-c")+ .arg("default_permissions=\"aliases\"")+ .arg("-c")+ .arg("approvals_reviewer=\"user\"")+ .arg("-c")+ .arg("model_provider=\"test\"")+ .arg("-c")+ .arg(format!(+ "model_providers.test={{name=\"test\",base_url={:?},wire_api=\"responses\",requires_openai_auth=false,supports_websockets=false}}",+ format!("{}/v1", server.uri())+ ))+ .arg("run the patch script")+ .assert()+ .success();+ let output = mock+ .function_call_output_text("nested-patch")+ .expect("tool output");+ assert!(+ output.contains("Process exited with code 0"),+ "{output}\n{}",+ String::from_utf8_lossy(&run.get_output().stderr)+ );+ assert_eq!(+ fs::read_to_string(test.cwd_path().join("patched.txt"))?,+ "through the nested alias\n"+ );+ Ok(())+}+#[cfg(not(target_os = "windows"))]#[tokio::test(flavor = "multi_thread", worker_threads = 4)]async fn test_apply_patch_freeform_tool() -> anyhow::Result<()> {diff --git a/codex-rs/exec/tests/suite/sandbox.rs b/codex-rs/exec/tests/suite/sandbox.rsindex d2eb241e9e..5f3b545813 100644--- a/codex-rs/exec/tests/suite/sandbox.rs+++ b/codex-rs/exec/tests/suite/sandbox.rs@@ -101,7 +101,7 @@ pub(super) async fn spawn_command_under_sandbox(/// under the production Landlock path and skip when enforcement is unavailable/// (for example on kernels or container profiles where Landlock is not/// enforced).-async fn linux_sandbox_test_env() -> Option<HashMap<String, String>> {+pub(super) async fn linux_sandbox_test_env() -> Option<HashMap<String, String>> {let command_cwd = AbsolutePathBuf::current_dir().ok()?;let sandbox_cwd = command_cwd.clone();let permission_profile = PermissionProfile::read_only();diff --git a/codex-rs/features/src/lib.rs b/codex-rs/features/src/lib.rsindex f9147628f0..8d67b47787 100644--- a/codex-rs/features/src/lib.rs+++ b/codex-rs/features/src/lib.rs@@ -148,13 +148,9 @@ pub enum Feature {UnifiedExec,/// Allow unified exec commands to allocate an interactive terminal.UnifiedExecTty,- /// Route shell tool execution through the zsh exec bridge.+ /// Removed compatibility flag for the retired patched zsh backend.ShellZshFork,- /// Allow unified exec to compose with the zsh exec bridge.- ///- /// This flag is only a composition gate. Enabling it by itself must not turn- /// on either `unified_exec` or `shell_zsh_fork` because those features have- /// separate rollout and enterprise controls.+ /// Removed compatibility flag for the retired patched zsh backend.UnifiedExecZshFork,/// Removed compatibility flag. Transcript scrollback reflow on terminal resize is always on.TerminalResizeReflow,@@ -639,6 +635,17 @@ impl Features {Feature::WebSearchCached,);}+ "shell_zsh_fork" => {+ self.record_legacy_usage_force("shell_zsh_fork", Feature::ShellZshFork);+ continue;+ }+ "unified_exec_zsh_fork" => {+ self.record_legacy_usage_force(+ "unified_exec_zsh_fork",+ Feature::UnifiedExecZshFork,+ );+ continue;+ }"transcript_v2" => {self.record_legacy_usage_force("features.transcript_v2", Feature::TranscriptV2);continue;@@ -754,6 +761,10 @@ impl Features {fn legacy_usage_notice(alias: &str, feature: Feature) -> (String, Option<String>) {let canonical = feature.key();match feature {+ Feature::ShellZshFork | Feature::UnifiedExecZshFork => (+ format!("`[features].{canonical}` is deprecated and ignored."),+ Some(format!("The patched zsh backend has been removed. Shell commands now use the standard shell executor. Remove `{canonical}` from [features] in config.toml or profile configuration files.")),+ ),Feature::GuardianThreadContext => ("`[features.guardianv2].thread_context` is deprecated and ignored.".to_string(),Some("Thread-owned Guardian context is always enabled. Remove `thread_context` from [features.guardianv2] in config.toml, including profile overrides.".to_string()),@@ -1048,14 +1059,14 @@ pub const FEATURES: &[FeatureSpec] = &[FeatureSpec {id: Feature::ShellZshFork,key: "shell_zsh_fork",- stage: Stage::UnderDevelopment,+ stage: Stage::Removed,default_enabled: false,},FeatureSpec {id: Feature::UnifiedExecZshFork,key: "unified_exec_zsh_fork",stage: Stage::Removed,- default_enabled: true,+ default_enabled: false,},FeatureSpec {id: Feature::ShellSnapshot,diff --git a/codex-rs/install-context/src/lib.rs b/codex-rs/install-context/src/lib.rsindex 1a9be86a11..899211bcb2 100644--- a/codex-rs/install-context/src/lib.rs+++ b/codex-rs/install-context/src/lib.rs@@ -18,7 +18,6 @@ const PATH_DIRNAME: &str = "codex-path";const RELEASES_DIRNAME: &str = "releases";const RESOURCES_DIRNAME: &str = "codex-resources";const STANDALONE_PACKAGES_DIRNAME: &str = "standalone";-const ZSH_DIRNAME: &str = "zsh";static INSTALL_CONTEXT: OnceLock<InstallContext> = OnceLock::new();#[derive(Clone, Copy, Debug, Eq, PartialEq)]@@ -228,18 +227,6 @@ impl InstallContext {None}-- pub fn bundled_zsh_path(&self) -> Option<AbsolutePathBuf> {- if cfg!(windows) {- None- } else {- self.bundled_resource(zsh_resource_path())- }- }-- pub fn bundled_zsh_bin_dir(&self) -> Option<AbsolutePathBuf> {- self.bundled_zsh_path()?.parent()- }}impl CodexPackageLayout {@@ -371,10 +358,6 @@ fn default_rg_command() -> PathBuf {}}-fn zsh_resource_path() -> PathBuf {- PathBuf::from(ZSH_DIRNAME).join(BIN_DIRNAME).join("zsh")-}-#[cfg(test)]#[path = "bundle_tests.rs"]mod bundle_tests;@@ -572,11 +555,6 @@ mod tests {fs::write(bin_dir.join(CODE_MODE_HOST_EXECUTABLE_NAME), "")?;fs::write(resources_dir.join(TEST_RESOURCE_NAME), "")?;fs::write(path_dir.join(default_rg_command()), "")?;- if !cfg!(windows) {- let zsh_path = resources_dir.join(zsh_resource_path());- fs::create_dir_all(zsh_path.parent().expect("zsh path should have parent"))?;- fs::write(&zsh_path, "")?;- }let canonical_package_dir =AbsolutePathBuf::from_absolute_path(package_dir.path().canonicalize()?)?;let canonical_bin_dir = AbsolutePathBuf::from_absolute_path(bin_dir.canonicalize()?)?;@@ -631,19 +609,6 @@ mod tests {context.bundled_resource(TEST_RESOURCE_NAME),Some(canonical_resources_dir.join(TEST_RESOURCE_NAME)));- if cfg!(windows) {- assert_eq!(context.bundled_zsh_path(), None);- assert_eq!(context.bundled_zsh_bin_dir(), None);- } else {- assert_eq!(- context.bundled_zsh_path(),- Some(canonical_resources_dir.join(zsh_resource_path()))- );- assert_eq!(- context.bundled_zsh_bin_dir(),- Some(canonical_resources_dir.join(ZSH_DIRNAME).join(BIN_DIRNAME))- );- }Ok(())}diff --git a/codex-rs/shell-command/src/shell_snapshot_exports.rs b/codex-rs/shell-command/src/shell_snapshot_exports.rsindex 491ba09375..96ac267eb2 100644--- a/codex-rs/shell-command/src/shell_snapshot_exports.rs+++ b/codex-rs/shell-command/src/shell_snapshot_exports.rs@@ -21,7 +21,7 @@ pub(super) fn script(shell_type: ShellType) -> String {ShellType::Zsh => {r#"(unsetopt rcquotes- # The bundled Zsh does not include the zsh/parameter module.+ # Some Zsh builds do not include the zsh/parameter module.for __codex_snapshot_export_name in ${(f)"$(typeset +x)"}; docase "$__codex_snapshot_export_name" in""|[0-9]*|*[!A-Za-z0-9_]*|PWD|OLDPWD) continue ;;diff --git a/codex-rs/shell-escalation/BUILD.bazel b/codex-rs/shell-escalation/BUILD.bazeldeleted file mode 100644index 5092f33324..0000000000--- a/codex-rs/shell-escalation/BUILD.bazel+++ /dev/null@@ -1,6 +0,0 @@-load("//:defs.bzl", "codex_rust_crate")--codex_rust_crate(- name = "shell-escalation",- crate_name = "codex_shell_escalation",-)diff --git a/codex-rs/shell-escalation/Cargo.toml b/codex-rs/shell-escalation/Cargo.tomldeleted file mode 100644index 92ae8b033f..0000000000--- a/codex-rs/shell-escalation/Cargo.toml+++ /dev/null@@ -1,41 +0,0 @@-[package]-edition.workspace = true-license.workspace = true-name = "codex-shell-escalation"-version.workspace = true--[[bin]]-name = "codex-execve-wrapper"-path = "src/bin/main_execve_wrapper.rs"--[lints]-workspace = true--[dependencies]-anyhow = { workspace = true }-clap = { workspace = true, features = ["derive"] }-codex-protocol = { workspace = true }-codex-utils-absolute-path = { workspace = true }-libc = { workspace = true }-serde = { workspace = true, features = ["derive"] }-serde_json = { workspace = true }-socket2 = { workspace = true, features = ["all"] }-tokio = { workspace = true, features = [- "io-std",- "net",- "macros",- "process",- "rt-multi-thread",- "signal",- "time",-] }-tokio-util = { workspace = true }-tracing = { workspace = true }-tracing-subscriber = { workspace = true, features = ["env-filter", "fmt"] }--[dev-dependencies]-pretty_assertions = { workspace = true }-tempfile = { workspace = true }--[lib]-doctest = falsediff --git a/codex-rs/shell-escalation/README.md b/codex-rs/shell-escalation/README.mddeleted file mode 100644index 69cd038220..0000000000--- a/codex-rs/shell-escalation/README.md+++ /dev/null@@ -1,34 +0,0 @@-# codex-shell-escalation--This crate contains the Unix shell-escalation protocol implementation and the-`codex-execve-wrapper` executable.--`codex-execve-wrapper` receives the arguments to an intercepted `execve(2)` call and delegates the-decision to the shell-escalation protocol over a shared file descriptor (specified by the-`CODEX_ESCALATE_SOCKET` environment variable). The server on the other side replies with one of:--- `Run`: `codex-execve-wrapper` should invoke `execve(2)` on itself to run the original command- within the sandboxed shell.-- `Escalate`: forward the file descriptors of the current process so the command can be run- faithfully outside the sandbox. When the process completes, the server forwards the exit code- back to `codex-execve-wrapper`.-- `Deny`: the server has declared the proposed command to be forbidden, so- `codex-execve-wrapper` prints an error to `stderr` and exits with `1`.--## Patched zsh--We carry a small patch to `Src/exec.c` (see `patches/zsh-exec-wrapper.patch`) that adds support for `EXEC_WRAPPER`. The patch applies to `77045ef899e53b9598bebc5a41db93a548a40ca6` from https://git.code.sf.net/p/zsh/code. To rebuild manually:--```bash-git clone https://git.code.sf.net/p/zsh/code-git checkout 77045ef899e53b9598bebc5a41db93a548a40ca6-git apply /path/to/patches/zsh-exec-wrapper.patch-./Util/preconfig-./configure-make -j"$(nproc)"-```--Release artifacts are built by `.github/workflows/rust-release-zsh.yml` when a-`codex-zsh-vX.Y.Z` tag is pushed. When the zsh commit or patch changes, publish-the next version tag and update the checked-in DotSlash manifests to use the new-release.diff --git a/codex-rs/shell-escalation/patches/zsh-exec-wrapper.patch b/codex-rs/shell-escalation/patches/zsh-exec-wrapper.patchdeleted file mode 100644index 99cdcadcb2..0000000000--- a/codex-rs/shell-escalation/patches/zsh-exec-wrapper.patch+++ /dev/null@@ -1,34 +0,0 @@-diff --git a/Src/exec.c b/Src/exec.c-index 27bca11..baea760 100644---- a/Src/exec.c-+++ b/Src/exec.c-@@ -507,7 +507,9 @@ zexecve(char *pth, char **argv, char **newenvp)- {- int eno;- static char buf[PATH_MAX * 2+1];-- char **eep;-+ char **eep, **exec_argv;-+ char *orig_pth = pth;-+ char *exec_wrapper;-- unmetafy(pth, NULL);- for (eep = argv; *eep; eep++)-@@ -526,8 +528,17 @@ zexecve(char *pth, char **argv, char **newenvp)-- if (newenvp == NULL)- newenvp = environ;-+ exec_argv = argv;-+ if ((exec_wrapper = getenv("EXEC_WRAPPER")) &&-+ *exec_wrapper && !inblank(*exec_wrapper)) {-+ exec_argv = argv - 2;-+ exec_argv[0] = exec_wrapper;-+ exec_argv[1] = orig_pth;-+ pth = exec_wrapper;-+ }- winch_unblock();-- execve(pth, argv, newenvp);-+ execve(pth, exec_argv, newenvp);-+ pth = orig_pth;-- /* If the execve returns (which in general shouldn't happen), *- * then check for an errno equal to ENOEXEC. This errno is set *diff --git a/codex-rs/shell-escalation/src/bin/main_execve_wrapper.rs b/codex-rs/shell-escalation/src/bin/main_execve_wrapper.rsdeleted file mode 100644index ab459a311e..0000000000--- a/codex-rs/shell-escalation/src/bin/main_execve_wrapper.rs+++ /dev/null@@ -1,8 +0,0 @@-#[cfg(not(unix))]-fn main() {- eprintln!("codex-execve-wrapper is only implemented for UNIX");- std::process::exit(1);-}--#[cfg(unix)]-pub use codex_shell_escalation::main_execve_wrapper as main;diff --git a/codex-rs/shell-escalation/src/lib.rs b/codex-rs/shell-escalation/src/lib.rsdeleted file mode 100644index 53a55c4d83..0000000000--- a/codex-rs/shell-escalation/src/lib.rs+++ /dev/null@@ -1,39 +0,0 @@-#[cfg(unix)]-mod unix;--#[cfg(unix)]-pub use unix::ESCALATE_SOCKET_ENV_VAR;-#[cfg(unix)]-pub use unix::EscalateAction;-#[cfg(unix)]-pub use unix::EscalateServer;-#[cfg(unix)]-pub use unix::EscalationDecision;-#[cfg(unix)]-pub use unix::EscalationExecution;-#[cfg(unix)]-pub use unix::EscalationPermissions;-#[cfg(unix)]-pub use unix::EscalationPolicy;-#[cfg(unix)]-pub use unix::EscalationPolicyFuture;-#[cfg(unix)]-pub use unix::EscalationSession;-#[cfg(unix)]-pub use unix::ExecParams;-#[cfg(unix)]-pub use unix::ExecResult;-#[cfg(unix)]-pub use unix::PreparedExec;-#[cfg(unix)]-pub use unix::ResolvedPermissionProfile;-#[cfg(unix)]-pub use unix::ShellCommandExecutor;-#[cfg(unix)]-pub use unix::ShellCommandExecutorFuture;-#[cfg(unix)]-pub use unix::Stopwatch;-#[cfg(unix)]-pub use unix::main_execve_wrapper;-#[cfg(unix)]-pub use unix::run_shell_escalation_execve_wrapper;diff --git a/codex-rs/shell-escalation/src/unix/escalate_client.rs b/codex-rs/shell-escalation/src/unix/escalate_client.rsdeleted file mode 100644index 0f98883865..0000000000--- a/codex-rs/shell-escalation/src/unix/escalate_client.rs+++ /dev/null@@ -1,144 +0,0 @@-use std::io;-use std::os::fd::AsFd;-use std::os::fd::AsRawFd;-use std::os::fd::OwnedFd;--use anyhow::Context as _;-use codex_utils_absolute_path::AbsolutePathBuf;--use crate::unix::escalate_protocol::ESCALATE_SOCKET_ENV_VAR;-use crate::unix::escalate_protocol::EXEC_WRAPPER_ENV_VAR;-use crate::unix::escalate_protocol::EscalateAction;-use crate::unix::escalate_protocol::EscalateRequest;-use crate::unix::escalate_protocol::EscalateResponse;-use crate::unix::escalate_protocol::SuperExecMessage;-use crate::unix::escalate_protocol::SuperExecResult;-use crate::unix::socket::AsyncDatagramSocket;-use crate::unix::socket::AsyncSocket;--fn get_escalate_client() -> anyhow::Result<AsyncDatagramSocket> {- // TODO: we should defensively require only calling this once, since AsyncSocket will take ownership of the fd.- let client_fd = std::env::var(ESCALATE_SOCKET_ENV_VAR)?.parse::<i32>()?;- if client_fd < 0 {- return Err(anyhow::anyhow!(- "{ESCALATE_SOCKET_ENV_VAR} is not a valid file descriptor: {client_fd}"- ));- }- Ok(unsafe { AsyncDatagramSocket::from_raw_fd(client_fd) }?)-}--fn duplicate_fd_for_transfer(fd: impl AsFd, name: &str) -> anyhow::Result<OwnedFd> {- fd.as_fd()- .try_clone_to_owned()- .with_context(|| format!("failed to duplicate {name} for escalation transfer"))-}--pub async fn run_shell_escalation_execve_wrapper(- file: String,- argv: Vec<String>,-) -> anyhow::Result<i32> {- let handshake_client = get_escalate_client()?;- let (server, client) = AsyncSocket::pair()?;- const HANDSHAKE_MESSAGE: [u8; 1] = [0];- handshake_client- .send_with_fds(&HANDSHAKE_MESSAGE, &[server.into_inner().into()])- .await- .context("failed to send handshake datagram")?;- let env = std::env::vars()- .filter(|(k, _)| !matches!(k.as_str(), ESCALATE_SOCKET_ENV_VAR | EXEC_WRAPPER_ENV_VAR))- .collect();- client- .send(EscalateRequest {- file: file.clone().into(),- argv: argv.clone(),- workdir: AbsolutePathBuf::current_dir()?,- env,- })- .await- .context("failed to send EscalateRequest")?;- let message = client- .receive::<EscalateResponse>()- .await- .context("failed to receive EscalateResponse")?;- match message.action {- EscalateAction::Escalate => {- // Duplicate stdio before transferring ownership to the server. The- // wrapper must keep using its own stdin/stdout/stderr until the- // escalated child takes over.- let destination_fds = [- io::stdin().as_raw_fd(),- io::stdout().as_raw_fd(),- io::stderr().as_raw_fd(),- ];- let fds_to_send = [- duplicate_fd_for_transfer(io::stdin(), "stdin")?,- duplicate_fd_for_transfer(io::stdout(), "stdout")?,- duplicate_fd_for_transfer(io::stderr(), "stderr")?,- ];-- // TODO: also forward signals over the super-exec socket-- client- .send_with_fds(- SuperExecMessage {- fds: destination_fds.into_iter().collect(),- },- &fds_to_send,- )- .await- .context("failed to send SuperExecMessage")?;- let SuperExecResult { exit_code } = client.receive::<SuperExecResult>().await?;- Ok(exit_code)- }- EscalateAction::Run => {- // We avoid std::process::Command here because we want to be as transparent as- // possible. std::os::unix::process::CommandExt has .exec() but it does some funky- // stuff with signal masks and dup2() on its standard FDs, which we don't want.- use std::ffi::CString;- let file = CString::new(file).context("NUL in file")?;-- let argv_cstrs: Vec<CString> = argv- .iter()- .map(|s| CString::new(s.as_str()).context("NUL in argv"))- .collect::<Result<Vec<_>, _>>()?;-- let mut argv: Vec<*const libc::c_char> =- argv_cstrs.iter().map(|s| s.as_ptr()).collect();- argv.push(std::ptr::null());-- let err = unsafe {- libc::execv(file.as_ptr(), argv.as_ptr());- std::io::Error::last_os_error()- };-- Err(err.into())- }- EscalateAction::Deny { reason } => {- match reason {- Some(reason) => eprintln!("Execution denied: {reason}"),- None => eprintln!("Execution denied"),- }- Ok(1)- }- }-}--#[cfg(test)]-mod tests {- use super::*;- use std::os::fd::AsRawFd;- use std::os::unix::net::UnixStream;-- #[test]- fn duplicate_fd_for_transfer_does_not_close_original() {- let (left, _right) = UnixStream::pair().expect("socket pair");- let original_fd = left.as_raw_fd();-- let duplicate = duplicate_fd_for_transfer(&left, "test fd").expect("duplicate fd");- assert_ne!(duplicate.as_raw_fd(), original_fd);-- drop(duplicate);-- assert_ne!(unsafe { libc::fcntl(original_fd, libc::F_GETFD) }, -1);- }-}diff --git a/codex-rs/shell-escalation/src/unix/escalate_protocol.rs b/codex-rs/shell-escalation/src/unix/escalate_protocol.rsdeleted file mode 100644index 1892f181b9..0000000000--- a/codex-rs/shell-escalation/src/unix/escalate_protocol.rs+++ /dev/null@@ -1,88 +0,0 @@-use std::collections::HashMap;-use std::os::fd::RawFd;-use std::path::PathBuf;--use codex_protocol::approvals::EscalationPermissions;-use codex_utils_absolute_path::AbsolutePathBuf;-use serde::Deserialize;-use serde::Serialize;--/// Exec wrappers read this to find the inherited FD for the escalation socket.-pub const ESCALATE_SOCKET_ENV_VAR: &str = "CODEX_ESCALATE_SOCKET";--/// Patched shells use this to wrap exec() calls.-pub const EXEC_WRAPPER_ENV_VAR: &str = "EXEC_WRAPPER";--/// The client sends this to the server to request an exec() call.-#[derive(Clone, Serialize, Deserialize, Debug, PartialEq, Eq)]-pub struct EscalateRequest {- /// The executable path from the intercepted exec call.- ///- /// This may be relative, in which case it should be resolved against- /// `workdir`.- pub file: PathBuf,- /// The argv, including the program name (argv[0]).- pub argv: Vec<String>,- pub workdir: AbsolutePathBuf,- pub env: HashMap<String, String>,-}--/// The server sends this to the client to respond to an exec() request.-#[derive(Clone, Serialize, Deserialize, Debug, PartialEq, Eq)]-pub struct EscalateResponse {- pub action: EscalateAction,-}--#[derive(Clone, Debug, PartialEq, Eq)]-pub enum EscalationDecision {- Run,- Escalate(EscalationExecution),- Deny { reason: Option<String> },-}--#[allow(clippy::large_enum_variant)]-#[derive(Clone, Debug, PartialEq, Eq)]-pub enum EscalationExecution {- /// Rerun the intercepted command outside any sandbox wrapper.- Unsandboxed,- /// Rerun using the turn's current sandbox configuration.- TurnDefault,- /// Rerun using an explicit sandbox configuration attached to the request.- Permissions(EscalationPermissions),-}--impl EscalationDecision {- pub fn run() -> Self {- Self::Run- }-- pub fn escalate(execution: EscalationExecution) -> Self {- Self::Escalate(execution)- }-- pub fn deny(reason: Option<String>) -> Self {- Self::Deny { reason }- }-}--#[derive(Clone, Serialize, Deserialize, Debug, PartialEq, Eq)]-pub enum EscalateAction {- /// The command should be run directly by the client.- Run,- /// The command should be escalated to the server for execution.- Escalate,- /// The command should not be executed.- Deny { reason: Option<String> },-}--/// The client sends this to the server to forward its open FDs.-#[derive(Clone, Serialize, Deserialize, Debug)]-pub struct SuperExecMessage {- pub fds: Vec<RawFd>,-}--/// The server responds when the exec()'d command has exited.-#[derive(Clone, Serialize, Deserialize, Debug)]-pub struct SuperExecResult {- pub exit_code: i32,-}diff --git a/codex-rs/shell-escalation/src/unix/escalate_server.rs b/codex-rs/shell-escalation/src/unix/escalate_server.rsdeleted file mode 100644index 139450dc3d..0000000000--- a/codex-rs/shell-escalation/src/unix/escalate_server.rs+++ /dev/null@@ -1,1118 +0,0 @@-use std::collections::HashMap;-use std::future::Future;-use std::os::fd::AsRawFd;-use std::path::PathBuf;-use std::pin::Pin;-use std::process::Stdio;-use std::sync::Arc;-use std::sync::Mutex;-use std::time::Duration;--use anyhow::Context as _;-use codex_protocol::shell_environment::scrub_non_inheritable_env_vars;-use codex_utils_absolute_path::AbsolutePathBuf;-use socket2::Socket;-use tokio::process::Command;-use tokio::task::JoinHandle;-use tokio_util::sync::CancellationToken;--use crate::unix::escalate_protocol::ESCALATE_SOCKET_ENV_VAR;-use crate::unix::escalate_protocol::EXEC_WRAPPER_ENV_VAR;-use crate::unix::escalate_protocol::EscalateAction;-use crate::unix::escalate_protocol::EscalateRequest;-use crate::unix::escalate_protocol::EscalateResponse;-use crate::unix::escalate_protocol::EscalationDecision;-use crate::unix::escalate_protocol::EscalationExecution;-use crate::unix::escalate_protocol::SuperExecMessage;-use crate::unix::escalate_protocol::SuperExecResult;-use crate::unix::escalation_policy::EscalationPolicy;-use crate::unix::socket::AsyncDatagramSocket;-use crate::unix::socket::AsyncSocket;--/// Adapter for running the shell command after the escalation server has been set up.-///-/// This lets `shell-escalation` own the Unix escalation protocol while the caller-/// keeps control over process spawning, output capture, and sandbox integration.-/// Implementations can capture any sandbox state they need.-pub trait ShellCommandExecutor: Send + Sync {- /// Runs the requested shell command and returns the captured result.- ///- /// `env_overlay` contains only the wrapper/socket variables exported by- /// `EscalationSession::env()`, not a complete child environment.- /// Implementations should merge it into whatever base environment they use- /// for the shell process. `after_spawn` should be invoked immediately after- /// the shell process has been spawned so the parent copy of the inherited- /// escalation socket can be closed.- fn run(- &self,- command: Vec<String>,- cwd: PathBuf,- env_overlay: HashMap<String, String>,- cancel_rx: CancellationToken,- after_spawn: Option<Box<dyn FnOnce() + Send>>,- ) -> ShellCommandExecutorFuture<'_, ExecResult>;-- /// Prepares an escalated subcommand for execution on the server side.- fn prepare_escalated_exec<'a>(- &'a self,- program: &'a AbsolutePathBuf,- argv: &'a [String],- workdir: &'a AbsolutePathBuf,- env: HashMap<String, String>,- execution: EscalationExecution,- ) -> ShellCommandExecutorFuture<'a, PreparedExec>;-}--pub type ShellCommandExecutorFuture<'a, T> =- Pin<Box<dyn Future<Output = anyhow::Result<T>> + Send + 'a>>;--#[derive(Debug, serde::Deserialize, serde::Serialize)]-pub struct ExecParams {- /// The command string to pass to the shell via `-c` or `-lc`.- pub command: String,- /// The working directory to execute the command in. Must be an absolute path.- pub workdir: String,- /// The timeout for the command in milliseconds.- pub timeout_ms: Option<u64>,- /// Launch the shell with -lc instead of -c: defaults to true.- pub login: Option<bool>,-}--#[derive(Debug, serde::Serialize, serde::Deserialize)]-pub struct ExecResult {- pub exit_code: i32,- pub stdout: String,- pub stderr: String,- /// Aggregated stdout+stderr output for compatibility with existing callers.- pub output: String,- pub duration: Duration,- pub timed_out: bool,-}--#[derive(Debug, Clone, PartialEq, Eq)]-pub struct PreparedExec {- pub command: Vec<String>,- pub cwd: PathBuf,- pub env: HashMap<String, String>,- pub arg0: Option<String>,-}--#[derive(Debug)]-pub struct EscalationSession {- env: HashMap<String, String>,- task: JoinHandle<anyhow::Result<()>>,- client_socket: Arc<Mutex<Option<Socket>>>,- cancellation_token: CancellationToken,-}--impl EscalationSession {- /// Returns just the environment overlay needed by the execve wrapper.- ///- /// Callers should merge this into their own child-process environment- /// rather than treating it as the full environment for the shell.- pub fn env(&self) -> &HashMap<String, String> {- &self.env- }-- pub fn close_client_socket(&self) {- if let Ok(mut client_socket) = self.client_socket.lock() {- client_socket.take();- }- }-}--impl Drop for EscalationSession {- fn drop(&mut self) {- self.close_client_socket();- self.cancellation_token.cancel();- self.task.abort();- }-}--pub struct EscalateServer {- shell_path: PathBuf,- execve_wrapper: PathBuf,- policy: Arc<dyn EscalationPolicy>,-}--impl EscalateServer {- pub fn new<Policy>(shell_path: PathBuf, execve_wrapper: PathBuf, policy: Policy) -> Self- where- Policy: EscalationPolicy + Send + Sync + 'static,- {- Self {- shell_path,- execve_wrapper,- policy: Arc::new(policy),- }- }-- pub async fn exec(- &self,- params: ExecParams,- cancel_rx: CancellationToken,- command_executor: Arc<dyn ShellCommandExecutor>,- ) -> anyhow::Result<ExecResult> {- let session = self.start_session(cancel_rx.clone(), Arc::clone(&command_executor))?;- let env_overlay = session.env().clone();- let client_socket = Arc::clone(&session.client_socket);- let command = vec![- self.shell_path.to_string_lossy().to_string(),- if params.login == Some(false) {- "-c".to_string()- } else {- "-lc".to_string()- },- params.command,- ];- let workdir = AbsolutePathBuf::try_from(params.workdir)?;- let result = command_executor- .run(- command,- workdir.to_path_buf(),- env_overlay,- cancel_rx,- Some(Box::new(move || {- if let Ok(mut client_socket) = client_socket.lock() {- client_socket.take();- }- })),- )- .await?;- Ok(result)- }-- /// Starts an escalation session and returns the environment overlay a shell- /// needs in order to route intercepted execs through this server.- ///- /// This does not spawn the shell itself. Callers own process creation and- /// only use the returned environment plus the session lifetime handle.- pub fn start_session(- &self,- parent_cancellation_token: CancellationToken,- command_executor: Arc<dyn ShellCommandExecutor>,- ) -> anyhow::Result<EscalationSession> {- let cancellation_token = CancellationToken::new();- let (escalate_server, escalate_client) = AsyncDatagramSocket::pair()?;- let client_socket = escalate_client.into_inner();- let client_socket_fd = client_socket.as_raw_fd();- // Only the client endpoint should cross exec into the wrapper process.- client_socket.set_cloexec(false)?;- let client_socket = Arc::new(Mutex::new(Some(client_socket)));- let task = tokio::spawn(escalate_task(- escalate_server,- Arc::clone(&self.policy),- Arc::clone(&command_executor),- parent_cancellation_token,- cancellation_token.clone(),- ));- let mut env = HashMap::new();- env.insert(- ESCALATE_SOCKET_ENV_VAR.to_string(),- client_socket_fd.to_string(),- );- env.insert(- EXEC_WRAPPER_ENV_VAR.to_string(),- self.execve_wrapper.to_string_lossy().to_string(),- );- Ok(EscalationSession {- env,- task,- client_socket,- cancellation_token,- })- }-}--async fn escalate_task(- socket: AsyncDatagramSocket,- policy: Arc<dyn EscalationPolicy>,- command_executor: Arc<dyn ShellCommandExecutor>,- parent_cancellation_token: CancellationToken,- session_cancellation_token: CancellationToken,-) -> anyhow::Result<()> {- loop {- let (_, mut fds) = tokio::select! {- received = socket.receive_with_fds() => received?,- _ = parent_cancellation_token.cancelled() => return Ok(()),- _ = session_cancellation_token.cancelled() => return Ok(()),- };- if fds.len() != 1 {- tracing::error!("expected 1 fd in datagram handshake, got {}", fds.len());- continue;- }- let stream_socket = AsyncSocket::from_fd(fds.remove(0))?;- let policy = Arc::clone(&policy);- let command_executor = Arc::clone(&command_executor);- let parent_cancellation_token = parent_cancellation_token.clone();- let session_cancellation_token = session_cancellation_token.clone();- tokio::spawn(async move {- if let Err(err) = handle_escalate_session_with_policy(- stream_socket,- policy,- command_executor,- parent_cancellation_token,- session_cancellation_token,- )- .await- {- tracing::error!("escalate session failed: {err:?}");- }- });- }-}--async fn handle_escalate_session_with_policy(- socket: AsyncSocket,- policy: Arc<dyn EscalationPolicy>,- command_executor: Arc<dyn ShellCommandExecutor>,- parent_cancellation_token: CancellationToken,- session_cancellation_token: CancellationToken,-) -> anyhow::Result<()> {- let EscalateRequest {- file,- argv,- workdir,- env,- } = tokio::select! {- request = socket.receive::<EscalateRequest>() => request?,- _ = parent_cancellation_token.cancelled() => return Ok(()),- _ = session_cancellation_token.cancelled() => return Ok(()),- };- let program = AbsolutePathBuf::resolve_path_against_base(file, workdir.as_path());- let decision = tokio::select! {- decision = policy.determine_action(&program, &argv, &workdir) => {- decision.context("failed to determine escalation action")?- }- _ = parent_cancellation_token.cancelled() => return Ok(()),- _ = session_cancellation_token.cancelled() => return Ok(()),- };-- tracing::debug!("decided {decision:?} for {program:?} {argv:?} {workdir:?}");-- match decision {- EscalationDecision::Run => {- socket- .send(EscalateResponse {- action: EscalateAction::Run,- })- .await?;- }- EscalationDecision::Escalate(execution) => {- socket- .send(EscalateResponse {- action: EscalateAction::Escalate,- })- .await?;- let (msg, fds) = tokio::select! {- message = socket.receive_with_fds::<SuperExecMessage>() => {- message.context("failed to receive SuperExecMessage")?- }- _ = parent_cancellation_token.cancelled() => return Ok(()),- _ = session_cancellation_token.cancelled() => return Ok(()),- };- if fds.len() != msg.fds.len() {- return Err(anyhow::anyhow!(- "mismatched number of fds in SuperExecMessage: {} in the message, {} from the control message",- msg.fds.len(),- fds.len()- ));- }-- let PreparedExec {- command,- cwd,- env,- arg0,- } = tokio::select! {- prepared = command_executor.prepare_escalated_exec(&program, &argv, &workdir, env, execution) => prepared?,- _ = parent_cancellation_token.cancelled() => return Ok(()),- _ = session_cancellation_token.cancelled() => return Ok(()),- };- let (program, args) = command- .split_first()- .ok_or_else(|| anyhow::anyhow!("prepared escalated command must not be empty"))?;- let mut command = Command::new(program);- command- .args(args)- .arg0(arg0.unwrap_or_else(|| program.clone()))- .env_clear()- .envs(&env)- .current_dir(&cwd)- .stdin(Stdio::null())- .stdout(Stdio::null())- .stderr(Stdio::null())- .kill_on_drop(true);- scrub_non_inheritable_env_vars(command.as_std_mut());- unsafe {- command.pre_exec(move || {- for (dst_fd, src_fd) in msg.fds.iter().zip(&fds) {- libc::dup2(src_fd.as_raw_fd(), *dst_fd);- }- Ok(())- });- }- let mut child = command.spawn()?;- let exit_status = tokio::select! {- status = child.wait() => status?,- _ = parent_cancellation_token.cancelled() => {- let _ = child.start_kill();- child.wait().await?- }- _ = session_cancellation_token.cancelled() => {- let _ = child.start_kill();- child.wait().await?- }- };- socket- .send(SuperExecResult {- exit_code: exit_status.code().unwrap_or(127),- })- .await?;- }- EscalationDecision::Deny { reason } => {- socket- .send(EscalateResponse {- action: EscalateAction::Deny { reason },- })- .await?;- }- }- Ok(())-}--#[cfg(test)]-mod tests {- use super::*;- use crate::unix::escalation_policy::EscalationPolicyFuture;- use codex_protocol::approvals::EscalationPermissions;- use codex_protocol::models::AdditionalPermissionProfile as PermissionProfile;- use codex_protocol::models::NetworkPermissions;- use codex_utils_absolute_path::AbsolutePathBuf;- use pretty_assertions::assert_eq;- use std::collections::HashMap;- use std::io::Write;- use std::os::fd::AsRawFd;- use std::os::fd::FromRawFd;- use std::path::PathBuf;- use std::sync::LazyLock;- use std::sync::atomic::AtomicBool;- use std::sync::atomic::Ordering;- use tempfile::TempDir;- use tokio::sync::Semaphore;- use tokio::time::Instant;- use tokio::time::sleep;-- static ESCALATE_SERVER_TEST_LOCK: LazyLock<Semaphore> = LazyLock::new(|| Semaphore::new(1));-- struct DeterministicEscalationPolicy {- decision: EscalationDecision,- }-- impl EscalationPolicy for DeterministicEscalationPolicy {- fn determine_action<'a>(- &'a self,- _file: &'a AbsolutePathBuf,- _argv: &'a [String],- _workdir: &'a AbsolutePathBuf,- ) -> EscalationPolicyFuture<'a> {- Box::pin(async move { Ok(self.decision.clone()) })- }- }-- struct AssertingEscalationPolicy {- expected_file: AbsolutePathBuf,- expected_workdir: AbsolutePathBuf,- }-- impl EscalationPolicy for AssertingEscalationPolicy {- fn determine_action<'a>(- &'a self,- file: &'a AbsolutePathBuf,- _argv: &'a [String],- workdir: &'a AbsolutePathBuf,- ) -> EscalationPolicyFuture<'a> {- Box::pin(async move {- assert_eq!(file, &self.expected_file);- assert_eq!(workdir, &self.expected_workdir);- Ok(EscalationDecision::run())- })- }- }-- struct ForwardingShellCommandExecutor;-- impl ForwardingShellCommandExecutor {- async fn prepare_escalated_exec(- &self,- program: &AbsolutePathBuf,- argv: &[String],- workdir: &AbsolutePathBuf,- env: HashMap<String, String>,- ) -> anyhow::Result<PreparedExec> {- Ok(PreparedExec {- command: std::iter::once(program.to_string_lossy().to_string())- .chain(argv.iter().skip(1).cloned())- .collect(),- cwd: workdir.to_path_buf(),- env,- arg0: argv.first().cloned(),- })- }- }-- impl ShellCommandExecutor for ForwardingShellCommandExecutor {- fn run(- &self,- _command: Vec<String>,- _cwd: PathBuf,- _env_overlay: HashMap<String, String>,- _cancel_rx: CancellationToken,- _after_spawn: Option<Box<dyn FnOnce() + Send>>,- ) -> ShellCommandExecutorFuture<'_, ExecResult> {- Box::pin(async {- unreachable!("run() is not used by handle_escalate_session_with_policy() tests")- })- }-- fn prepare_escalated_exec<'a>(- &'a self,- program: &'a AbsolutePathBuf,- argv: &'a [String],- workdir: &'a AbsolutePathBuf,- env: HashMap<String, String>,- _execution: EscalationExecution,- ) -> ShellCommandExecutorFuture<'a, PreparedExec> {- Box::pin(ForwardingShellCommandExecutor::prepare_escalated_exec(- self, program, argv, workdir, env,- ))- }- }-- struct PermissionAssertingShellCommandExecutor {- expected_permissions: EscalationPermissions,- }-- impl PermissionAssertingShellCommandExecutor {- async fn prepare_escalated_exec(- &self,- program: &AbsolutePathBuf,- argv: &[String],- workdir: &AbsolutePathBuf,- env: HashMap<String, String>,- execution: EscalationExecution,- ) -> anyhow::Result<PreparedExec> {- assert_eq!(- execution,- EscalationExecution::Permissions(self.expected_permissions.clone())- );- Ok(PreparedExec {- command: std::iter::once(program.to_string_lossy().to_string())- .chain(argv.iter().skip(1).cloned())- .collect(),- cwd: workdir.to_path_buf(),- env,- arg0: argv.first().cloned(),- })- }- }-- impl ShellCommandExecutor for PermissionAssertingShellCommandExecutor {- fn run(- &self,- _command: Vec<String>,- _cwd: PathBuf,- _env_overlay: HashMap<String, String>,- _cancel_rx: CancellationToken,- _after_spawn: Option<Box<dyn FnOnce() + Send>>,- ) -> ShellCommandExecutorFuture<'_, ExecResult> {- Box::pin(async {- unreachable!("run() is not used by handle_escalate_session_with_policy() tests")- })- }-- fn prepare_escalated_exec<'a>(- &'a self,- program: &'a AbsolutePathBuf,- argv: &'a [String],- workdir: &'a AbsolutePathBuf,- env: HashMap<String, String>,- execution: EscalationExecution,- ) -> ShellCommandExecutorFuture<'a, PreparedExec> {- Box::pin(- PermissionAssertingShellCommandExecutor::prepare_escalated_exec(- self, program, argv, workdir, env, execution,- ),- )- }- }-- async fn wait_for_pid_file(pid_file: &std::path::Path) -> anyhow::Result<i32> {- let deadline = Instant::now() + Duration::from_secs(5);- loop {- if let Ok(contents) = std::fs::read_to_string(pid_file) {- return Ok(contents.trim().parse()?);- }- if Instant::now() >= deadline {- return Err(anyhow::anyhow!(- "timed out waiting for pid file {}",- pid_file.display()- ));- }- sleep(Duration::from_millis(20)).await;- }- }-- fn process_exists(pid: i32) -> bool {- let rc = unsafe { libc::kill(pid, 0) };- if rc == 0 {- return true;- }- std::io::Error::last_os_error().raw_os_error() != Some(libc::ESRCH)- }-- struct AfterSpawnAssertingShellCommandExecutor {- after_spawn_invoked: Arc<AtomicBool>,- }-- impl AfterSpawnAssertingShellCommandExecutor {- async fn run(- &self,- env_overlay: HashMap<String, String>,- after_spawn: Option<Box<dyn FnOnce() + Send>>,- ) -> anyhow::Result<ExecResult> {- let socket_fd = env_overlay- .get(ESCALATE_SOCKET_ENV_VAR)- .expect("session should export shell escalation socket")- .parse::<i32>()?;- assert_ne!(unsafe { libc::fcntl(socket_fd, libc::F_GETFD) }, -1);- after_spawn.expect("one-shot exec should install an after-spawn hook")();- self.after_spawn_invoked.store(true, Ordering::Relaxed);- Ok(ExecResult {- exit_code: 0,- stdout: String::new(),- stderr: String::new(),- output: String::new(),- duration: Duration::ZERO,- timed_out: false,- })- }- }-- impl ShellCommandExecutor for AfterSpawnAssertingShellCommandExecutor {- fn run(- &self,- _command: Vec<String>,- _cwd: PathBuf,- env_overlay: HashMap<String, String>,- _cancel_rx: CancellationToken,- after_spawn: Option<Box<dyn FnOnce() + Send>>,- ) -> ShellCommandExecutorFuture<'_, ExecResult> {- Box::pin(AfterSpawnAssertingShellCommandExecutor::run(- self,- env_overlay,- after_spawn,- ))- }-- fn prepare_escalated_exec<'a>(- &'a self,- _program: &'a AbsolutePathBuf,- _argv: &'a [String],- _workdir: &'a AbsolutePathBuf,- _env: HashMap<String, String>,- _execution: EscalationExecution,- ) -> ShellCommandExecutorFuture<'a, PreparedExec> {- Box::pin(async { unreachable!("prepare_escalated_exec() is not used by exec() tests") })- }- }-- async fn wait_for_process_exit(pid: i32) -> anyhow::Result<()> {- let deadline = Instant::now() + Duration::from_secs(5);- loop {- if !process_exists(pid) {- return Ok(());- }- if Instant::now() >= deadline {- return Err(anyhow::anyhow!("timed out waiting for pid {pid} to exit"));- }- sleep(Duration::from_millis(20)).await;- }- }-- /// Verifies that `start_session()` returns only the wrapper/socket env- /// overlay and does not need to touch the configured shell or wrapper- /// executable paths.- ///- /// The `/bin/zsh` and `/tmp/codex-execve-wrapper` values here are- /// intentionally fake sentinels: this test asserts that the paths are- /// copied into the exported environment and that the socket fd stays valid- /// until `close_client_socket()` is called.- #[tokio::test]- async fn start_session_exposes_wrapper_env_overlay() -> anyhow::Result<()> {- let _guard = ESCALATE_SERVER_TEST_LOCK.acquire().await?;- let execve_wrapper = PathBuf::from("/tmp/codex-execve-wrapper");- let execve_wrapper_str = execve_wrapper.to_string_lossy().to_string();- let server = EscalateServer::new(- PathBuf::from("/bin/zsh"),- execve_wrapper,- DeterministicEscalationPolicy {- decision: EscalationDecision::run(),- },- );-- let session = server.start_session(- CancellationToken::new(),- Arc::new(ForwardingShellCommandExecutor),- )?;- let env = session.env();- assert_eq!(env.get(EXEC_WRAPPER_ENV_VAR), Some(&execve_wrapper_str));- let socket_fd = env- .get(ESCALATE_SOCKET_ENV_VAR)- .expect("session should export shell escalation socket");- let socket_fd = socket_fd.parse::<i32>()?;- assert!(socket_fd >= 0);- assert_ne!(unsafe { libc::fcntl(socket_fd, libc::F_GETFD) }, -1);- assert!(- session- .client_socket- .lock()- .is_ok_and(|socket| socket.is_some())- );- session.close_client_socket();- assert!(- session- .client_socket- .lock()- .is_ok_and(|socket| socket.is_none())- );-- Ok(())- }-- #[tokio::test]- async fn exec_closes_parent_socket_after_shell_spawn() -> anyhow::Result<()> {- let _guard = ESCALATE_SERVER_TEST_LOCK.acquire().await?;- let after_spawn_invoked = Arc::new(AtomicBool::new(false));- let server = EscalateServer::new(- PathBuf::from("/bin/bash"),- PathBuf::from("/tmp/codex-execve-wrapper"),- DeterministicEscalationPolicy {- decision: EscalationDecision::run(),- },- );-- let result = server- .exec(- ExecParams {- command: "true".to_string(),- workdir: AbsolutePathBuf::current_dir()?- .to_string_lossy()- .to_string(),- timeout_ms: None,- login: Some(false),- },- CancellationToken::new(),- Arc::new(AfterSpawnAssertingShellCommandExecutor {- after_spawn_invoked: Arc::clone(&after_spawn_invoked),- }),- )- .await?;- assert_eq!(0, result.exit_code);- assert!(after_spawn_invoked.load(Ordering::Relaxed));-- Ok(())- }-- #[tokio::test]- async fn handle_escalate_session_respects_run_in_sandbox_decision() -> anyhow::Result<()> {- let _guard = ESCALATE_SERVER_TEST_LOCK.acquire().await?;- let (server, client) = AsyncSocket::pair()?;- let server_task = tokio::spawn(handle_escalate_session_with_policy(- server,- Arc::new(DeterministicEscalationPolicy {- decision: EscalationDecision::run(),- }),- Arc::new(ForwardingShellCommandExecutor),- CancellationToken::new(),- CancellationToken::new(),- ));-- let mut env = HashMap::new();- for i in 0..10 {- let value = "A".repeat(1024);- env.insert(format!("CODEX_TEST_VAR{i}"), value);- }-- client- .send(EscalateRequest {- file: PathBuf::from("/bin/echo"),- argv: vec!["echo".to_string()],- workdir: AbsolutePathBuf::try_from(PathBuf::from("/tmp"))?,- env,- })- .await?;-- let response = client.receive::<EscalateResponse>().await?;- assert_eq!(- EscalateResponse {- action: EscalateAction::Run,- },- response- );- server_task.await?- }-- #[tokio::test]- async fn handle_escalate_session_resolves_relative_file_against_request_workdir()- -> anyhow::Result<()> {- let _guard = ESCALATE_SERVER_TEST_LOCK.acquire().await?;- let (server, client) = AsyncSocket::pair()?;- let tmp = tempfile::TempDir::new()?;- let workdir = tmp.path().join("workspace");- std::fs::create_dir(&workdir)?;- let workdir = AbsolutePathBuf::try_from(workdir)?;- let expected_file = workdir.join("bin/tool");- let server_task = tokio::spawn(handle_escalate_session_with_policy(- server,- Arc::new(AssertingEscalationPolicy {- expected_file,- expected_workdir: workdir.clone(),- }),- Arc::new(ForwardingShellCommandExecutor),- CancellationToken::new(),- CancellationToken::new(),- ));-- client- .send(EscalateRequest {- file: PathBuf::from("./bin/tool"),- argv: vec!["./bin/tool".to_string()],- workdir,- env: HashMap::new(),- })- .await?;-- let response = client.receive::<EscalateResponse>().await?;- assert_eq!(- EscalateResponse {- action: EscalateAction::Run,- },- response- );- server_task.await?- }-- #[tokio::test]- async fn handle_escalate_session_executes_escalated_command() -> anyhow::Result<()> {- let _guard = ESCALATE_SERVER_TEST_LOCK.acquire().await?;- let (server, client) = AsyncSocket::pair()?;- let server_task = tokio::spawn(handle_escalate_session_with_policy(- server,- Arc::new(DeterministicEscalationPolicy {- decision: EscalationDecision::escalate(EscalationExecution::Unsandboxed),- }),- Arc::new(ForwardingShellCommandExecutor),- CancellationToken::new(),- CancellationToken::new(),- ));-- client- .send(EscalateRequest {- file: PathBuf::from("/bin/sh"),- argv: vec![- "sh".to_string(),- "-c".to_string(),- r#"if [ "$KEY" = VALUE ]; then exit 42; else exit 1; fi"#.to_string(),- ],- workdir: AbsolutePathBuf::current_dir()?,- env: HashMap::from([("KEY".to_string(), "VALUE".to_string())]),- })- .await?;-- let response = client.receive::<EscalateResponse>().await?;- assert_eq!(- EscalateResponse {- action: EscalateAction::Escalate,- },- response- );-- client- .send_with_fds(SuperExecMessage { fds: Vec::new() }, &[])- .await?;-- let result = client.receive::<SuperExecResult>().await?;- assert_eq!(42, result.exit_code);-- server_task.await?- }-- /// Saves a target descriptor, closes it, and restores it when dropped.- ///- /// The overlap regression test needs the next received `SCM_RIGHTS` handle- /// to land on a specific descriptor number such as stdin. Temporarily- /// closing the descriptor makes that allocation possible while still- /// letting the test put the process back the way it found it.- struct RestoredFd {- target_fd: i32,- original_fd: std::os::fd::OwnedFd,- }-- impl RestoredFd {- /// Duplicates `target_fd`, then closes the original descriptor number.- ///- /// The duplicate is kept alive so `Drop` can restore the original- /// process state after the test finishes.- fn close_temporarily(target_fd: i32) -> anyhow::Result<Self> {- let original_fd = unsafe { libc::dup(target_fd) };- if original_fd == -1 {- return Err(std::io::Error::last_os_error().into());- }- if unsafe { libc::close(target_fd) } == -1 {- let err = std::io::Error::last_os_error();- unsafe {- libc::close(original_fd);- }- return Err(err.into());- }- Ok(Self {- target_fd,- original_fd: unsafe { std::os::fd::OwnedFd::from_raw_fd(original_fd) },- })- }- }-- /// Restores the original descriptor back onto its original fd number.- ///- /// This keeps the overlap test self-contained even though it mutates the- /// current process's stdio table.- impl Drop for RestoredFd {- fn drop(&mut self) {- unsafe {- libc::dup2(self.original_fd.as_raw_fd(), self.target_fd);- }- }- }-- #[tokio::test]- async fn handle_escalate_session_accepts_received_fds_that_overlap_destinations()- -> anyhow::Result<()> {- let _guard = ESCALATE_SERVER_TEST_LOCK.acquire().await?;- let mut pipe_fds = [0; 2];- if unsafe { libc::pipe(pipe_fds.as_mut_ptr()) } == -1 {- return Err(std::io::Error::last_os_error().into());- }- let read_end = unsafe { std::os::fd::OwnedFd::from_raw_fd(pipe_fds[0]) };- let mut write_end = unsafe { std::fs::File::from_raw_fd(pipe_fds[1]) };-- // Force the receive-side overlap case for stdin.- //- // SCM_RIGHTS installs received descriptors into the lowest available fd- // numbers in the receiving process. The pipe is opened first so its- // read end does not consume fd 0. After stdin is temporarily closed,- // receiving `read_end` should reuse descriptor 0. The message below- // also asks the server to map that received fd to destination fd 0, so- // the pre-exec dup2 loop exercises the src_fd == dst_fd case.- let stdin_restore = RestoredFd::close_temporarily(libc::STDIN_FILENO)?;- let (server, client) = AsyncSocket::pair()?;- let server_task = tokio::spawn(handle_escalate_session_with_policy(- server,- Arc::new(DeterministicEscalationPolicy {- decision: EscalationDecision::escalate(EscalationExecution::Unsandboxed),- }),- Arc::new(ForwardingShellCommandExecutor),- CancellationToken::new(),- CancellationToken::new(),- ));-- client- .send(EscalateRequest {- file: PathBuf::from("/bin/sh"),- argv: vec![- "sh".to_string(),- "-c".to_string(),- "IFS= read -r line && [ \"$line\" = overlap-ok ]".to_string(),- ],- workdir: AbsolutePathBuf::current_dir()?,- env: HashMap::new(),- })- .await?;-- let response = client.receive::<EscalateResponse>().await?;- assert_eq!(- EscalateResponse {- action: EscalateAction::Escalate,- },- response- );-- client- .send_with_fds(- SuperExecMessage {- fds: vec![libc::STDIN_FILENO],- },- &[read_end],- )- .await?;- write_end.write_all(b"overlap-ok\n")?;- drop(write_end);-- let result = client.receive::<SuperExecResult>().await?;- assert_eq!(- 0, result.exit_code,- "expected the escalated child to read the sent stdin payload even when the received fd reuses fd 0"- );- drop(stdin_restore);-- server_task.await?- }-- #[tokio::test]- async fn handle_escalate_session_passes_permissions_to_executor() -> anyhow::Result<()> {- let _guard = ESCALATE_SERVER_TEST_LOCK.acquire().await?;- let (server, client) = AsyncSocket::pair()?;- let server_task = tokio::spawn(handle_escalate_session_with_policy(- server,- Arc::new(DeterministicEscalationPolicy {- decision: EscalationDecision::escalate(EscalationExecution::Permissions(- EscalationPermissions::AdditionalPermissionProfile(PermissionProfile {- network: Some(NetworkPermissions {- enabled: Some(true),- }),- ..Default::default()- }),- )),- }),- Arc::new(PermissionAssertingShellCommandExecutor {- expected_permissions: EscalationPermissions::AdditionalPermissionProfile(- PermissionProfile {- network: Some(NetworkPermissions {- enabled: Some(true),- }),- ..Default::default()- },- ),- }),- CancellationToken::new(),- CancellationToken::new(),- ));-- client- .send(EscalateRequest {- file: PathBuf::from("/bin/sh"),- argv: vec!["sh".to_string(), "-c".to_string(), "exit 0".to_string()],- workdir: AbsolutePathBuf::current_dir()?,- env: HashMap::new(),- })- .await?;-- let response = client.receive::<EscalateResponse>().await?;- assert_eq!(- EscalateResponse {- action: EscalateAction::Escalate,- },- response- );-- client- .send_with_fds(SuperExecMessage { fds: Vec::new() }, &[])- .await?;-- let result = client.receive::<SuperExecResult>().await?;- assert_eq!(0, result.exit_code);-- server_task.await?- }-- #[tokio::test]- async fn dropping_session_aborts_intercept_workers_and_kills_spawned_child()- -> anyhow::Result<()> {- let _guard = ESCALATE_SERVER_TEST_LOCK.acquire().await?;- let tmp = TempDir::new()?;- let pid_file = tmp.path().join("escalated-child.pid");- let pid_file_display = pid_file.display().to_string();- assert!(- !pid_file_display.contains('\''),- "test temp path should not contain single quotes: {pid_file_display}"- );- let server = EscalateServer::new(- PathBuf::from("/bin/bash"),- PathBuf::from("/tmp/codex-execve-wrapper"),- DeterministicEscalationPolicy {- decision: EscalationDecision::escalate(EscalationExecution::Unsandboxed),- },- );-- let session = server.start_session(- CancellationToken::new(),- Arc::new(ForwardingShellCommandExecutor),- )?;- let socket_fd = session- .env()- .get(ESCALATE_SOCKET_ENV_VAR)- .expect("session should export shell escalation socket")- .parse::<i32>()?;- let dup_socket_fd = unsafe { libc::dup(socket_fd) };- assert!(dup_socket_fd >= 0, "expected dup() to succeed");- let handshake_client = unsafe { AsyncDatagramSocket::from_raw_fd(dup_socket_fd) }?;- let (server_stream, client_stream) = AsyncSocket::pair()?;- // Keep one local reference to the server end alive until the worker has- // responded once. Without that guard, macOS can observe EOF on the- // client side before the transferred fd is fully servicing the stream.- let server_stream_guard = server_stream.into_inner();- let dup_server_stream_fd = unsafe { libc::dup(server_stream_guard.as_raw_fd()) };- assert!(- dup_server_stream_fd >= 0,- "expected dup() of server stream to succeed"- );- let server_stream_fd = unsafe { std::os::fd::OwnedFd::from_raw_fd(dup_server_stream_fd) };- handshake_client- .send_with_fds(&[0], &[server_stream_fd])- .await- .context("failed to send handshake datagram")?;-- client_stream- .send(EscalateRequest {- file: PathBuf::from("/bin/sh"),- argv: vec![- "sh".to_string(),- "-c".to_string(),- format!("echo $$ > '{pid_file_display}' && exec /bin/sleep 100"),- ],- workdir: AbsolutePathBuf::current_dir()?,- env: HashMap::new(),- })- .await- .context("failed to send EscalateRequest")?;-- let response = client_stream- .receive::<EscalateResponse>()- .await- .context("failed to receive EscalateResponse")?;- assert_eq!(- EscalateResponse {- action: EscalateAction::Escalate,- },- response- );- drop(server_stream_guard);-- client_stream- .send_with_fds(SuperExecMessage { fds: Vec::new() }, &[])- .await- .context("failed to send SuperExecMessage")?;-- let pid = wait_for_pid_file(&pid_file).await?;- assert!(- process_exists(pid),- "expected spawned child pid {pid} to exist"- );-- drop(session);-- wait_for_process_exit(pid).await?;-- Ok(())- }-}diff --git a/codex-rs/shell-escalation/src/unix/escalation_policy.rs b/codex-rs/shell-escalation/src/unix/escalation_policy.rsdeleted file mode 100644index c77af22db7..0000000000--- a/codex-rs/shell-escalation/src/unix/escalation_policy.rs+++ /dev/null@@ -1,19 +0,0 @@-use std::future::Future;-use std::pin::Pin;--use codex_utils_absolute_path::AbsolutePathBuf;--use crate::unix::escalate_protocol::EscalationDecision;--/// Decides what action to take in response to an execve request from a client.-pub trait EscalationPolicy: Send + Sync {- fn determine_action<'a>(- &'a self,- file: &'a AbsolutePathBuf,- argv: &'a [String],- workdir: &'a AbsolutePathBuf,- ) -> EscalationPolicyFuture<'a>;-}--pub type EscalationPolicyFuture<'a> =- Pin<Box<dyn Future<Output = anyhow::Result<EscalationDecision>> + Send + 'a>>;diff --git a/codex-rs/shell-escalation/src/unix/execve_wrapper.rs b/codex-rs/shell-escalation/src/unix/execve_wrapper.rsdeleted file mode 100644index 58f8d37062..0000000000--- a/codex-rs/shell-escalation/src/unix/execve_wrapper.rs+++ /dev/null@@ -1,25 +0,0 @@-//! Entrypoints for execve interception helper binaries.--use clap::Parser;-use tracing_subscriber::EnvFilter;--#[derive(Parser)]-pub struct ExecveWrapperCli {- file: String,-- #[arg(trailing_var_arg = true)]- argv: Vec<String>,-}--#[tokio::main]-pub async fn main_execve_wrapper() -> anyhow::Result<()> {- tracing_subscriber::fmt()- .with_env_filter(EnvFilter::from_default_env())- .with_writer(std::io::stderr)- .with_ansi(false)- .init();-- let ExecveWrapperCli { file, argv } = ExecveWrapperCli::parse();- let exit_code = crate::run_shell_escalation_execve_wrapper(file, argv).await?;- std::process::exit(exit_code);-}diff --git a/codex-rs/shell-escalation/src/unix/mod.rs b/codex-rs/shell-escalation/src/unix/mod.rsdeleted file mode 100644index 8e30056bb4..0000000000--- a/codex-rs/shell-escalation/src/unix/mod.rs+++ /dev/null@@ -1,81 +0,0 @@-//! Unix shell-escalation protocol implementation.-//!-//! A patched shell invokes an exec wrapper on every `exec()` attempt. The wrapper sends an-//! `EscalateRequest` over the inherited `CODEX_ESCALATE_SOCKET`, and the server decides whether to-//! run the command directly (`Run`) or execute it on the server side (`Escalate`).-//!-//! Of key importance is the `EscalateRequest` includes a file descriptor for a socket-//! that the server can use to send the response to the execve wrapper. In this-//! way, all descendents of the Server process can use the file descriptor-//! specified by the `CODEX_ESCALATE_SOCKET` environment variable to _send_ escalation requests,-//! but responses are read from a separate socket that is created for each request, which-//! allows the server to handle multiple concurrent escalation requests.-//!-//! ### Escalation flow-//!-//! Command Server Shell Execve Wrapper-//! |-//! o----->o-//! | |-//! | o--(exec)-->o-//! | | |-//! |o<-(EscalateReq)--o-//! || | |-//! |o--(Escalate)---->o-//! || | |-//! |o<---------(fds)--o-//! || | |-//! o<------o | |-//! | || | |-//! x------>o | |-//! || | |-//! |x--(exit code)--->o-//! | | |-//! | o<--(exit)--x-//! | |-//! o<-----x-//!-//! ### Non-escalation flow-//!-//! Server Shell Execve Wrapper Command-//! |-//! o----->o-//! | |-//! | o--(exec)-->o-//! | | |-//! |o<-(EscalateReq)--o-//! || | |-//! |o-(Run)---------->o-//! | | |-//! | | x--(exec)-->o-//! | | |-//! | o<--------------(exit)--x-//! | |-//! o<-----x-//!-pub(crate) mod escalate_client;-pub(crate) mod escalate_protocol;-pub(crate) mod escalate_server;-pub(crate) mod escalation_policy;-pub(crate) mod execve_wrapper;-pub(crate) mod socket;-pub(crate) mod stopwatch;--pub use self::escalate_client::run_shell_escalation_execve_wrapper;-pub use self::escalate_protocol::ESCALATE_SOCKET_ENV_VAR;-pub use self::escalate_protocol::EscalateAction;-pub use self::escalate_protocol::EscalationDecision;-pub use self::escalate_protocol::EscalationExecution;-pub use self::escalate_server::EscalateServer;-pub use self::escalate_server::EscalationSession;-pub use self::escalate_server::ExecParams;-pub use self::escalate_server::ExecResult;-pub use self::escalate_server::PreparedExec;-pub use self::escalate_server::ShellCommandExecutor;-pub use self::escalate_server::ShellCommandExecutorFuture;-pub use self::escalation_policy::EscalationPolicy;-pub use self::escalation_policy::EscalationPolicyFuture;-pub use self::execve_wrapper::main_execve_wrapper;-pub use self::stopwatch::Stopwatch;-pub use codex_protocol::approvals::EscalationPermissions;-pub use codex_protocol::approvals::ResolvedPermissionProfile;diff --git a/codex-rs/shell-escalation/src/unix/socket.rs b/codex-rs/shell-escalation/src/unix/socket.rsdeleted file mode 100644index a364608fc4..0000000000--- a/codex-rs/shell-escalation/src/unix/socket.rs+++ /dev/null@@ -1,523 +0,0 @@-use libc::c_uint;-use serde::Deserialize;-use serde::Serialize;-use socket2::Domain;-use socket2::MaybeUninitSlice;-use socket2::MsgHdr;-use socket2::MsgHdrMut;-use socket2::Socket;-use socket2::Type;-use std::io::IoSlice;-use std::mem::MaybeUninit;-use std::os::fd::AsRawFd;-use std::os::fd::FromRawFd;-use std::os::fd::OwnedFd;-use std::os::fd::RawFd;-use tokio::io::Interest;-use tokio::io::unix::AsyncFd;--const MAX_FDS_PER_MESSAGE: usize = 16;-const LENGTH_PREFIX_SIZE: usize = size_of::<u32>();-const MAX_DATAGRAM_SIZE: usize = 8192;--/// Converts a slice of MaybeUninit<T> to a slice of T.-///-/// The caller guarantees that every element of `buf` is initialized.-fn assume_init<T>(buf: &[MaybeUninit<T>]) -> &[T] {- unsafe { std::slice::from_raw_parts(buf.as_ptr().cast(), buf.len()) }-}--fn assume_init_slice<T, const N: usize>(buf: &[MaybeUninit<T>; N]) -> &[T; N] {- unsafe { &*(buf as *const [MaybeUninit<T>; N] as *const [T; N]) }-}--fn assume_init_vec<T>(mut buf: Vec<MaybeUninit<T>>) -> Vec<T> {- unsafe {- let ptr = buf.as_mut_ptr() as *mut T;- let len = buf.len();- let cap = buf.capacity();- std::mem::forget(buf);- Vec::from_raw_parts(ptr, len, cap)- }-}--fn control_space_for_fds(count: usize) -> usize {- unsafe { libc::CMSG_SPACE((count * size_of::<RawFd>()) as _) as usize }-}--/// Extracts the FDs from a SCM_RIGHTS control message.-fn extract_fds(control: &[u8]) -> Vec<OwnedFd> {- let mut fds = Vec::new();- let mut hdr: libc::msghdr = unsafe { std::mem::zeroed() };- hdr.msg_control = control.as_ptr() as *mut libc::c_void;- hdr.msg_controllen = control.len() as _;- let hdr = hdr; // drop mut-- let mut cmsg = unsafe { libc::CMSG_FIRSTHDR(&hdr) as *const libc::cmsghdr };- while !cmsg.is_null() {- let level = unsafe { (*cmsg).cmsg_level };- let ty = unsafe { (*cmsg).cmsg_type };- if level == libc::SOL_SOCKET && ty == libc::SCM_RIGHTS {- let data_ptr = unsafe { libc::CMSG_DATA(cmsg).cast::<RawFd>() };- let fd_count: usize = {- // `cmsghdr::cmsg_len` is not typed consistently across targets, so normalize it- // before doing the size arithmetic.- #[allow(clippy::useless_conversion, clippy::expect_used)]- let cmsg_data_len = usize::try_from(unsafe { (*cmsg).cmsg_len })- .expect("cmsghdr length fits")- - unsafe { libc::CMSG_LEN(0) as usize };- cmsg_data_len / size_of::<RawFd>()- };- for i in 0..fd_count {- let fd = unsafe { data_ptr.add(i).read() };- fds.push(unsafe { OwnedFd::from_raw_fd(fd) });- }- }- cmsg = unsafe { libc::CMSG_NXTHDR(&hdr, cmsg) };- }- fds-}--/// Read a frame from a SOCK_STREAM socket.-///-/// A frame is a message length prefix followed by a payload. FDs may be included in the control-/// message when receiving the frame header.-async fn read_frame(async_socket: &AsyncFd<Socket>) -> std::io::Result<(Vec<u8>, Vec<OwnedFd>)> {- let (message_len, fds) = read_frame_header(async_socket).await?;- let payload = read_frame_payload(async_socket, message_len).await?;- Ok((payload, fds))-}--/// Read the frame header (i.e. length) and any FDs from a SOCK_STREAM socket.-async fn read_frame_header(- async_socket: &AsyncFd<Socket>,-) -> std::io::Result<(usize, Vec<OwnedFd>)> {- let mut header = [MaybeUninit::<u8>::uninit(); LENGTH_PREFIX_SIZE];- let mut filled = 0;- let mut control = vec![MaybeUninit::<u8>::uninit(); control_space_for_fds(MAX_FDS_PER_MESSAGE)];- let mut captured_control = false;-- while filled < LENGTH_PREFIX_SIZE {- let mut guard = async_socket.readable().await?;- // The first read should come with a control message containing any FDs.- let read = if !captured_control {- match guard.try_io(|inner| {- let mut bufs = [MaybeUninitSlice::new(&mut header[filled..])];- let (read, control_len) = {- let mut msg = MsgHdrMut::new()- .with_buffers(&mut bufs)- .with_control(&mut control);- let read = inner.get_ref().recvmsg(&mut msg, 0)?;- (read, msg.control_len())- };- control.truncate(control_len);- captured_control = true;- Ok(read)- }) {- Ok(Ok(read)) => read,- Ok(Err(err)) => return Err(err),- Err(_would_block) => continue,- }- } else {- match guard.try_io(|inner| inner.get_ref().recv(&mut header[filled..])) {- Ok(Ok(read)) => read,- Ok(Err(err)) => return Err(err),- Err(_would_block) => continue,- }- };- if read == 0 {- return Err(std::io::Error::new(- std::io::ErrorKind::UnexpectedEof,- "socket closed while receiving frame header",- ));- }-- filled += read;- assert!(filled <= LENGTH_PREFIX_SIZE);- if filled == LENGTH_PREFIX_SIZE {- let len_bytes = assume_init_slice(&header);- let payload_len = u32::from_le_bytes(*len_bytes) as usize;- let fds = extract_fds(assume_init(&control));- return Ok((payload_len, fds));- }- }- unreachable!("header loop always returns")-}--/// Read `message_len` bytes from a SOCK_STREAM socket.-async fn read_frame_payload(- async_socket: &AsyncFd<Socket>,- message_len: usize,-) -> std::io::Result<Vec<u8>> {- if message_len == 0 {- return Ok(Vec::new());- }- let mut payload = vec![MaybeUninit::<u8>::uninit(); message_len];- let mut filled = 0;- while filled < message_len {- let mut guard = async_socket.readable().await?;- let read = match guard.try_io(|inner| inner.get_ref().recv(&mut payload[filled..])) {- Ok(Ok(read)) => read,- Ok(Err(err)) => return Err(err),- Err(_would_block) => continue,- };- if read == 0 {- return Err(std::io::Error::new(- std::io::ErrorKind::UnexpectedEof,- "socket closed while receiving frame payload",- ));- }- filled += read;- assert!(filled <= message_len);- if filled == message_len {- return Ok(assume_init_vec(payload));- }- }- unreachable!("loop exits only after returning payload")-}--fn send_datagram_bytes(socket: &Socket, data: &[u8], fds: &[OwnedFd]) -> std::io::Result<()> {- let control = make_control_message(fds)?;- let payload = [IoSlice::new(data)];- let msg = if control.is_empty() {- MsgHdr::new().with_buffers(&payload)- } else {- MsgHdr::new().with_buffers(&payload).with_control(&control)- };- let written = socket.sendmsg(&msg, 0)?;- if written != data.len() {- return Err(std::io::Error::new(- std::io::ErrorKind::WriteZero,- format!(- "short datagram write: wrote {written} bytes out of {}",- data.len()- ),- ));- }- Ok(())-}--fn encode_length(len: usize) -> std::io::Result<[u8; LENGTH_PREFIX_SIZE]> {- let len_u32 = u32::try_from(len).map_err(|_| {- std::io::Error::new(- std::io::ErrorKind::InvalidInput,- format!("message too large: {len}"),- )- })?;- Ok(len_u32.to_le_bytes())-}--fn make_control_message(fds: &[OwnedFd]) -> std::io::Result<Vec<u8>> {- if fds.len() > MAX_FDS_PER_MESSAGE {- Err(std::io::Error::new(- std::io::ErrorKind::InvalidInput,- format!("too many fds: {}", fds.len()),- ))- } else if fds.is_empty() {- Ok(Vec::new())- } else {- let mut control = vec![0u8; control_space_for_fds(fds.len())];- unsafe {- let cmsg = control.as_mut_ptr().cast::<libc::cmsghdr>();- (*cmsg).cmsg_len =- libc::CMSG_LEN(size_of::<RawFd>() as c_uint * fds.len() as c_uint) as _;- (*cmsg).cmsg_level = libc::SOL_SOCKET;- (*cmsg).cmsg_type = libc::SCM_RIGHTS;- let data_ptr = libc::CMSG_DATA(cmsg).cast::<RawFd>();- for (i, fd) in fds.iter().enumerate() {- data_ptr.add(i).write(fd.as_raw_fd());- }- }- Ok(control)- }-}--fn receive_datagram_bytes(socket: &Socket) -> std::io::Result<(Vec<u8>, Vec<OwnedFd>)> {- let mut buffer = vec![MaybeUninit::<u8>::uninit(); MAX_DATAGRAM_SIZE];- let mut control = vec![MaybeUninit::<u8>::uninit(); control_space_for_fds(MAX_FDS_PER_MESSAGE)];- let (read, control_len) = {- let mut bufs = [MaybeUninitSlice::new(&mut buffer)];- let mut msg = MsgHdrMut::new()- .with_buffers(&mut bufs)- .with_control(&mut control);- let read = socket.recvmsg(&mut msg, 0)?;- (read, msg.control_len())- };- let data = assume_init(&buffer[..read]).to_vec();- let fds = extract_fds(assume_init(&control[..control_len]));- Ok((data, fds))-}--pub(crate) struct AsyncSocket {- inner: AsyncFd<Socket>,-}--impl AsyncSocket {- fn new(socket: Socket) -> std::io::Result<AsyncSocket> {- socket.set_nonblocking(true)?;- let async_socket = AsyncFd::new(socket)?;- Ok(AsyncSocket {- inner: async_socket,- })- }-- pub fn from_fd(fd: OwnedFd) -> std::io::Result<AsyncSocket> {- AsyncSocket::new(Socket::from(fd))- }-- pub fn pair() -> std::io::Result<(AsyncSocket, AsyncSocket)> {- // `socket2::Socket::pair()` also applies "common flags" (including- // `SO_NOSIGPIPE` on Apple platforms), which can fail for AF_UNIX sockets.- // Use `pair_raw()` to avoid those side effects, then restore `CLOEXEC`- // explicitly on both endpoints.- let (server, client) = Socket::pair_raw(Domain::UNIX, Type::STREAM, None)?;- server.set_cloexec(true)?;- client.set_cloexec(true)?;- Ok((AsyncSocket::new(server)?, AsyncSocket::new(client)?))- }-- pub async fn send_with_fds<T: Serialize>(- &self,- msg: T,- fds: &[OwnedFd],- ) -> std::io::Result<()> {- let payload = serde_json::to_vec(&msg)?;- let mut frame = Vec::with_capacity(LENGTH_PREFIX_SIZE + payload.len());- frame.extend_from_slice(&encode_length(payload.len())?);- frame.extend_from_slice(&payload);- send_stream_frame(&self.inner, &frame, fds).await- }-- pub async fn receive_with_fds<T: for<'de> Deserialize<'de>>(- &self,- ) -> std::io::Result<(T, Vec<OwnedFd>)> {- let (payload, fds) = read_frame(&self.inner).await?;- let message: T = serde_json::from_slice(&payload)?;- Ok((message, fds))- }-- pub async fn send<T>(&self, msg: T) -> std::io::Result<()>- where- T: Serialize,- {- self.send_with_fds(&msg, &[]).await- }-- pub async fn receive<T: for<'de> Deserialize<'de>>(&self) -> std::io::Result<T> {- let (msg, fds) = self.receive_with_fds().await?;- if !fds.is_empty() {- tracing::warn!("unexpected fds in receive: {}", fds.len());- }- Ok(msg)- }-- pub fn into_inner(self) -> Socket {- self.inner.into_inner()- }-}--async fn send_stream_frame(- socket: &AsyncFd<Socket>,- frame: &[u8],- fds: &[OwnedFd],-) -> std::io::Result<()> {- let mut written = 0;- let mut include_fds = !fds.is_empty();- while written < frame.len() {- let mut guard = socket.writable().await?;- let bytes_written = match guard- .try_io(|inner| send_stream_chunk(inner.get_ref(), &frame[written..], fds, include_fds))- {- Ok(result) => result?,- Err(_would_block) => continue,- };- if bytes_written == 0 {- return Err(std::io::Error::new(- std::io::ErrorKind::WriteZero,- "socket closed while sending frame payload",- ));- }- written += bytes_written;- include_fds = false;- }- Ok(())-}--fn send_stream_chunk(- socket: &Socket,- frame: &[u8],- fds: &[OwnedFd],- include_fds: bool,-) -> std::io::Result<usize> {- let control = if include_fds {- make_control_message(fds)?- } else {- Vec::new()- };- let payload = [IoSlice::new(frame)];- let msg = if control.is_empty() {- MsgHdr::new().with_buffers(&payload)- } else {- MsgHdr::new().with_buffers(&payload).with_control(&control)- };- socket.sendmsg(&msg, 0)-}--pub(crate) struct AsyncDatagramSocket {- inner: AsyncFd<Socket>,-}--impl AsyncDatagramSocket {- fn new(socket: Socket) -> std::io::Result<Self> {- socket.set_nonblocking(true)?;- Ok(Self {- inner: AsyncFd::new(socket)?,- })- }-- pub unsafe fn from_raw_fd(fd: RawFd) -> std::io::Result<Self> {- Self::new(unsafe { Socket::from_raw_fd(fd) })- }-- pub fn pair() -> std::io::Result<(Self, Self)> {- // `socket2::Socket::pair()` also applies "common flags" (including- // `SO_NOSIGPIPE` on Apple platforms), which can fail for AF_UNIX sockets.- // Use `pair_raw()` to avoid those side effects, then restore `CLOEXEC`- // explicitly on both endpoints.- let (server, client) = Socket::pair_raw(Domain::UNIX, Type::DGRAM, None)?;- server.set_cloexec(true)?;- client.set_cloexec(true)?;- Ok((Self::new(server)?, Self::new(client)?))- }-- pub async fn send_with_fds(&self, data: &[u8], fds: &[OwnedFd]) -> std::io::Result<()> {- self.inner- .async_io(Interest::WRITABLE, |socket| {- send_datagram_bytes(socket, data, fds)- })- .await- }-- pub async fn receive_with_fds(&self) -> std::io::Result<(Vec<u8>, Vec<OwnedFd>)> {- self.inner- .async_io(Interest::READABLE, receive_datagram_bytes)- .await- }-- pub fn into_inner(self) -> Socket {- self.inner.into_inner()- }-}--#[cfg(test)]-mod tests {- use super::*;- use pretty_assertions::assert_eq;- use serde::Deserialize;- use serde::Serialize;- use std::os::fd::AsFd;- use std::os::fd::AsRawFd;- use tempfile::NamedTempFile;-- #[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Clone)]- struct TestPayload {- id: i32,- label: String,- }-- fn fd_list(count: usize) -> std::io::Result<Vec<OwnedFd>> {- let file = NamedTempFile::new()?;- let mut fds = Vec::new();- for _ in 0..count {- fds.push(file.as_fd().try_clone_to_owned()?);- }- Ok(fds)- }-- #[tokio::test]- async fn async_socket_round_trips_payload_and_fds() -> std::io::Result<()> {- let (server, client) = AsyncSocket::pair()?;- let payload = TestPayload {- id: 7,- label: "round-trip".to_string(),- };- let send_fds = fd_list(/*count*/ 1)?;-- let receive_task =- tokio::spawn(async move { server.receive_with_fds::<TestPayload>().await });- client.send_with_fds(payload.clone(), &send_fds).await?;- drop(send_fds);-- let (received_payload, received_fds) = receive_task.await.unwrap()?;- assert_eq!(payload, received_payload);- assert_eq!(1, received_fds.len());- let fd_status = unsafe { libc::fcntl(received_fds[0].as_raw_fd(), libc::F_GETFD) };- assert!(- fd_status >= 0,- "expected received file descriptor to be valid, but got {fd_status}",- );- Ok(())- }-- #[tokio::test]- async fn async_socket_handles_large_payload() -> std::io::Result<()> {- let (server, client) = AsyncSocket::pair()?;- let payload = vec![b'A'; 10_000];- let receive_task = tokio::spawn(async move { server.receive::<Vec<u8>>().await });- client.send(payload.clone()).await?;- let received_payload = receive_task.await.unwrap()?;- assert_eq!(payload, received_payload);- Ok(())- }-- #[tokio::test]- async fn async_datagram_sockets_round_trip_messages() -> std::io::Result<()> {- let (server, client) = AsyncDatagramSocket::pair()?;- let data = b"datagram payload".to_vec();- let send_fds = fd_list(/*count*/ 1)?;- let receive_task = tokio::spawn(async move { server.receive_with_fds().await });-- client.send_with_fds(&data, &send_fds).await?;- drop(send_fds);-- let (received_bytes, received_fds) = receive_task.await.unwrap()?;- assert_eq!(data, received_bytes);- assert_eq!(1, received_fds.len());- Ok(())- }-- #[test]- fn send_datagram_bytes_rejects_excessive_fd_counts() -> std::io::Result<()> {- let (socket, _peer) = Socket::pair_raw(Domain::UNIX, Type::DGRAM, None)?;- let fds = fd_list(MAX_FDS_PER_MESSAGE + 1)?;- let err = send_datagram_bytes(&socket, b"hi", &fds).unwrap_err();- assert_eq!(std::io::ErrorKind::InvalidInput, err.kind());- Ok(())- }-- #[test]- fn send_stream_chunk_rejects_excessive_fd_counts() -> std::io::Result<()> {- let (socket, _peer) = Socket::pair_raw(Domain::UNIX, Type::STREAM, None)?;- let fds = fd_list(MAX_FDS_PER_MESSAGE + 1)?;- let err = send_stream_chunk(&socket, b"hello", &fds, /*include_fds*/ true).unwrap_err();- assert_eq!(std::io::ErrorKind::InvalidInput, err.kind());- Ok(())- }-- #[test]- fn encode_length_errors_for_oversized_messages() {- let err = encode_length(usize::MAX).unwrap_err();- assert_eq!(std::io::ErrorKind::InvalidInput, err.kind());- }-- #[tokio::test]- async fn receive_fails_when_peer_closes_before_header() {- let (server, client) = AsyncSocket::pair().expect("failed to create socket pair");- drop(client);- let err = server- .receive::<serde_json::Value>()- .await- .expect_err("expected read failure");- assert_eq!(std::io::ErrorKind::UnexpectedEof, err.kind());- }-}diff --git a/codex-rs/shell-escalation/src/unix/stopwatch.rs b/codex-rs/shell-escalation/src/unix/stopwatch.rsdeleted file mode 100644index 19821d8be2..0000000000--- a/codex-rs/shell-escalation/src/unix/stopwatch.rs+++ /dev/null@@ -1,237 +0,0 @@-use std::future::Future;-use std::sync::Arc;-use std::time::Duration;-use std::time::Instant;--use tokio::sync::Mutex;-use tokio::sync::Notify;-use tokio_util::sync::CancellationToken;--#[derive(Clone, Debug)]-pub struct Stopwatch {- limit: Option<Duration>,- inner: Arc<Mutex<StopwatchState>>,- notify: Arc<Notify>,-}--#[derive(Debug)]-struct StopwatchState {- elapsed: Duration,- running_since: Option<Instant>,- active_pauses: u32,-}--impl Stopwatch {- pub fn new(limit: Duration) -> Self {- Self {- inner: Arc::new(Mutex::new(StopwatchState {- elapsed: Duration::ZERO,- running_since: Some(Instant::now()),- active_pauses: 0,- })),- notify: Arc::new(Notify::new()),- limit: Some(limit),- }- }-- pub fn unlimited() -> Self {- Self {- inner: Arc::new(Mutex::new(StopwatchState {- elapsed: Duration::ZERO,- running_since: Some(Instant::now()),- active_pauses: 0,- })),- notify: Arc::new(Notify::new()),- limit: None,- }- }-- pub fn cancellation_token(&self) -> CancellationToken {- let token = CancellationToken::new();- let Some(limit) = self.limit else {- return token;- };- let cancel = token.clone();- let inner = Arc::clone(&self.inner);- let notify = Arc::clone(&self.notify);- tokio::spawn(async move {- loop {- let (remaining, running) = {- let guard = inner.lock().await;- let elapsed = guard.elapsed- + guard- .running_since- .map(|since| since.elapsed())- .unwrap_or_default();- if elapsed >= limit {- break;- }- (limit - elapsed, guard.running_since.is_some())- };-- if !running {- notify.notified().await;- continue;- }-- let sleep = tokio::time::sleep(remaining);- tokio::pin!(sleep);- tokio::select! {- _ = &mut sleep => {- break;- }- _ = notify.notified() => {- continue;- }- }- }- cancel.cancel();- });- token- }-- /// Runs `fut`, pausing the stopwatch while the future is pending. The clock- /// resumes automatically when the future completes. Nested/overlapping- /// calls are reference-counted so the stopwatch only resumes when every- /// pause is lifted.- pub async fn pause_for<F, T>(&self, fut: F) -> T- where- F: Future<Output = T>,- {- self.pause().await;- let result = fut.await;- self.resume().await;- result- }-- async fn pause(&self) {- let mut guard = self.inner.lock().await;- guard.active_pauses += 1;- if guard.active_pauses == 1- && let Some(since) = guard.running_since.take()- {- guard.elapsed += since.elapsed();- self.notify.notify_waiters();- }- }-- async fn resume(&self) {- let mut guard = self.inner.lock().await;- if guard.active_pauses == 0 {- return;- }- guard.active_pauses -= 1;- if guard.active_pauses == 0 && guard.running_since.is_none() {- guard.running_since = Some(Instant::now());- self.notify.notify_waiters();- }- }-}--#[cfg(test)]-mod tests {- use super::Stopwatch;- use tokio::time::Duration;- use tokio::time::Instant;- use tokio::time::sleep;- use tokio::time::timeout;-- #[tokio::test]- async fn cancellation_receiver_fires_after_limit() {- let stopwatch = Stopwatch::new(Duration::from_millis(50));- let token = stopwatch.cancellation_token();- let start = Instant::now();- token.cancelled().await;- assert!(start.elapsed() >= Duration::from_millis(50));- }-- #[tokio::test]- async fn pause_prevents_timeout_until_resumed() {- let stopwatch = Stopwatch::new(Duration::from_millis(50));- let token = stopwatch.cancellation_token();-- let pause_handle = tokio::spawn({- let stopwatch = stopwatch.clone();- async move {- stopwatch- .pause_for(async {- sleep(Duration::from_millis(100)).await;- })- .await;- }- });-- assert!(- timeout(Duration::from_millis(30), token.cancelled())- .await- .is_err()- );-- pause_handle.await.expect("pause task should finish");-- token.cancelled().await;- }-- #[tokio::test]- async fn overlapping_pauses_only_resume_once() {- let stopwatch = Stopwatch::new(Duration::from_millis(50));- let token = stopwatch.cancellation_token();-- // First pause.- let pause1 = {- let stopwatch = stopwatch.clone();- tokio::spawn(async move {- stopwatch- .pause_for(async {- sleep(Duration::from_millis(80)).await;- })- .await;- })- };-- // Overlapping pause that ends sooner.- let pause2 = {- let stopwatch = stopwatch.clone();- tokio::spawn(async move {- stopwatch- .pause_for(async {- sleep(Duration::from_millis(30)).await;- })- .await;- })- };-- // While both pauses are active, the cancellation should not fire.- assert!(- timeout(Duration::from_millis(40), token.cancelled())- .await- .is_err()- );-- pause2.await.expect("short pause should complete");-- // Still paused because the long pause is active.- assert!(- timeout(Duration::from_millis(30), token.cancelled())- .await- .is_err()- );-- pause1.await.expect("long pause should complete");-- // Now the stopwatch should resume and hit the limit shortly after.- token.cancelled().await;- }-- #[tokio::test]- async fn unlimited_stopwatch_never_cancels() {- let stopwatch = Stopwatch::unlimited();- let token = stopwatch.cancellation_token();-- assert!(- timeout(Duration::from_millis(30), token.cancelled())- .await- .is_err()- );- }-}diff --git a/codex-rs/thread-manager-sample/src/main.rs b/codex-rs/thread-manager-sample/src/main.rsindex 640f3a1855..b91d65cd9e 100644--- a/codex-rs/thread-manager-sample/src/main.rs+++ b/codex-rs/thread-manager-sample/src/main.rs@@ -341,7 +341,7 @@ async fn new_config(file_opener: UriBasedFileOpener::VsCode,codex_self_exe: arg0_paths.codex_self_exe,codex_linux_sandbox_exe: arg0_paths.codex_linux_sandbox_exe,- main_execve_wrapper_exe: arg0_paths.main_execve_wrapper_exe,+ main_execve_wrapper_exe: None,zsh_path: None,model_reasoning_effort: None,plan_mode_reasoning_effort: None,diff --git a/codex-rs/tools/Cargo.toml b/codex-rs/tools/Cargo.tomlindex f47815537f..fc75ad22ce 100644--- a/codex-rs/tools/Cargo.toml+++ b/codex-rs/tools/Cargo.toml@@ -15,7 +15,6 @@ codex-features = { workspace = true }codex-file-system = { workspace = true }codex-extension-items = { workspace = true }codex-protocol = { workspace = true }-codex-utils-absolute-path = { workspace = true }codex-utils-output-truncation = { workspace = true }codex-utils-path-uri = { workspace = true }codex-utils-string = { workspace = true }@@ -29,7 +28,6 @@ rmcp = { workspace = true, default-features = false, features = [serde = { workspace = true, features = ["derive"] }serde_json = { workspace = true, features = ["raw_value"] }thiserror = { workspace = true }-tracing = { workspace = true }urlencoding = { workspace = true }[dev-dependencies]diff --git a/codex-rs/tools/src/lib.rs b/codex-rs/tools/src/lib.rsindex 29c02afabb..a89697a2e9 100644--- a/codex-rs/tools/src/lib.rs+++ b/codex-rs/tools/src/lib.rs@@ -80,9 +80,6 @@ pub use tool_call::ToolEnvironment;pub use tool_call::TurnItemEmissionFuture;pub use tool_call::TurnItemEmitter;pub use tool_config::ToolEnvironmentMode;-pub use tool_config::ToolUserShellType;-pub use tool_config::UnifiedExecShellMode;-pub use tool_config::ZshForkConfig;pub use tool_config::request_user_input_available_modes;pub use tool_definition::ToolDefinition;pub use tool_discovery::DiscoverablePluginInfo;diff --git a/codex-rs/tools/src/tool_config.rs b/codex-rs/tools/src/tool_config.rsindex ea2a9688a7..3609405509 100644--- a/codex-rs/tools/src/tool_config.rs+++ b/codex-rs/tools/src/tool_config.rs@@ -2,17 +2,6 @@ use codex_features::Feature;use codex_features::Features;use codex_protocol::config_types::ModeKind;use codex_protocol::config_types::TUI_VISIBLE_COLLABORATION_MODES;-use codex_utils_absolute_path::AbsolutePathBuf;-use std::path::PathBuf;--#[derive(Debug, Clone, Copy, Eq, PartialEq)]-pub enum ToolUserShellType {- Zsh,- Bash,- PowerShell,- Sh,- Cmd,-}pub fn request_user_input_available_modes(features: &Features) -> Vec<ModeKind> {TUI_VISIBLE_COLLABORATION_MODES@@ -25,58 +14,6 @@ pub fn request_user_input_available_modes(features: &Features) -> Vec<ModeKind>.collect()}-#[derive(Debug, Clone, Eq, PartialEq)]-pub enum UnifiedExecShellMode {- Direct,- ZshFork(ZshForkConfig),-}--#[derive(Debug, Clone, Eq, PartialEq)]-pub struct ZshForkConfig {- pub shell_zsh_path: AbsolutePathBuf,- pub main_execve_wrapper_exe: AbsolutePathBuf,-}--impl UnifiedExecShellMode {- pub fn for_session(- features: &Features,- user_shell_type: ToolUserShellType,- shell_zsh_path: Option<&PathBuf>,- main_execve_wrapper_exe: Option<&PathBuf>,- ) -> Self {- if cfg!(unix)- && features.enabled(Feature::ShellTool)- && features.enabled(Feature::UnifiedExec)- && features.enabled(Feature::ShellZshFork)- && features.enabled(Feature::UnifiedExecZshFork)- && matches!(user_shell_type, ToolUserShellType::Zsh)- && let (Some(shell_zsh_path), Some(main_execve_wrapper_exe)) =- (shell_zsh_path, main_execve_wrapper_exe)- && let (Ok(shell_zsh_path), Ok(main_execve_wrapper_exe)) = (- AbsolutePathBuf::try_from(shell_zsh_path.as_path()).inspect_err(|err| {- tracing::warn!(- "Failed to convert shell_zsh_path `{shell_zsh_path:?}`: {err:?}"- )- }),- AbsolutePathBuf::try_from(main_execve_wrapper_exe.as_path()).inspect_err(- |err| {- tracing::warn!(- "Failed to convert main_execve_wrapper_exe `{main_execve_wrapper_exe:?}`: {err:?}"- )- },- ),- )- {- Self::ZshFork(ZshForkConfig {- shell_zsh_path,- main_execve_wrapper_exe,- })- } else {- Self::Direct- }- }-}-#[derive(Debug, Clone, Copy, PartialEq, Eq)]pub enum ToolEnvironmentMode {None,diff --git a/codex-rs/tools/src/tool_config_tests.rs b/codex-rs/tools/src/tool_config_tests.rsindex 69e6c13117..61ec0415b6 100644--- a/codex-rs/tools/src/tool_config_tests.rs+++ b/codex-rs/tools/src/tool_config_tests.rs@@ -20,70 +20,3 @@ fn request_user_input_modes_follow_default_mode_feature() {vec![ModeKind::Default, ModeKind::Plan]);}--#[test]-fn unified_exec_shell_mode_respects_feature_and_policy_gates() {- let exe = std::env::current_exe().expect("current exe path");- let shell = exe.clone();- let mut features = Features::with_defaults();- features.enable(Feature::ShellTool);- features.enable(Feature::ShellZshFork);- let mode = UnifiedExecShellMode::for_session(- &features,- ToolUserShellType::Zsh,- Some(&shell),- Some(&exe),- );- if cfg!(unix) {- assert!(matches!(mode, UnifiedExecShellMode::ZshFork(_)));- } else {- assert_eq!(mode, UnifiedExecShellMode::Direct);- }-- features.disable(Feature::ShellZshFork);- assert_eq!(- UnifiedExecShellMode::for_session(- &features,- ToolUserShellType::Zsh,- Some(&shell),- Some(&exe),- ),- UnifiedExecShellMode::Direct- );-- features.enable(Feature::ShellZshFork);- features.disable(Feature::UnifiedExecZshFork);- assert_eq!(- UnifiedExecShellMode::for_session(- &features,- ToolUserShellType::Zsh,- Some(&shell),- Some(&exe),- ),- UnifiedExecShellMode::Direct- );-- features.enable(Feature::UnifiedExecZshFork);- features.disable(Feature::UnifiedExec);- assert_eq!(- UnifiedExecShellMode::for_session(- &features,- ToolUserShellType::Zsh,- Some(&shell),- Some(&exe),- ),- UnifiedExecShellMode::Direct- );-- features.enable(Feature::UnifiedExec);- features.disable(Feature::ShellTool);- assert_eq!(- UnifiedExecShellMode::for_session(- &features,- ToolUserShellType::Zsh,- Some(&shell),- Some(&exe),- ),- UnifiedExecShellMode::Direct- );-}diff --git a/codex-rs/tui/src/history_cell/snapshots/codex_tui__history_cell__tests__legacy_zsh_migration_notice_snapshot.snap b/codex-rs/tui/src/history_cell/snapshots/codex_tui__history_cell__tests__legacy_zsh_migration_notice_snapshot.snapnew file mode 100644index 0000000000..9a790a64a5--- /dev/null+++ b/codex-rs/tui/src/history_cell/snapshots/codex_tui__history_cell__tests__legacy_zsh_migration_notice_snapshot.snap@@ -0,0 +1,8 @@+---+source: tui/src/history_cell/tests.rs+expression: "render_lines(&cell.transcript_lines(80)).join(\"\\n\")"+---+⚠ `[features].shell_zsh_fork` is deprecated and ignored.+The patched zsh backend has been removed. Shell commands now use the+standard shell executor. Remove `shell_zsh_fork` from [features] in+config.toml or profile configuration files.diff --git a/codex-rs/tui/src/history_cell/tests.rs b/codex-rs/tui/src/history_cell/tests.rsindex ea59afbbe7..f3b62e10dd 100644--- a/codex-rs/tui/src/history_cell/tests.rs+++ b/codex-rs/tui/src/history_cell/tests.rs@@ -2965,6 +2965,18 @@ fn deprecation_notice_renders_summary_with_details() {);}+#[test]+fn legacy_zsh_migration_notice_snapshot() {+ let mut features = codex_features::Features::default();+ features.record_legacy_usage_force("shell_zsh_fork", codex_features::Feature::ShellZshFork);+ let usage = features+ .legacy_feature_usages()+ .next()+ .expect("migration notice");+ let cell = new_deprecation_notice(usage.summary.clone(), usage.details.clone());+ insta::assert_snapshot!(render_lines(&cell.transcript_lines(/*width*/ 80)).join("\n"));+}+#[test]fn agent_markdown_cell_renders_source_at_different_widths() {let source =diff --git a/codex-rs/tui/src/session_archive_commands.rs b/codex-rs/tui/src/session_archive_commands.rsindex ea37b0fe20..47e4608d7d 100644--- a/codex-rs/tui/src/session_archive_commands.rs+++ b/codex-rs/tui/src/session_archive_commands.rs@@ -368,7 +368,6 @@ pub(super) async fn start_app_server_for_session_command(model_provider,codex_self_exe: arg0_paths.codex_self_exe.clone(),codex_linux_sandbox_exe: arg0_paths.codex_linux_sandbox_exe.clone(),- main_execve_wrapper_exe: arg0_paths.main_execve_wrapper_exe.clone(),show_raw_agent_reasoning: cli.oss.then_some(true),bypass_hook_trust: cli.bypass_hook_trust.then_some(true),..Default::default()diff --git a/codex-rs/tui/src/startup_orchestration.rs b/codex-rs/tui/src/startup_orchestration.rsindex 87c1c42f54..51bbad1b67 100644--- a/codex-rs/tui/src/startup_orchestration.rs+++ b/codex-rs/tui/src/startup_orchestration.rs@@ -441,7 +441,6 @@ pub(super) async fn run_main_inner(model_provider: model_provider_override.clone(),codex_self_exe: arg0_paths.codex_self_exe.clone(),codex_linux_sandbox_exe: arg0_paths.codex_linux_sandbox_exe.clone(),- main_execve_wrapper_exe: arg0_paths.main_execve_wrapper_exe.clone(),show_raw_agent_reasoning: cli.oss.then_some(true),bypass_hook_trust: cli.bypass_hook_trust.then_some(true),additional_writable_roots: additional_dirs,