Lightweight coding agent that runs in your terminal
Rust
Wire the Windows MXC sandbox into command execution (#45176)
iceweasel-oaic379459bba59
diff --git a/codex-rs/app-server/src/request_processors/command_exec_processor.rs b/codex-rs/app-server/src/request_processors/command_exec_processor.rsindex fde1b9e895..9ce19397d2 100644--- a/codex-rs/app-server/src/request_processors/command_exec_processor.rs+++ b/codex-rs/app-server/src/request_processors/command_exec_processor.rs@@ -315,6 +315,7 @@ impl CommandExecRequestProcessor {&sandbox_cwd,windows_sandbox_workspace_roots.as_slice(),&codex_linux_sandbox_exe,+ &self.arg0_paths.codex_self_exe,use_legacy_landlock,).map_err(|err| internal_error(format!("exec failed: {err}")))?;diff --git a/codex-rs/app-server/src/request_processors/thread_processor.rs b/codex-rs/app-server/src/request_processors/thread_processor.rsindex c6e0524ba3..de98fc7cde 100644--- a/codex-rs/app-server/src/request_processors/thread_processor.rs+++ b/codex-rs/app-server/src/request_processors/thread_processor.rs@@ -4907,7 +4907,7 @@ impl ThreadRequestProcessor {serde_json::json!("unelevated"),);}- WindowsSandboxLevel::Disabled => {}+ WindowsSandboxLevel::Disabled | WindowsSandboxLevel::Mxc => {}}}let request_overrides = if cli_overrides.is_empty() {diff --git a/codex-rs/app-server/src/request_processors/windows_sandbox_processor.rs b/codex-rs/app-server/src/request_processors/windows_sandbox_processor.rsindex 70e0e6efa8..34ffcfc129 100644--- a/codex-rs/app-server/src/request_processors/windows_sandbox_processor.rs+++ b/codex-rs/app-server/src/request_processors/windows_sandbox_processor.rs@@ -222,7 +222,9 @@ fn determine_windows_sandbox_readiness_from_state() -> WindowsSandboxReadinessResponse {let status = match windows_sandbox_level {WindowsSandboxLevel::Disabled => WindowsSandboxReadiness::NotConfigured,- WindowsSandboxLevel::RestrictedToken => WindowsSandboxReadiness::Ready,+ WindowsSandboxLevel::RestrictedToken | WindowsSandboxLevel::Mxc => {+ WindowsSandboxReadiness::Ready+ }WindowsSandboxLevel::Elevated => {if sandbox_setup_is_complete {WindowsSandboxReadiness::Readydiff --git a/codex-rs/core/src/config/mod.rs b/codex-rs/core/src/config/mod.rsindex 5ae1f366a0..f1aa685185 100644--- a/codex-rs/core/src/config/mod.rs+++ b/codex-rs/core/src/config/mod.rs@@ -3329,7 +3329,7 @@ impl Config {match WindowsSandboxLevel::from_features(&features) {WindowsSandboxLevel::Elevated => Some(WindowsSandboxModeToml::Elevated),WindowsSandboxLevel::RestrictedToken => Some(WindowsSandboxModeToml::Unelevated),- WindowsSandboxLevel::Disabled => None,+ WindowsSandboxLevel::Disabled | WindowsSandboxLevel::Mxc => None,}});apply_requirement_constrained_value(diff --git a/codex-rs/core/src/exec.rs b/codex-rs/core/src/exec.rsindex 95b78ebace..78c0076f0d 100644--- a/codex-rs/core/src/exec.rs+++ b/codex-rs/core/src/exec.rs@@ -300,6 +300,7 @@ pub async fn process_exec_tool_call(sandbox_cwd: &AbsolutePathBuf,windows_sandbox_workspace_roots: &[AbsolutePathBuf],codex_linux_sandbox_exe: &Option<PathBuf>,+ codex_self_exe: &Option<PathBuf>,use_legacy_landlock: bool,stdout_stream: Option<StdoutStream>,) -> Result<ExecToolCallOutput> {@@ -309,6 +310,7 @@ pub async fn process_exec_tool_call(sandbox_cwd,windows_sandbox_workspace_roots,codex_linux_sandbox_exe,+ codex_self_exe,use_legacy_landlock,)?;@@ -324,6 +326,7 @@ pub fn build_exec_request(sandbox_cwd: &AbsolutePathBuf,windows_sandbox_workspace_roots: &[AbsolutePathBuf],codex_linux_sandbox_exe: &Option<PathBuf>,+ codex_self_exe: &Option<PathBuf>,use_legacy_landlock: bool,) -> Result<ExecRequest> {let ExecParams {@@ -390,7 +393,11 @@ pub fn build_exec_request(environment_id: network_environment_id.as_deref(),network: network.as_ref(),sandbox_policy_cwd: &sandbox_policy_cwd_uri,- codex_linux_sandbox_exe: codex_linux_sandbox_exe.as_deref(),+ sandbox_exe: if cfg!(windows) {+ codex_self_exe.as_deref()+ } else {+ codex_linux_sandbox_exe.as_deref()+ },use_legacy_landlock,windows_sandbox_level,windows_sandbox_private_desktop,diff --git a/codex-rs/core/src/exec_tests.rs b/codex-rs/core/src/exec_tests.rsindex fde92af514..93000cfb51 100644--- a/codex-rs/core/src/exec_tests.rs+++ b/codex-rs/core/src/exec_tests.rs@@ -515,6 +515,7 @@ async fn process_exec_tool_call_preserves_full_buffer_capture_policy(&cwd,std::slice::from_ref(&cwd),&None,+ /*codex_self_exe*/ &None,/*use_legacy_landlock*/ false,/*stdout_stream*/ None,)@@ -1219,6 +1220,7 @@ fn build_exec_request_preserves_windows_workspace_roots() -> Result<()> {&cwd,workspace_roots.as_slice(),&None,+ /*codex_self_exe*/ &None,/*use_legacy_landlock*/ false,)?;@@ -1338,6 +1340,7 @@ async fn process_exec_tool_call_respects_cancellation_token() -> Result<()> {&cwd,std::slice::from_ref(&cwd),&None,+ /*codex_self_exe*/ &None,/*use_legacy_landlock*/ false,/*stdout_stream*/ None,),@@ -1419,6 +1422,7 @@ while :; do sleep 1; done"#&cwd,std::slice::from_ref(&cwd),&None,+ /*codex_self_exe*/ &None,/*use_legacy_landlock*/ false,/*stdout_stream*/ None,),diff --git a/codex-rs/core/src/sandbox_tags.rs b/codex-rs/core/src/sandbox_tags.rsindex 7c453996f4..120dbff0da 100644--- a/codex-rs/core/src/sandbox_tags.rs+++ b/codex-rs/core/src/sandbox_tags.rs@@ -77,9 +77,12 @@ fn permission_profile_sandbox_tag(}}}- if cfg!(target_os = "windows") && matches!(windows_sandbox_level, WindowsSandboxLevel::Elevated)- {- return "windows_elevated";+ if cfg!(target_os = "windows") {+ match windows_sandbox_level {+ WindowsSandboxLevel::Mxc => return "windows_mxc",+ WindowsSandboxLevel::Elevated => return "windows_elevated",+ WindowsSandboxLevel::Disabled | WindowsSandboxLevel::RestrictedToken => {}+ }}get_platform_sandbox(windows_sandbox_level != WindowsSandboxLevel::Disabled)diff --git a/codex-rs/core/src/shell_snapshot_sandbox.rs b/codex-rs/core/src/shell_snapshot_sandbox.rsindex 758aa3dbd5..3bb156dd60 100644--- a/codex-rs/core/src/shell_snapshot_sandbox.rs+++ b/codex-rs/core/src/shell_snapshot_sandbox.rs@@ -39,7 +39,7 @@ pub(crate) struct ShellSnapshotSandbox {enforce_managed_network: bool,sandbox_policy_cwd: PathUri,workspace_roots: Vec<PathUri>,- codex_linux_sandbox_exe: Option<PathBuf>,+ sandbox_exe: Option<PathBuf>,use_legacy_landlock: bool,windows_sandbox_level: WindowsSandboxLevel,windows_sandbox_private_desktop: bool,@@ -84,7 +84,7 @@ impl ShellSnapshotSandbox {enforce_managed_network: attempt.enforce_managed_network,sandbox_policy_cwd: attempt.sandbox_cwd.clone(),workspace_roots: attempt.workspace_roots.to_vec(),- codex_linux_sandbox_exe: attempt.codex_linux_sandbox_exe.cloned(),+ sandbox_exe: attempt.sandbox_exe.cloned(),use_legacy_landlock: attempt.use_legacy_landlock,windows_sandbox_level: attempt.windows_sandbox_level,windows_sandbox_private_desktop: attempt.windows_sandbox_private_desktop,@@ -103,7 +103,7 @@ impl ShellSnapshotSandbox {self.enforce_managed_network,&self.sandbox_policy_cwd,&self.workspace_roots,- &self.codex_linux_sandbox_exe,+ &self.sandbox_exe,self.use_legacy_landlock,self.windows_sandbox_level,self.windows_sandbox_private_desktop,@@ -172,7 +172,7 @@ impl ShellSnapshotSandbox {environment_id: Some(&self.environment_id),network: self.network.as_ref(),sandbox_policy_cwd: &self.sandbox_policy_cwd,- codex_linux_sandbox_exe: self.codex_linux_sandbox_exe.as_deref(),+ sandbox_exe: self.sandbox_exe.as_deref(),use_legacy_landlock: self.use_legacy_landlock,windows_sandbox_level: self.windows_sandbox_level,windows_sandbox_private_desktop: self.windows_sandbox_private_desktop,diff --git a/codex-rs/core/src/shell_snapshot_sandbox_tests.rs b/codex-rs/core/src/shell_snapshot_sandbox_tests.rsindex 2a44248977..85fa3b9db0 100644--- a/codex-rs/core/src/shell_snapshot_sandbox_tests.rs+++ b/codex-rs/core/src/shell_snapshot_sandbox_tests.rs@@ -42,7 +42,7 @@ async fn snapshot_failure_omits_credentials_and_stops_descendants(manager: &manager,sandbox_cwd: &cwd_uri,workspace_roots: std::slice::from_ref(&cwd_uri),- codex_linux_sandbox_exe: None,+ sandbox_exe: None,use_legacy_landlock: false,windows_sandbox_level: WindowsSandboxLevel::Disabled,windows_sandbox_private_desktop: false,diff --git a/codex-rs/core/src/shell_snapshot_tests.rs b/codex-rs/core/src/shell_snapshot_tests.rsindex 4193e35221..d88af88829 100644--- a/codex-rs/core/src/shell_snapshot_tests.rs+++ b/codex-rs/core/src/shell_snapshot_tests.rs@@ -416,7 +416,7 @@ async fn inactive_profiles_keep_snapshots_but_active_brokers_require_sandbox() -manager: &manager,sandbox_cwd: &cwd_uri,workspace_roots: std::slice::from_ref(&cwd_uri),- codex_linux_sandbox_exe: None,+ sandbox_exe: None,use_legacy_landlock: false,windows_sandbox_level: WindowsSandboxLevel::Disabled,windows_sandbox_private_desktop: false,diff --git a/codex-rs/core/src/tools/orchestrator.rs b/codex-rs/core/src/tools/orchestrator.rsindex ec5be46125..4e66949f24 100644--- a/codex-rs/core/src/tools/orchestrator.rs+++ b/codex-rs/core/src/tools/orchestrator.rs@@ -88,7 +88,7 @@ impl ToolOrchestrator {manager: attempt.manager,sandbox_cwd: attempt.sandbox_cwd,workspace_roots: attempt.workspace_roots,- codex_linux_sandbox_exe: attempt.codex_linux_sandbox_exe,+ sandbox_exe: attempt.sandbox_exe,use_legacy_landlock: attempt.use_legacy_landlock,windows_sandbox_level: attempt.windows_sandbox_level,windows_sandbox_private_desktop: attempt.windows_sandbox_private_desktop,@@ -290,6 +290,11 @@ impl ToolOrchestrator {.sandbox_cwd(req).cloned().unwrap_or_else(|| environment.cwd().clone());+ let codex_sandbox_exe = if cfg!(windows) {+ turn_ctx.config.codex_self_exe.as_ref()+ } else {+ turn_ctx.config.codex_linux_sandbox_exe.as_ref()+ };let initial_attempt = SandboxAttempt {sandbox: initial_sandbox,sandbox_requested,@@ -299,7 +304,7 @@ impl ToolOrchestrator {manager: &sandbox_manager,sandbox_cwd: &sandbox_policy_cwd,workspace_roots,- codex_linux_sandbox_exe: turn_ctx.config.codex_linux_sandbox_exe.as_ref(),+ sandbox_exe: codex_sandbox_exe,use_legacy_landlock: sandbox_config.use_legacy_landlock,windows_sandbox_level: sandbox_config.windows_sandbox_level,windows_sandbox_private_desktop: sandbox_config.windows_sandbox_private_desktop,@@ -459,10 +464,10 @@ impl ToolOrchestrator {} else {SandboxType::None};- let retry_codex_linux_sandbox_exe = if unsandboxed_allowed {+ let retry_sandbox_exe = if unsandboxed_allowed {None} else {- turn_ctx.config.codex_linux_sandbox_exe.as_ref()+ codex_sandbox_exe};let retry_attempt = SandboxAttempt {sandbox: retry_sandbox,@@ -473,7 +478,7 @@ impl ToolOrchestrator {manager: &sandbox_manager,sandbox_cwd: &sandbox_policy_cwd,workspace_roots,- codex_linux_sandbox_exe: retry_codex_linux_sandbox_exe,+ sandbox_exe: retry_sandbox_exe,use_legacy_landlock: sandbox_config.use_legacy_landlock,windows_sandbox_level: sandbox_config.windows_sandbox_level,windows_sandbox_private_desktop: sandbox_config.windows_sandbox_private_desktop,diff --git a/codex-rs/core/src/tools/runtimes/apply_patch_tests.rs b/codex-rs/core/src/tools/runtimes/apply_patch_tests.rsindex 35470229b4..becb1c4839 100644--- a/codex-rs/core/src/tools/runtimes/apply_patch_tests.rs+++ b/codex-rs/core/src/tools/runtimes/apply_patch_tests.rs@@ -246,7 +246,7 @@ async fn file_system_sandbox_context_preserves_executor_workspace_permissions()manager: &manager,sandbox_cwd: &sandbox_policy_cwd,workspace_roots: std::slice::from_ref(&sandbox_policy_cwd),- codex_linux_sandbox_exe: None,+ sandbox_exe: None,use_legacy_landlock: true,windows_sandbox_level: WindowsSandboxLevel::RestrictedToken,windows_sandbox_private_desktop: true,@@ -315,7 +315,7 @@ async fn file_system_sandbox_context_respects_sandbox_request() {manager: &manager,sandbox_cwd: &sandbox_policy_cwd,workspace_roots: std::slice::from_ref(&sandbox_policy_cwd),- codex_linux_sandbox_exe: None,+ sandbox_exe: None,use_legacy_landlock: false,windows_sandbox_level: WindowsSandboxLevel::Disabled,windows_sandbox_private_desktop: false,diff --git a/codex-rs/core/src/tools/runtimes/mod_tests.rs b/codex-rs/core/src/tools/runtimes/mod_tests.rsindex 8d0d9b5f8b..8640654856 100644--- a/codex-rs/core/src/tools/runtimes/mod_tests.rs+++ b/codex-rs/core/src/tools/runtimes/mod_tests.rs@@ -124,7 +124,7 @@ async fn explicit_escalation_prepares_exec_without_managed_network() -> anyhow::manager: &manager,sandbox_cwd: &sandbox_policy_cwd,workspace_roots: std::slice::from_ref(&sandbox_policy_cwd),- codex_linux_sandbox_exe: None,+ sandbox_exe: None,use_legacy_landlock: false,windows_sandbox_level: WindowsSandboxLevel::Disabled,windows_sandbox_private_desktop: false,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.rsindex d0be8e1f9b..b32bbf1a1d 100644--- a/codex-rs/core/src/tools/runtimes/zsh_fork/unix_escalation.rs+++ b/codex-rs/core/src/tools/runtimes/zsh_fork/unix_escalation.rs@@ -789,7 +789,7 @@ impl CoreShellCommandExecutor {environment_id: self.network_environment_id.as_deref(),network: self.network.as_ref(),sandbox_policy_cwd: &sandbox_policy_cwd,- codex_linux_sandbox_exe: self.codex_linux_sandbox_exe.as_deref(),+ sandbox_exe: self.codex_linux_sandbox_exe.as_deref(),use_legacy_landlock: self.use_legacy_landlock,windows_sandbox_level: self.windows_sandbox_level,windows_sandbox_private_desktop: false,diff --git a/codex-rs/core/src/tools/sandboxing.rs b/codex-rs/core/src/tools/sandboxing.rsindex 615b917413..a9931e54e0 100644--- a/codex-rs/core/src/tools/sandboxing.rs+++ b/codex-rs/core/src/tools/sandboxing.rs@@ -394,7 +394,7 @@ pub(crate) struct SandboxAttempt<'a> {pub(crate) manager: &'a SandboxManager,pub(crate) sandbox_cwd: &'a PathUri,pub(crate) workspace_roots: &'a [PathUri],- pub codex_linux_sandbox_exe: Option<&'a std::path::PathBuf>,+ pub sandbox_exe: Option<&'a std::path::PathBuf>,// TODO(anp): Reconcile these attempt settings with TurnEnvironment::sandbox_context// so process execution and patch writes honor the selected environment's backend.pub use_legacy_landlock: bool,@@ -459,9 +459,7 @@ impl<'a> SandboxAttempt<'a> {environment_id,network,sandbox_policy_cwd: self.sandbox_cwd,- codex_linux_sandbox_exe: self- .codex_linux_sandbox_exe- .map(std::path::PathBuf::as_path),+ sandbox_exe: self.sandbox_exe.map(std::path::PathBuf::as_path),use_legacy_landlock: self.use_legacy_landlock,windows_sandbox_level: self.windows_sandbox_level,windows_sandbox_private_desktop: self.windows_sandbox_private_desktop,@@ -496,7 +494,7 @@ impl<'a> SandboxAttempt<'a> {environment_id: None,network: None,sandbox_policy_cwd: self.sandbox_cwd,- codex_linux_sandbox_exe: None,+ sandbox_exe: None,use_legacy_landlock: self.use_legacy_landlock,windows_sandbox_level: self.windows_sandbox_level,windows_sandbox_private_desktop: self.windows_sandbox_private_desktop,diff --git a/codex-rs/core/src/tools/sandboxing_tests.rs b/codex-rs/core/src/tools/sandboxing_tests.rsindex 0a9e1fe114..3f47ae13e6 100644--- a/codex-rs/core/src/tools/sandboxing_tests.rs+++ b/codex-rs/core/src/tools/sandboxing_tests.rs@@ -255,7 +255,7 @@ fn windows_sandbox_env_preserves_denied_reads_or_rejects_unsupported_backend() {manager: &manager,sandbox_cwd: &cwd_uri,workspace_roots: std::slice::from_ref(&cwd_uri),- codex_linux_sandbox_exe: None,+ sandbox_exe: None,use_legacy_landlock: false,windows_sandbox_level: codex_protocol::config_types::WindowsSandboxLevel::Elevated,windows_sandbox_private_desktop: false,@@ -326,7 +326,7 @@ fn exec_server_env_keeps_command_native_and_carries_sandbox_context() {manager: &manager,sandbox_cwd: &cwd_uri,workspace_roots: std::slice::from_ref(&cwd_uri),- codex_linux_sandbox_exe: None,+ sandbox_exe: None,use_legacy_landlock: false,windows_sandbox_level: codex_protocol::config_types::WindowsSandboxLevel::Disabled,windows_sandbox_private_desktop: false,diff --git a/codex-rs/core/tests/suite/exec.rs b/codex-rs/core/tests/suite/exec.rsindex 355711e345..36f1dbd864 100644--- a/codex-rs/core/tests/suite/exec.rs+++ b/codex-rs/core/tests/suite/exec.rs@@ -55,6 +55,7 @@ where&cwd,std::slice::from_ref(&cwd),&None,+ /*codex_self_exe*/ &None,/*use_legacy_landlock*/ false,/*stdout_stream*/ None,)diff --git a/codex-rs/core/tests/suite/windows_sandbox.rs b/codex-rs/core/tests/suite/windows_sandbox.rsindex 887ed5a42f..14e140ff8e 100644--- a/codex-rs/core/tests/suite/windows_sandbox.rs+++ b/codex-rs/core/tests/suite/windows_sandbox.rs@@ -375,6 +375,7 @@ async fn windows_restricted_token_rejects_exact_and_glob_deny_read_policy() -> a&cwd,std::slice::from_ref(&cwd),&None,+ /*codex_self_exe*/ &None,/*use_legacy_landlock*/ false,/*stdout_stream*/ None,)@@ -424,6 +425,7 @@ async fn windows_elevated_does_not_create_missing_workspace_metadata() -> anyhow&cwd,std::slice::from_ref(&cwd),&None,+ /*codex_self_exe*/ &None,/*use_legacy_landlock*/ false,/*stdout_stream*/ None,)@@ -603,6 +605,7 @@ async fn windows_elevated_enforces_deny_read_and_protects_setup_marker() -> anyh&cwd,std::slice::from_ref(&cwd),&None,+ /*codex_self_exe*/ &None,/*use_legacy_landlock*/ false,/*stdout_stream*/ None,)diff --git a/codex-rs/exec-server-protocol/src/protocol.rs b/codex-rs/exec-server-protocol/src/protocol.rsindex 64b9e2a346..8ef964028a 100644--- a/codex-rs/exec-server-protocol/src/protocol.rs+++ b/codex-rs/exec-server-protocol/src/protocol.rs@@ -152,6 +152,9 @@ pub struct EnvironmentCapabilities {/// Whether shell state can be cached and restored entirely inside the executor.#[serde(default)]pub shell_snapshot_v2: bool,+ /// Whether requests may explicitly select the MXC Windows sandbox backend.+ #[serde(default)]+ pub windows_mxc: bool,}/// Status returned by an initialized exec-server connection.@@ -243,6 +246,7 @@ impl EnvironmentInfo {http_header_env_vars: true,sandboxed_file_streaming: true,shell_snapshot_v2: cfg!(unix),+ windows_mxc: false,},}}@@ -358,6 +362,7 @@ pub enum ProcessSandboxType {MacosSeatbelt,LinuxSeccomp,WindowsRestrictedToken,+ WindowsMxc,}#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]@@ -1057,6 +1062,7 @@ mod tests {http_header_env_vars: false,sandboxed_file_streaming: false,shell_snapshot_v2: false,+ windows_mxc: false,});}@@ -1078,6 +1084,7 @@ mod tests {"httpHeaderEnvVars": false,"sandboxedFileStreaming": false,"shellSnapshotV2": false,+ "windowsMxc": false,},});let info: EnvironmentInfo = serde_json::from_value(expected.clone())diff --git a/codex-rs/exec-server/src/fs_sandbox.rs b/codex-rs/exec-server/src/fs_sandbox.rsindex cd7c311267..566973e526 100644--- a/codex-rs/exec-server/src/fs_sandbox.rs+++ b/codex-rs/exec-server/src/fs_sandbox.rs@@ -176,7 +176,11 @@ impl FileSystemSandboxRunner {environment_id: None,network: None,sandbox_policy_cwd: &cwd.uri,- codex_linux_sandbox_exe: self.runtime_paths.codex_linux_sandbox_exe.as_deref(),+ sandbox_exe: if cfg!(windows) {+ Some(self.runtime_paths.codex_self_exe.as_path())+ } else {+ self.runtime_paths.codex_linux_sandbox_exe.as_deref()+ },use_legacy_landlock: sandbox_context.use_legacy_landlock,windows_sandbox_level: sandbox_context.windows_sandbox_level,windows_sandbox_private_desktop: sandbox_contextdiff --git a/codex-rs/exec-server/src/local_process.rs b/codex-rs/exec-server/src/local_process.rsindex c728c7416e..be4606883c 100644--- a/codex-rs/exec-server/src/local_process.rs+++ b/codex-rs/exec-server/src/local_process.rs@@ -396,6 +396,7 @@ impl LocalProcess {SandboxType::MacosSeatbelt => Some(ProcessSandboxType::MacosSeatbelt),SandboxType::LinuxSeccomp => Some(ProcessSandboxType::LinuxSeccomp),SandboxType::WindowsRestrictedToken => Some(ProcessSandboxType::WindowsRestrictedToken),+ SandboxType::WindowsMxc => Some(ProcessSandboxType::WindowsMxc),};let start = Arc::new(ProcessStart);diff --git a/codex-rs/exec-server/src/process.rs b/codex-rs/exec-server/src/process.rsindex 726c8a6392..5e795faa1a 100644--- a/codex-rs/exec-server/src/process.rs+++ b/codex-rs/exec-server/src/process.rs@@ -35,6 +35,7 @@ pub(crate) fn sandbox_type_from_protocol(Some(ProcessSandboxType::WindowsRestrictedToken) => {Some(SandboxType::WindowsRestrictedToken)}+ Some(ProcessSandboxType::WindowsMxc) => Some(SandboxType::WindowsMxc),}}diff --git a/codex-rs/exec-server/src/process_sandbox.rs b/codex-rs/exec-server/src/process_sandbox.rsindex a16c182c73..15bff80842 100644--- a/codex-rs/exec-server/src/process_sandbox.rs+++ b/codex-rs/exec-server/src/process_sandbox.rs@@ -84,6 +84,28 @@ pub(crate) async fn prepare_exec_request_with_telemetry(network_policy_audit_observer: Option<NetworkPolicyAuditObserver>,telemetry: &ProcessTelemetry,) -> Result<PreparedExecRequest, JSONRPCErrorError> {+ if let Some(sandbox) = params.sandbox.as_ref()+ && sandbox.windows_sandbox_level == codex_protocol::config_types::WindowsSandboxLevel::Mxc+ {+ if params.tty || params.arg0.is_some() {+ return Err(invalid_params(+ "MXC currently supports ordinary pipe launches only".to_owned(),+ ));+ }+ if params.enforce_managed_network+ || params.managed_network.is_some()+ || params.network_proxy.is_some()+ {+ return Err(invalid_params(+ "MXC managed networking is not supported yet".to_owned(),+ ));+ }+ if !codex_sandboxing::windows_mxc_available() {+ return Err(invalid_params(+ "native MXC is unavailable on this executor".to_owned(),+ ));+ }+ }#[cfg(target_os = "windows")]let mut env = env;#[cfg(target_os = "windows")]@@ -241,7 +263,11 @@ pub(crate) async fn prepare_exec_request_with_telemetry(environment_id: None,network: None,sandbox_policy_cwd,- codex_linux_sandbox_exe: runtime_paths.codex_linux_sandbox_exe.as_deref(),+ sandbox_exe: if cfg!(windows) {+ Some(runtime_paths.codex_self_exe.as_path())+ } else {+ runtime_paths.codex_linux_sandbox_exe.as_deref()+ },use_legacy_landlock: sandbox_context.use_legacy_landlock,windows_sandbox_level: sandbox_context.windows_sandbox_level,windows_sandbox_private_desktop: sandbox_context.windows_sandbox_private_desktop,diff --git a/codex-rs/exec-server/src/process_sandbox_tests.rs b/codex-rs/exec-server/src/process_sandbox_tests.rsindex 00840569c1..d2b65555d0 100644--- a/codex-rs/exec-server/src/process_sandbox_tests.rs+++ b/codex-rs/exec-server/src/process_sandbox_tests.rs@@ -129,6 +129,33 @@ async fn sandbox_request_wraps_native_argv_on_executor() {prepared.command.first().map(String::as_str),Some("/usr/bin/sandbox-exec"));++ let mut params = params;+ params.sandbox.as_mut().unwrap().windows_sandbox_level =+ codex_protocol::config_types::WindowsSandboxLevel::Mxc;+ for (tty, managed, message) in [+ (false, false, "native MXC is unavailable on this executor"),+ (+ true,+ false,+ "MXC currently supports ordinary pipe launches only",+ ),+ (false, true, "MXC managed networking is not supported yet"),+ ] {+ params.tty = tty;+ params.enforce_managed_network = managed;+ let error = prepare_exec_request(+ ¶ms,+ HashMap::new(),+ Some(&runtime_paths),+ /*network_policy_decider*/ None,+ /*network_policy_audit_observer*/ None,+ )+ .await+ .err()+ .expect("unsupported MXC must fail closed");+ assert_eq!(error.message, message);+ }}#[cfg(unix)]diff --git a/codex-rs/exec-server/tests/common/mod.rs b/codex-rs/exec-server/tests/common/mod.rsindex d3e46aeeb8..6b3d2937d2 100644--- a/codex-rs/exec-server/tests/common/mod.rs+++ b/codex-rs/exec-server/tests/common/mod.rs@@ -44,6 +44,9 @@ pub static TEST_BINARY_DISPATCH_GUARD: Option<TestBinaryDispatchGuard> = {if argv1 == Some(CODEX_WINDOWS_SANDBOX_ARG1) {return TestBinaryDispatchMode::DispatchArg0Only;}+ if argv1 == Some(codex_sandboxing::CODEX_WINDOWS_MXC_ARG1) {+ return TestBinaryDispatchMode::DispatchArg0Only;+ }if exe_name == CODEX_LINUX_SANDBOX_ARG0 {return TestBinaryDispatchMode::DispatchArg0Only;}diff --git a/codex-rs/exec-server/tests/exec_process.rs b/codex-rs/exec-server/tests/exec_process.rsindex f1df5d78ae..b982301949 100644--- a/codex-rs/exec-server/tests/exec_process.rs+++ b/codex-rs/exec-server/tests/exec_process.rs@@ -1,4 +1,6 @@mod common;+#[path = "exec_process/windows_sandbox.rs"]+mod windows_sandbox;use std::collections::HashMap;#[cfg(unix)]@@ -102,6 +104,10 @@ async fn create_process_context(use_remote: bool) -> Result<ProcessContext> {}}+fn selected_windows_sandbox_available(windows_sandbox_level: WindowsSandboxLevel) -> bool {+ windows_sandbox_level != WindowsSandboxLevel::Mxc || codex_sandboxing::windows_mxc_available()+}+#[cfg(target_os = "macos")]#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn codex_home_symlink_opt_out_respects_host_config_and_scope() -> Result<()> {@@ -914,13 +920,20 @@ async fn collect_process_output_from_reads(async fn collect_process_output_from_events(session: Arc<dyn ExecProcess>,+) -> Result<(String, String, Option<i32>, bool)> {+ collect_process_output_from_events_with_timeout(session, Duration::from_secs(2)).await+}++async fn collect_process_output_from_events_with_timeout(+ session: Arc<dyn ExecProcess>,+ event_timeout: Duration,) -> Result<(String, String, Option<i32>, bool)> {let mut events = session.subscribe_events();let mut stdout = String::new();let mut stderr = String::new();let mut exit_code = None;loop {- match timeout(Duration::from_secs(2), events.recv()).await?? {+ match timeout(event_timeout, events.recv()).await?? {ExecProcessEvent::Output(chunk) => match chunk.stream {ExecOutputStream::Stdout | ExecOutputStream::Pty => {stdout.push_str(&String::from_utf8_lossy(&chunk.chunk.into_inner()));@@ -1281,7 +1294,14 @@ async fn assert_exec_process_write_then_read_without_tty(use_remote: bool) -> ReOk(())}-async fn assert_remote_windows_sandbox_process_write() -> Result<()> {+async fn assert_remote_windows_sandbox_process_write(+ windows_sandbox_level: WindowsSandboxLevel,+ expected_sandbox_type: codex_sandboxing::SandboxType,+) -> Result<()> {+ if !selected_windows_sandbox_available(windows_sandbox_level) {+ eprintln!("skipping MXC enforcement test: native MXC is unavailable on this host");+ return Ok(());+ }let context = create_process_context(/*use_remote*/ true).await?;let workspace = TempDir::new()?;let blocked_file = workspace.path().join("blocked.txt");@@ -1290,7 +1310,7 @@ async fn assert_remote_windows_sandbox_process_write() -> Result<()> {SandboxPolicy::new_read_only_policy(),cwd.clone(),)?;- sandbox.windows_sandbox_level = WindowsSandboxLevel::RestrictedToken;+ sandbox.windows_sandbox_level = windows_sandbox_level;let session = match context.backend@@ -1325,6 +1345,7 @@ async fn assert_remote_windows_sandbox_process_write() -> Result<()> {Ok(session) => session,Err(err) => return Err(err.into()),};+ assert_eq!(session.sandbox_type, Some(expected_sandbox_type));let write_response = session.process.write(b"hello\n".to_vec()).await?;assert_eq!(write_response.status, WriteStatus::Accepted);@@ -1743,11 +1764,24 @@ async fn exec_process_write_then_read_without_tty(use_remote: bool) -> Result<()assert_exec_process_write_then_read_without_tty(use_remote).await}-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+#[test_case(+ WindowsSandboxLevel::RestrictedToken,+ codex_sandboxing::SandboxType::WindowsRestrictedToken;+ "restricted_token"+)]+#[test_case(+ WindowsSandboxLevel::Mxc,+ codex_sandboxing::SandboxType::WindowsMxc;+ "mxc"+)]#[cfg_attr(not(windows), ignore = "Windows-only exec-server sandbox process test")]+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]#[serial_test::serial(remote_exec_server)]-async fn remote_windows_sandbox_process_accepts_process_write() -> Result<()> {- assert_remote_windows_sandbox_process_write().await+async fn remote_windows_sandbox_process_accepts_process_write(+ windows_sandbox_level: WindowsSandboxLevel,+ expected_sandbox_type: codex_sandboxing::SandboxType,+) -> Result<()> {+ assert_remote_windows_sandbox_process_write(windows_sandbox_level, expected_sandbox_type).await}#[test_case(false ; "local")]diff --git a/codex-rs/exec-server/tests/exec_process/windows_sandbox.rs b/codex-rs/exec-server/tests/exec_process/windows_sandbox.rsnew file mode 100644index 0000000000..1f2868112f--- /dev/null+++ b/codex-rs/exec-server/tests/exec_process/windows_sandbox.rs@@ -0,0 +1,112 @@+//! Shared Windows sandbox behavior over the real exec-server RPC connection.++use super::*;+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 pretty_assertions::assert_eq;++#[cfg_attr(not(windows), ignore = "requires a native Windows sandbox")]+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+#[serial_test::serial(remote_exec_server)]+async fn mxc_tmpdir_uses_command_environment_over_rpc() -> Result<()> {+ if !selected_windows_sandbox_available(WindowsSandboxLevel::Mxc) {+ eprintln!("skipping MXC enforcement test: native MXC is unavailable on this host");+ return Ok(());+ }+ let root = TempDir::new()?;+ let command_temp = root.path().join("command temp");+ let server_temp = root.path().join("server temp");+ std::fs::create_dir(&command_temp)?;+ std::fs::create_dir(&server_temp)?;+ let outside = server_temp.join("outside.txt");+ std::fs::write(&outside, "original")?;+ let server = common::exec_server::exec_server_with_env(+ [+ ("TEMP", server_temp.as_os_str()),+ ("TMP", server_temp.as_os_str()),+ ],+ &[],+ )+ .await?;+ let environment = Environment::create_for_tests(Some(server.websocket_url().to_owned()))?;+ let cwd = PathUri::from_host_native_path(root.path())?;+ let fs = FileSystemSandboxPolicy::restricted(vec![+ FileSystemSandboxEntry::new(+ FileSystemPath::Special {+ value: FileSystemSpecialPath::Root,+ },+ FileSystemAccessMode::Read,+ ),+ FileSystemSandboxEntry::new(+ FileSystemPath::Special {+ value: FileSystemSpecialPath::Tmpdir,+ },+ FileSystemAccessMode::Write,+ ),+ ]);+ let mut sandbox = FileSystemSandboxContext::from_permission_profile_with_cwd(+ PermissionProfile::from_runtime_permissions(&fs, NetworkSandboxPolicy::Restricted),+ cwd.clone(),+ );+ sandbox.windows_sandbox_level = WindowsSandboxLevel::Mxc;+ let command_temp = command_temp.to_string_lossy().into_owned();+ let started = environment+ .get_exec_backend()+ .start(ExecParams {+ process_id: ProcessId::from("windows-sandbox-temp"),+ metadata: None,+ argv: vec![+ r"C:\Windows\System32\cmd.exe".to_owned(),+ "/D".to_owned(),+ "/S".to_owned(),+ "/C".to_owned(),+ format!(+ "echo allowed>\"%TEMP%\\allowed.txt\" & 2>\"%TEMP%\\denied.txt\" echo modified>\"{}\" & exit /b 0",+ outside.display()+ ),+ ],+ cwd,+ env_policy: None,+ shell_snapshot: None,+ env: HashMap::from([+ ("SystemRoot".to_owned(), std::env::var("SystemRoot")?),+ ("TEMP".to_owned(), command_temp.clone()),+ ("TMP".to_owned(), command_temp),+ ]),+ tty: false,+ pipe_stdin: false,+ arg0: None,+ sandbox: Some(sandbox),+ enforce_managed_network: false,+ managed_network: None,+ network_proxy: None,+ })+ .await?;+ assert_eq!(+ started.sandbox_type,+ Some(codex_sandboxing::SandboxType::WindowsMxc)+ );+ assert_eq!(+ collect_process_output_from_events_with_timeout(+ started.process,+ Duration::from_secs(/*secs*/ 30),+ )+ .await?,+ (String::new(), String::new(), Some(0), true)+ );+ assert_eq!(+ (+ std::fs::read_to_string(root.path().join("command temp").join("allowed.txt"))?+ .trim_end()+ .to_owned(),+ std::fs::read_to_string(outside)?+ ),+ ("allowed".to_owned(), "original".to_owned())+ );+ Ok(())+}diff --git a/codex-rs/exec/tests/suite/sandbox.rs b/codex-rs/exec/tests/suite/sandbox.rsindex 29dd4af60b..285cb73ae5 100644--- a/codex-rs/exec/tests/suite/sandbox.rs+++ b/codex-rs/exec/tests/suite/sandbox.rs@@ -52,6 +52,7 @@ pub(super) async fn spawn_command_under_sandbox(sandbox_cwd,std::slice::from_ref(sandbox_cwd),&codex_linux_sandbox_exe,+ /*codex_self_exe*/ &None,/*use_legacy_landlock*/ false,).map_err(|err| io::Error::other(err.to_string()))?;diff --git a/codex-rs/linux-sandbox/tests/suite/landlock.rs b/codex-rs/linux-sandbox/tests/suite/landlock.rsindex 56c0180124..c21f6c21cc 100644--- a/codex-rs/linux-sandbox/tests/suite/landlock.rs+++ b/codex-rs/linux-sandbox/tests/suite/landlock.rs@@ -195,6 +195,7 @@ async fn run_cmd_result_with_permission_profile_for_cwd(&sandbox_cwd,std::slice::from_ref(&sandbox_cwd),&codex_linux_sandbox_exe,+ /*codex_self_exe*/ &None,use_legacy_landlock,/*stdout_stream*/ None,)@@ -891,6 +892,7 @@ async fn assert_network_blocked(cmd: &[&str]) {&sandbox_cwd,std::slice::from_ref(&sandbox_cwd),&codex_linux_sandbox_exe,+ /*codex_self_exe*/ &None,/*use_legacy_landlock*/ false,/*stdout_stream*/ None,)diff --git a/codex-rs/mxc-sandbox/README.md b/codex-rs/mxc-sandbox/README.mdindex e1c4380fcf..b864424e4c 100644--- a/codex-rs/mxc-sandbox/README.md+++ b/codex-rs/mxc-sandbox/README.md@@ -7,9 +7,8 @@ dispatcher, edits host ACLs, creates sandbox users, runs setup, or requestselevation. The existing Codex Windows sandboxes remain separate backends.Windows executors record `codex.windows_mxc.available` once per process with an-`available=true|false` tag. This measures capability independently of selection.-The exec-server handshake also exposes `windows_mxc_available`; older or-unsupported Windows executors reject MXC requests before execution.+`available=true|false` tag. This measures runtime availability independently of+selection. Unsupported Windows executors reject MXC requests before execution.`is_available()` uses MXC's cached create/close probe, rather than an OS buildnumber or the SDK's broad `platform_support()` result. The latter also reportsdiff --git a/codex-rs/mxc-sandbox/src/lib.rs b/codex-rs/mxc-sandbox/src/lib.rsindex 4be53b323c..cb006b0e34 100644--- a/codex-rs/mxc-sandbox/src/lib.rs+++ b/codex-rs/mxc-sandbox/src/lib.rs@@ -106,7 +106,7 @@ pub fn run_main() -> ! {match windows::run() {Ok(exit_code) => std::process::exit(exit_code),Err(error) => {- eprintln!("MXC sandbox: {error:#}");+ eprintln!("MXC launcher: {error:#}");std::process::exit(1);}}diff --git a/codex-rs/mxc-sandbox/src/windows.rs b/codex-rs/mxc-sandbox/src/windows.rsindex 871921289d..872792ecbc 100644--- a/codex-rs/mxc-sandbox/src/windows.rs+++ b/codex-rs/mxc-sandbox/src/windows.rs@@ -43,11 +43,11 @@ pub(super) fn run() -> Result<i32> {Ok((key, value))}).collect::<Result<HashMap<_, _>>>()?;- let command = crate::transport::decode(&mut env)?;- ensure!(- !env.is_empty(),- "MXC requires an explicit child environment"- );+ // Serde errors can quote arbitrary payload values; do not print them to stderr.+ let command = crate::transport::decode(&mut env)+ .map_err(|_| anyhow::anyhow!("invalid MXC launcher request"))?;+ // The transport itself proves this is an explicit child environment; it+ // may intentionally contain no variables once launcher state is removed.let mask = unsafe { GetLogicalDrives() };ensure!(mask != 0,diff --git a/codex-rs/protocol/src/config_types.rs b/codex-rs/protocol/src/config_types.rsindex b5ac448ebc..900950cb8a 100644--- a/codex-rs/protocol/src/config_types.rs+++ b/codex-rs/protocol/src/config_types.rs@@ -299,6 +299,7 @@ pub enum WindowsSandboxLevel {Disabled,RestrictedToken,Elevated,+ Mxc,}/// Controls whether a Windows sandbox launch reconciles persistent proxy settings or preservesdiff --git a/codex-rs/sandboxing/src/lib.rs b/codex-rs/sandboxing/src/lib.rsindex f85396dc78..3a1c883ce4 100644--- a/codex-rs/sandboxing/src/lib.rs+++ b/codex-rs/sandboxing/src/lib.rs@@ -18,6 +18,7 @@ pub use bwrap::find_system_bwrap_in_path;#[cfg(target_os = "linux")]pub use bwrap::system_bwrap_warning;pub use codex_mxc_sandbox::CODEX_WINDOWS_MXC_ARG1;+pub use codex_mxc_sandbox::is_available as windows_mxc_available;pub use codex_mxc_sandbox::run_main as run_windows_mxc_main;pub use codex_windows_sandbox::WindowsSandboxProxySettingsMode;pub use denial::is_likely_executor_managed_sandbox_denied;@@ -73,6 +74,9 @@ impl From<SandboxTransformError> for CodexErr {SandboxTransformError::EnvironmentNetworkProxy(message) => {CodexErr::UnsupportedOperation(message)}+ SandboxTransformError::WindowsMxcPreparation(message) => {+ CodexErr::UnsupportedOperation(message)+ }#[cfg(target_os = "macos")]SandboxTransformError::SeatbeltPreparation(message) => {CodexErr::UnsupportedOperation(message)diff --git a/codex-rs/sandboxing/src/manager.rs b/codex-rs/sandboxing/src/manager.rsindex 2b16db917e..9d0beadc7c 100644--- a/codex-rs/sandboxing/src/manager.rs+++ b/codex-rs/sandboxing/src/manager.rs@@ -44,6 +44,7 @@ pub enum SandboxType {MacosSeatbelt,LinuxSeccomp,WindowsRestrictedToken,+ WindowsMxc,}impl SandboxType {@@ -53,6 +54,7 @@ impl SandboxType {SandboxType::MacosSeatbelt => "seatbelt",SandboxType::LinuxSeccomp => "seccomp",SandboxType::WindowsRestrictedToken => "windows_sandbox",+ SandboxType::WindowsMxc => "windows_mxc",}}}@@ -145,7 +147,7 @@ pub struct SandboxTransformRequest<'a> {// to make shared ownership explicit across runtime/sandbox plumbing.pub network: Option<&'a NetworkProxy>,pub sandbox_policy_cwd: &'a PathUri,- pub codex_linux_sandbox_exe: Option<&'a Path>,+ pub sandbox_exe: Option<&'a Path>,// TODO(anp): Reconcile these backend inputs with the supplied sandbox context// (TurnEnvironment::sandbox_context for turns) so selection shares its authority.pub use_legacy_landlock: bool,@@ -215,6 +217,7 @@ pub enum SandboxTransformError {source: io::Error,},MissingLinuxSandboxExecutable,+ WindowsMxcPreparation(String),EnvironmentNetworkProxy(String),#[cfg(target_os = "macos")]SeatbeltPreparation(String),@@ -242,6 +245,9 @@ impl std::fmt::Display for SandboxTransformError {Self::MissingLinuxSandboxExecutable => {write!(f, "missing codex-linux-sandbox executable path")}+ Self::WindowsMxcPreparation(err) => {+ write!(f, "failed to prepare MXC sandbox: {err}")+ }Self::EnvironmentNetworkProxy(err) => {write!(f, "failed to prepare environment network proxy: {err}")}@@ -267,6 +273,7 @@ impl std::error::Error for SandboxTransformError {Self::InvalidCommandCwd { source, .. }| Self::InvalidSandboxPolicyCwd { source, .. } => Some(source),Self::MissingLinuxSandboxExecutable => None,+ Self::WindowsMxcPreparation(_) => None,Self::EnvironmentNetworkProxy(_) => None,#[cfg(target_os = "macos")]Self::SeatbeltPreparation(_) => None,@@ -324,12 +331,14 @@ impl SandboxManager {#[cfg(windows)]crate::windows_mxc::record_availability_once();- if self.should_sandbox(permission_profile, pref, has_managed_network_requirements) {- get_platform_sandbox(windows_sandbox_level != WindowsSandboxLevel::Disabled)- .unwrap_or(SandboxType::None)- } else {- SandboxType::None+ if !self.should_sandbox(permission_profile, pref, has_managed_network_requirements) {+ return SandboxType::None;+ }+ if cfg!(windows) && windows_sandbox_level == WindowsSandboxLevel::Mxc {+ return SandboxType::WindowsMxc;}+ get_platform_sandbox(windows_sandbox_level != WindowsSandboxLevel::Disabled)+ .unwrap_or(SandboxType::None)}/// Returns whether the request needs a sandbox, independently of whether@@ -367,7 +376,7 @@ impl SandboxManager {environment_id,network,sandbox_policy_cwd,- codex_linux_sandbox_exe,+ sandbox_exe,use_legacy_landlock,windows_sandbox_level,windows_sandbox_private_desktop,@@ -386,11 +395,62 @@ impl SandboxManager {managed_mitm_ca_trust_bundle_path.as_ref(),);let mut argv = Vec::with_capacity(1 + command.args.len());- argv.push(command.program);- argv.extend(command.args.into_iter().map(OsString::from));+ argv.push(os_string_to_command_component(command.program));+ argv.extend(command.args);let (argv, arg0_override, pending_sandboxed_request) = match sandbox {- SandboxType::None => (os_argv_to_strings(argv), None, None),+ SandboxType::None => (argv, None, None),+ SandboxType::WindowsMxc => {+ if windows_sandbox_private_desktop {+ return Err(SandboxTransformError::WindowsMxcPreparation(+ "private desktop isolation is not supported by MXC".to_string(),+ ));+ }+ if !codex_mxc_sandbox::is_available() {+ return Err(SandboxTransformError::WindowsMxcPreparation(+ "native MXC is unavailable on this executor".to_string(),+ ));+ }+ if enforce_managed_network && command.managed_network.is_none() {+ let network = network.ok_or_else(|| {+ SandboxTransformError::WindowsMxcPreparation(+ "managed networking requires an executor-local proxy".to_string(),+ )+ })?;+ let prepared = network+ .prepare_for_optional_environment(+ std::mem::take(&mut command.env),+ environment_id,+ )+ .map_err(|err| {+ SandboxTransformError::EnvironmentNetworkProxy(err.to_string())+ })?;+ command.env = prepared.env;+ command.managed_network = Some(prepared.sandbox_context);+ }+ let managed_network = command.managed_network.filter(|_| enforce_managed_network);+ let pending = pending_sandboxed_request?;+ let exe = sandbox_exe.ok_or_else(|| {+ SandboxTransformError::WindowsMxcPreparation(+ "missing Codex executable path".to_string(),+ )+ })?;+ let mut full_command =+ vec![os_string_to_command_component(exe.as_os_str().to_owned())];+ full_command.extend(+ codex_mxc_sandbox::create_command_args(+ codex_mxc_sandbox::CreateMxcCommandArgsParams {+ command: argv,+ permission_profile: &pending.effective_permission_profile,+ sandbox_policy_cwd: pending.native_sandbox_policy_cwd.as_path(),+ managed_network: managed_network.as_ref(),+ env: &mut command.env,+ },+ )+ .map_err(|err| SandboxTransformError::WindowsMxcPreparation(err.to_string()))?,+ );+ (full_command, None, Some(pending))+ }#[cfg(target_os = "macos")]SandboxType::MacosSeatbelt => {use crate::seatbelt::CreateSeatbeltCommandArgsParams;@@ -404,7 +464,7 @@ impl SandboxManager {.to_runtime_permissions();let mut args = create_seatbelt_command_args_with_profile(CreateSeatbeltCommandArgsParams {- command: os_argv_to_strings(argv),+ command: argv,file_system_sandbox_policy: &file_system_sandbox_policy,network_sandbox_policy,sandbox_policy_cwd: pending.native_sandbox_policy_cwd.as_path(),@@ -434,8 +494,8 @@ impl SandboxManager {SandboxType::MacosSeatbelt => return Err(SandboxTransformError::SeatbeltUnavailable),SandboxType::LinuxSeccomp => {let pending = pending_sandboxed_request?;- let exe = codex_linux_sandbox_exe- .ok_or(SandboxTransformError::MissingLinuxSandboxExecutable)?;+ let exe =+ sandbox_exe.ok_or(SandboxTransformError::MissingLinuxSandboxExecutable)?;let allow_proxy_network = allow_network_for_proxy(enforce_managed_network);#[cfg(target_os = "linux")]ensure_linux_bubblewrap_is_supported(@@ -447,7 +507,7 @@ impl SandboxManager {is_wsl1(),)?;let mut args = create_linux_sandbox_command_args_for_permission_profile(- os_argv_to_strings(argv),+ argv,pending.native_command_cwd.as_path(),&pending.effective_permission_profile,pending.native_sandbox_policy_cwd.as_path(),@@ -487,14 +547,10 @@ impl SandboxManager {)],);}- (os_argv_to_strings(argv), None, Some(pending))+ (argv, None, Some(pending))}#[cfg(not(target_os = "windows"))]- SandboxType::WindowsRestrictedToken => (- os_argv_to_strings(argv),- None,- Some(pending_sandboxed_request?),- ),+ SandboxType::WindowsRestrictedToken => (argv, None, Some(pending_sandboxed_request?)),};// Unsandboxed exec-server requests may have foreign cwd values that cannot be prepared@@ -525,16 +581,12 @@ impl SandboxManager {request: SandboxDirectSpawnTransformRequest<'_>,) -> Result<SandboxExecRequest, SandboxTransformError> {#[cfg(target_os = "windows")]- {+ if request.transform.sandbox == SandboxType::WindowsRestrictedToken {let codex_home = codex_utils_home_dir::find_codex_home().map_err(|err| SandboxTransformError::WindowsSandboxPreparation(err.to_string()))?;- self.transform_for_direct_spawn_with_codex_home(request, codex_home.as_path())- }-- #[cfg(not(target_os = "windows"))]- {- self.transform(request.transform)+ return self.transform_for_direct_spawn_with_codex_home(request, codex_home.as_path());}+ self.transform(request.transform)}#[cfg(target_os = "windows")]@@ -751,12 +803,6 @@ fn ensure_linux_bubblewrap_is_supported(Ok(())}-fn os_argv_to_strings(argv: Vec<OsString>) -> Vec<String> {- argv.into_iter()- .map(os_string_to_command_component)- .collect()-}-fn os_string_to_command_component(value: OsString) -> String {value.into_string()diff --git a/codex-rs/sandboxing/src/manager_tests.rs b/codex-rs/sandboxing/src/manager_tests.rsindex 8954f11d48..ba01f9a280 100644--- a/codex-rs/sandboxing/src/manager_tests.rs+++ b/codex-rs/sandboxing/src/manager_tests.rs@@ -25,6 +25,48 @@ use pretty_assertions::assert_eq;use std::collections::HashMap;use tempfile::TempDir;+#[test]+fn mxc_selection_preserves_unsandboxed_requests_and_other_platforms() {+ let manager = SandboxManager::new();+ let platform_sandbox = if cfg!(windows) {+ SandboxType::WindowsMxc+ } else {+ get_platform_sandbox(/*windows_sandbox_enabled*/ false).unwrap_or(SandboxType::None)+ };+ for (permissions, preference, expected) in [+ (+ PermissionProfile::read_only(),+ SandboxablePreference::Auto,+ platform_sandbox,+ ),+ (+ PermissionProfile::Disabled,+ SandboxablePreference::Require,+ platform_sandbox,+ ),+ (+ PermissionProfile::read_only(),+ SandboxablePreference::Forbid,+ SandboxType::None,+ ),+ (+ PermissionProfile::Disabled,+ SandboxablePreference::Auto,+ SandboxType::None,+ ),+ ] {+ assert_eq!(+ manager.select_initial(+ &permissions,+ preference,+ WindowsSandboxLevel::Mxc,+ /*has_managed_network_requirements*/ false,+ ),+ expected,+ );+ }+}+#[test]fn danger_full_access_defaults_to_no_sandbox_without_network_requirements() {let manager = SandboxManager::new();@@ -103,7 +145,7 @@ fn unsandboxed_transform_preserves_foreign_cwd_and_unrestricted_file_system_polienvironment_id: None,network: None,sandbox_policy_cwd: &cwd_uri,- codex_linux_sandbox_exe: None,+ sandbox_exe: None,use_legacy_landlock: false,windows_sandbox_level: WindowsSandboxLevel::Disabled,windows_sandbox_private_desktop: false,@@ -160,7 +202,7 @@ fn symlinked_workspace_reports_seatbelt_preparation_error() {environment_id: None,network: None,sandbox_policy_cwd: &workspace_uri,- codex_linux_sandbox_exe: None,+ sandbox_exe: None,use_legacy_landlock: false,windows_sandbox_level: WindowsSandboxLevel::Disabled,windows_sandbox_private_desktop: false,@@ -215,7 +257,7 @@ fn transform_additional_permissions_enable_network_for_external_sandbox() {environment_id: None,network: None,sandbox_policy_cwd: &cwd_uri,- codex_linux_sandbox_exe: None,+ sandbox_exe: None,use_legacy_landlock: false,windows_sandbox_level: WindowsSandboxLevel::Disabled,windows_sandbox_private_desktop: false,@@ -286,7 +328,7 @@ fn transform_additional_permissions_preserves_denied_entries() {environment_id: None,network: None,sandbox_policy_cwd: &cwd_uri,- codex_linux_sandbox_exe: None,+ sandbox_exe: None,use_legacy_landlock: false,windows_sandbox_level: WindowsSandboxLevel::Disabled,windows_sandbox_private_desktop: false,@@ -388,7 +430,7 @@ fn transform_linux_seccomp_request(environment_id: None,network: None,sandbox_policy_cwd: &cwd_uri,- codex_linux_sandbox_exe: Some(codex_linux_sandbox_exe),+ sandbox_exe: Some(codex_linux_sandbox_exe),use_legacy_landlock: false,windows_sandbox_level: WindowsSandboxLevel::Disabled,windows_sandbox_private_desktop: false,@@ -590,7 +632,7 @@ fn transform_for_direct_spawn_windows_materializes_inner_helper() {environment_id: None,network: None,sandbox_policy_cwd: &cwd_uri,- codex_linux_sandbox_exe: None,+ sandbox_exe: None,use_legacy_landlock: false,windows_sandbox_level: WindowsSandboxLevel::Elevated,windows_sandbox_private_desktop: false,diff --git a/codex-rs/sandboxing/src/violation.rs b/codex-rs/sandboxing/src/violation.rsindex 4023fb4494..0d00a0f605 100644--- a/codex-rs/sandboxing/src/violation.rs+++ b/codex-rs/sandboxing/src/violation.rs@@ -50,6 +50,7 @@ pub enum SandboxViolationBackend {ManagedNetworkProxy,Seatbelt,WindowsSandbox,+ WindowsMxc,}impl SandboxViolationBackend {@@ -59,6 +60,7 @@ impl SandboxViolationBackend {Self::ManagedNetworkProxy => "managed_network_proxy",Self::Seatbelt => "seatbelt",Self::WindowsSandbox => "windows_sandbox",+ Self::WindowsMxc => "windows_mxc",}}}@@ -143,6 +145,7 @@ fn classify_filesystem_sandbox_violation(SandboxType::MacosSeatbelt => SandboxViolationBackend::Seatbelt,SandboxType::LinuxSeccomp => SandboxViolationBackend::LinuxSandbox,SandboxType::WindowsRestrictedToken => SandboxViolationBackend::WindowsSandbox,+ SandboxType::WindowsMxc => SandboxViolationBackend::WindowsMxc,};if let Some((reason, output)) = filesystem_reason_from_output(exec_output) {