clone/codex
1
0
Fork 0
mirror of https://github.com/openai/codex.git synced 2026-05-29 15:30:22 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat: gate unified exec zsh fork composition

Browse Source
This commit is contained in:
Michael Bolin
2026-05-28 15:54:02 -07:00
parent bcf2b55957
commit 9aa8c51741
10 changed files with 103 additions and 11 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
codex-rs/core/config.schema.json
View File

@@ -614,6 +614,9 @@
"unified_exec": {
"type": "boolean"
},
"unified_exec_zsh_fork": {
"type": "boolean"
},
"use_legacy_landlock": {
"type": "boolean"
},
@@ -4708,6 +4711,9 @@
"unified_exec": {
"type": "boolean"
},
"unified_exec_zsh_fork": {
"type": "boolean"
},
"use_legacy_landlock": {
"type": "boolean"
},

1
codex-rs/core/src/session/mod.rs
View File

@@ -362,7 +362,6 @@ use codex_protocol::protocol::WarningEvent;
use codex_protocol::user_input::UserInput;
use codex_tools::ToolEnvironmentMode;
use codex_tools::UnifiedExecShellMode;
use codex_tools::shell_command_backend_for_features;
use codex_utils_absolute_path::AbsolutePathBuf;
#[cfg(test)]
use codex_utils_stream_parser::ProposedPlanSegment;

3
codex-rs/core/src/session/review.rs
View File

@@ -30,9 +30,8 @@ pub(super) async fn spawn_review_thread(
.models_manager
.list_models(RefreshStrategy::OnlineIfUncached)
.await;
let shell_command_backend = shell_command_backend_for_features(review_features.get());
let unified_exec_shell_mode = UnifiedExecShellMode::for_session(
shell_command_backend,
codex_tools::unified_exec_zsh_fork_for_features(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(),

4
codex-rs/core/src/session/turn_context.rs
View File

@@ -465,10 +465,8 @@ impl Session {
let provider_for_context = create_model_provider(provider, auth_manager);
let session_telemetry_for_context = session_telemetry;
let available_models = models_manager.try_list_models().unwrap_or_default();
let shell_command_backend =
shell_command_backend_for_features(per_turn_config.features.get());
let unified_exec_shell_mode = UnifiedExecShellMode::for_session(
shell_command_backend,
codex_tools::unified_exec_zsh_fork_for_features(per_turn_config.features.get()),
crate::tools::tool_user_shell_type(user_shell),
shell_zsh_path,
main_execve_wrapper_exe,

40
codex-rs/core/src/tools/spec_plan_tests.rs
View File

@@ -382,6 +382,46 @@ async fn shell_family_registers_visible_unified_exec_and_hidden_legacy_shell() {
assert_eq!(plan.exposure("shell_command"), ToolExposure::Hidden);
}
#[tokio::test]
async fn shell_zsh_fork_stays_standalone_until_unified_exec_composition_is_enabled() {
let standalone = probe(|turn| {
set_features(turn, &[Feature::ShellTool, Feature::UnifiedExec]);
set_feature(turn, Feature::ShellZshFork, /*enabled*/ true);
set_feature(turn, Feature::UnifiedExecZshFork, /*enabled*/ false);
turn.model_info.shell_type = ConfigShellToolType::ShellCommand;
})
.await;
standalone.assert_visible_contains(&["shell_command"]);
standalone.assert_visible_lacks(&["exec_command", "write_stdin"]);
standalone.assert_registered_contains(&["shell_command"]);
standalone.assert_registered_lacks(&["exec_command", "write_stdin"]);
let composed = probe(|turn| {
set_features(
turn,
&[
Feature::ShellTool,
Feature::UnifiedExec,
Feature::ShellZshFork,
Feature::UnifiedExecZshFork,
],
);
turn.model_info.shell_type = ConfigShellToolType::ShellCommand;
})
.await;
if codex_utils_pty::conpty_supported() {
composed.assert_visible_contains(&["exec_command", "write_stdin"]);
composed.assert_visible_lacks(&["shell_command"]);
composed.assert_registered_contains(&["exec_command", "write_stdin", "shell_command"]);
assert_eq!(composed.exposure("shell_command"), ToolExposure::Hidden);
} else {
composed.assert_visible_contains(&["shell_command"]);
composed.assert_visible_lacks(&["exec_command", "write_stdin"]);
}
}
#[tokio::test]
async fn environment_count_controls_environment_backed_tools() {
let no_environment = probe(|turn| {

8
codex-rs/features/src/lib.rs
View File

@@ -90,6 +90,8 @@ pub enum Feature {
UnifiedExec,
/// Route shell tool execution through the zsh exec bridge.
ShellZshFork,
/// Route unified exec through the zsh exec bridge when both are enabled.
UnifiedExecZshFork,
/// Reflow transcript scrollback when the terminal is resized.
TerminalResizeReflow,
/// Stream structured progress while apply_patch input is being generated.
@@ -739,6 +741,12 @@ pub const FEATURES: &[FeatureSpec] = &[
stage: Stage::UnderDevelopment,
default_enabled: false,
},
FeatureSpec {
id: Feature::UnifiedExecZshFork,
key: "unified_exec_zsh_fork",
stage: Stage::UnderDevelopment,
default_enabled: false,
},
FeatureSpec {
id: Feature::ShellSnapshot,
key: "shell_snapshot",

10
codex-rs/features/src/tests.rs
View File

@@ -136,6 +136,16 @@ fn request_permissions_tool_is_under_development() {
assert_eq!(Feature::RequestPermissionsTool.default_enabled(), false);
}
#[test]
fn unified_exec_zsh_fork_is_under_development() {
assert_eq!(Feature::UnifiedExecZshFork.stage(), Stage::UnderDevelopment);
assert_eq!(Feature::UnifiedExecZshFork.default_enabled(), false);
assert_eq!(
feature_for_key("unified_exec_zsh_fork"),
Some(Feature::UnifiedExecZshFork)
);
}
#[test]
fn remote_compaction_v2_is_under_development() {
assert_eq!(Feature::RemoteCompactionV2.stage(), Stage::UnderDevelopment);

1
codex-rs/tools/src/lib.rs
View File

@@ -75,6 +75,7 @@ pub use tool_config::ZshForkConfig;
pub use tool_config::request_user_input_available_modes;
pub use tool_config::shell_command_backend_for_features;
pub use tool_config::shell_type_for_model_and_features;
pub use tool_config::unified_exec_zsh_fork_for_features;
pub use tool_definition::ToolDefinition;
pub use tool_discovery::DiscoverablePluginInfo;
pub use tool_discovery::DiscoverableTool;

15
codex-rs/tools/src/tool_config.rs
View File

@@ -41,6 +41,13 @@ pub fn shell_command_backend_for_features(features: &Features) -> ShellCommandBa
}
}
pub fn unified_exec_zsh_fork_for_features(features: &Features) -> bool {
features.enabled(Feature::ShellTool)
&& features.enabled(Feature::UnifiedExec)
&& features.enabled(Feature::ShellZshFork)
&& features.enabled(Feature::UnifiedExecZshFork)
}
pub fn shell_type_for_model_and_features(
model_info: &ModelInfo,
features: &Features,
@@ -58,7 +65,9 @@ pub fn shell_type_for_model_and_features(
if !features.enabled(Feature::ShellTool) {
ConfigShellToolType::Disabled
} else if features.enabled(Feature::ShellZshFork) {
} else if features.enabled(Feature::ShellZshFork)
&& !unified_exec_zsh_fork_for_features(features)
{
ConfigShellToolType::ShellCommand
} else if unified_exec_enabled {
if codex_utils_pty::conpty_supported() {
@@ -85,13 +94,13 @@ pub struct ZshForkConfig {
impl UnifiedExecShellMode {
pub fn for_session(
shell_command_backend: ShellCommandBackendConfig,
use_zsh_fork: bool,
user_shell_type: ToolUserShellType,
shell_zsh_path: Option<&PathBuf>,
main_execve_wrapper_exe: Option<&PathBuf>,
) -> Self {
if cfg!(unix)
&& shell_command_backend == ShellCommandBackendConfig::ZshFork
&& use_zsh_fork
&& matches!(user_shell_type, ToolUserShellType::Zsh)
&& let (Some(shell_zsh_path), Some(main_execve_wrapper_exe)) =
(shell_zsh_path, main_execve_wrapper_exe)

26
codex-rs/tools/src/tool_config_tests.rs
View File

@@ -81,6 +81,12 @@ fn shell_type_is_derived_from_model_and_feature_gates() {
ConfigShellToolType::ShellCommand
);
features.enable(Feature::UnifiedExecZshFork);
assert_eq!(
shell_type_for_model_and_features(&model, &features),
expected_unified_exec
);
features.disable(Feature::ShellTool);
assert_eq!(
shell_type_for_model_and_features(&model, &features),
@@ -109,6 +115,22 @@ fn shell_command_backend_requires_both_shell_tool_and_zsh_fork() {
);
}
#[test]
fn unified_exec_zsh_fork_requires_all_feature_gates() {
let mut features = shell_features();
assert_eq!(unified_exec_zsh_fork_for_features(&features), false);
features.enable(Feature::UnifiedExec);
features.enable(Feature::ShellZshFork);
assert_eq!(unified_exec_zsh_fork_for_features(&features), false);
features.enable(Feature::UnifiedExecZshFork);
assert_eq!(unified_exec_zsh_fork_for_features(&features), true);
features.disable(Feature::ShellTool);
assert_eq!(unified_exec_zsh_fork_for_features(&features), false);
}
#[test]
fn request_user_input_modes_follow_default_mode_feature() {
let mut features = Features::with_defaults();
@@ -131,7 +153,7 @@ fn unified_exec_shell_mode_uses_zsh_fork_only_when_all_inputs_match() {
let shell = exe.clone();
let mode = UnifiedExecShellMode::for_session(
ShellCommandBackendConfig::ZshFork,
/*use_zsh_fork*/ true,
ToolUserShellType::Zsh,
Some(&shell),
Some(&exe),
@@ -144,7 +166,7 @@ fn unified_exec_shell_mode_uses_zsh_fork_only_when_all_inputs_match() {
assert_eq!(
UnifiedExecShellMode::for_session(
ShellCommandBackendConfig::Classic,
/*use_zsh_fork*/ false,
ToolUserShellType::Zsh,
Some(&shell),
Some(&exe),