diff --git a/codex-rs/app-server-protocol/src/protocol/v2/permissions.rs b/codex-rs/app-server-protocol/src/protocol/v2/permissions.rs index fd13791112..6ba20500f7 100644 --- a/codex-rs/app-server-protocol/src/protocol/v2/permissions.rs +++ b/codex-rs/app-server-protocol/src/protocol/v2/permissions.rs @@ -556,7 +556,9 @@ pub enum SandboxPolicy { #[ts(rename_all = "camelCase")] WorkspaceWrite { #[serde(default)] - writable_roots: Vec, + #[schemars(with = "Vec")] + #[ts(as = "Vec")] + writable_roots: Vec, #[serde(default)] network_access: bool, #[serde(default)] @@ -585,7 +587,7 @@ enum SandboxPolicyDeserialize { #[serde(rename_all = "camelCase")] WorkspaceWrite { #[serde(default)] - writable_roots: Vec, + writable_roots: Vec, #[serde(default)] read_only_access: Option, #[serde(default)] @@ -649,8 +651,67 @@ impl<'de> Deserialize<'de> for SandboxPolicy { } impl SandboxPolicy { - pub fn to_core(&self) -> codex_protocol::protocol::SandboxPolicy { - match self { + /// Projects a server policy without resolving cwd-dependent permissions on the client. + pub fn permission_profile_template( + &self, + ) -> io::Result { + self.permission_profile(/*cwd*/ None) + } + + /// Projects the server policy into a permission profile for display in a client. + pub fn permission_profile_for_cwd( + &self, + cwd: &PathUri, + ) -> io::Result { + self.permission_profile(Some(cwd)) + } + + fn permission_profile( + &self, + cwd: Option<&PathUri>, + ) -> io::Result { + use codex_protocol::models::PermissionProfile; + use codex_protocol::permissions::NetworkSandboxPolicy; + if let Self::WorkspaceWrite { + writable_roots, + network_access, + exclude_tmpdir_env_var, + exclude_slash_tmp, + } = self + { + let roots = writable_roots + .iter() + .cloned() + .map(PathUri::try_from) + .collect::, _>>() + .map_err(io::Error::other)?; + if cwd.is_none_or(|cwd| cwd.to_abs_path().is_err()) + || roots.iter().any(|root| root.to_abs_path().is_err()) + { + return Ok(PermissionProfile::workspace_write_with_path_uris( + &roots, + if *network_access { + NetworkSandboxPolicy::Enabled + } else { + NetworkSandboxPolicy::Restricted + }, + *exclude_tmpdir_env_var, + *exclude_slash_tmp, + )); + } + } + let policy = self.try_to_core()?; + Ok(match cwd { + Some(cwd) => { + PermissionProfile::from_legacy_sandbox_policy_for_cwd(&policy, &cwd.to_path_buf()) + } + None => PermissionProfile::from_legacy_sandbox_policy_template(&policy), + }) + } + + /// Converts the policy for enforcement on this host, validating every writable root. + pub fn try_to_core(&self) -> io::Result { + Ok(match self { SandboxPolicy::DangerFullAccess => { codex_protocol::protocol::SandboxPolicy::DangerFullAccess } @@ -673,12 +734,24 @@ impl SandboxPolicy { exclude_tmpdir_env_var, exclude_slash_tmp, } => codex_protocol::protocol::SandboxPolicy::WorkspaceWrite { - writable_roots: writable_roots.clone(), + writable_roots: writable_roots + .iter() + .map(|root| { + let path = root.as_path(); + if !path.is_absolute() { + return Err(io::Error::new( + io::ErrorKind::InvalidInput, + format!("writable root is not absolute: {}", path.display()), + )); + } + AbsolutePathBuf::from_absolute_path_checked(path) + }) + .collect::>()?, network_access: *network_access, exclude_tmpdir_env_var: *exclude_tmpdir_env_var, exclude_slash_tmp: *exclude_slash_tmp, }, - } + }) } } @@ -705,7 +778,7 @@ impl From for SandboxPolicy { exclude_tmpdir_env_var, exclude_slash_tmp, } => SandboxPolicy::WorkspaceWrite { - writable_roots, + writable_roots: writable_roots.into_iter().map(Into::into).collect(), network_access, exclude_tmpdir_env_var, exclude_slash_tmp, diff --git a/codex-rs/app-server-protocol/src/protocol/v2/tests.rs b/codex-rs/app-server-protocol/src/protocol/v2/tests.rs index 36042c4ddc..33692a81a2 100644 --- a/codex-rs/app-server-protocol/src/protocol/v2/tests.rs +++ b/codex-rs/app-server-protocol/src/protocol/v2/tests.rs @@ -2015,7 +2015,7 @@ fn sandbox_policy_round_trips_external_sandbox_network_access() { network_access: NetworkAccess::Enabled, }; - let core_policy = v2_policy.to_core(); + let core_policy = v2_policy.try_to_core().unwrap(); assert_eq!( core_policy, codex_protocol::protocol::SandboxPolicy::ExternalSandbox { @@ -2033,7 +2033,7 @@ fn sandbox_policy_round_trips_read_only_network_access() { network_access: true, }; - let core_policy = v2_policy.to_core(); + let core_policy = v2_policy.try_to_core().unwrap(); assert_eq!( core_policy, codex_protocol::protocol::SandboxPolicy::ReadOnly { @@ -2889,13 +2889,13 @@ fn sandbox_policy_round_trips_workspace_write_access() { let root = AbsolutePathBuf::from_absolute_path(directory.path()).expect("absolute root"); std::fs::create_dir(root.join(".git")).expect("git metadata"); let v2_policy = SandboxPolicy::WorkspaceWrite { - writable_roots: vec![root.clone(), root.clone()], + writable_roots: vec![root.clone().into(), root.clone().into()], network_access: true, exclude_tmpdir_env_var: false, exclude_slash_tmp: false, }; - let core_policy = v2_policy.to_core(); + let core_policy = v2_policy.try_to_core().unwrap(); assert_eq!( core_policy, codex_protocol::protocol::SandboxPolicy::WorkspaceWrite { @@ -2907,7 +2907,7 @@ fn sandbox_policy_round_trips_workspace_write_access() { ); let profile = codex_protocol::models::PermissionProfile::from_legacy_sandbox_policy_template( - &v2_policy.to_core(), + &core_policy, ); assert!( !profile @@ -2936,6 +2936,43 @@ fn sandbox_policy_round_trips_workspace_write_access() { assert_eq!(back_to_v2, v2_policy); } +#[test] +fn sandbox_policy_template_preserves_foreign_writable_roots() { + let root = if cfg!(windows) { "/extra" } else { r"C:\extra" }; + let policy: SandboxPolicy = serde_json::from_value(json!({ + "type": "workspaceWrite", + "writableRoots": [root], + })) + .expect("workspace-write policy"); + let root = PathUri::try_from(LegacyAppPathString::from_string(root)).expect("foreign root"); + let file_system = policy + .permission_profile_template() + .expect("permission profile template") + .file_system_sandbox_policy(); + assert!(file_system.entries.iter().any(|entry| { + entry.access.can_write() + && matches!(&entry.path, codex_protocol::permissions::FileSystemPath::Path { path } if path == &root) + })); +} + +#[test] +fn sandbox_policy_rejects_home_relative_writable_roots_for_enforcement() { + let policy: SandboxPolicy = serde_json::from_value(json!({ + "type": "workspaceWrite", + "writableRoots": ["~/extra"], + })) + .expect("workspace-write policy"); + let home = std::env::current_dir().expect("current directory"); + let result = + codex_utils_absolute_path::AbsolutePathBufGuard::with_home_directory(&home, || { + policy.try_to_core() + }); + assert_eq!( + result.expect_err("writable roots must be absolute").kind(), + std::io::ErrorKind::InvalidInput + ); +} + #[test] fn sandbox_policy_deserializes_legacy_read_only_full_access_field() { let policy = serde_json::from_value::(json!({ @@ -2971,7 +3008,7 @@ fn sandbox_policy_deserializes_legacy_workspace_write_full_access_field() { assert_eq!( policy, SandboxPolicy::WorkspaceWrite { - writable_roots: vec![absolute_path("/workspace")], + writable_roots: vec![absolute_path("/workspace").into()], network_access: true, exclude_tmpdir_env_var: true, exclude_slash_tmp: true, @@ -5194,7 +5231,7 @@ fn thread_lifecycle_responses_default_missing_optional_fields() { "cwd": cwd, "approvalPolicy": "on-request", "approvalsReviewer": "user", - "sandbox": { "type": "dangerFullAccess" }, + "sandbox": { "type": "workspaceWrite", "writableRoots": [cwd] }, "reasoningEffort": null }); @@ -5208,6 +5245,7 @@ fn thread_lifecycle_responses_default_missing_optional_fields() { for encoded in [json!(start), json!(resume), json!(fork)] { assert_eq!(encoded["thread"]["cwd"], cwd); assert_eq!(encoded["cwd"], cwd); + assert_eq!(encoded["sandbox"]["writableRoots"], json!([cwd])); } assert_eq!(start.instruction_sources, Vec::::new()); assert_eq!(start.thread.parent_thread_id, None); 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.rs index 43e464e97a..be9fe18a37 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 @@ -239,7 +239,11 @@ impl CommandExecRequestProcessor { config.managed_network_requirements_enabled(), config.effective_workspace_roots(), ) - } else if let Some(policy) = sandbox_policy.map(|policy| policy.to_core()) { + } else if let Some(policy) = sandbox_policy + .map(|policy| policy.try_to_core()) + .transpose() + .map_err(|err| invalid_request(format!("invalid sandbox policy: {err}")))? + { let mut permissions = self.config.permissions.clone(); permissions .set_legacy_sandbox_policy(policy, &sandbox_cwd) diff --git a/codex-rs/app-server/src/request_processors/turn_processor.rs b/codex-rs/app-server/src/request_processors/turn_processor.rs index cacecd27ac..18302dafd8 100644 --- a/codex-rs/app-server/src/request_processors/turn_processor.rs +++ b/codex-rs/app-server/src/request_processors/turn_processor.rs @@ -919,7 +919,10 @@ impl TurnRequestProcessor { approval_policy.map(codex_app_server_protocol::AskForApproval::to_core); let approvals_reviewer = approvals_reviewer.map(codex_app_server_protocol::ApprovalsReviewer::to_core); - let sandbox_policy = sandbox_policy.map(|policy| policy.to_core()); + let sandbox_policy = sandbox_policy + .map(|policy| policy.try_to_core()) + .transpose() + .map_err(|err| invalid_request(format!("invalid sandboxPolicy: {err}")))?; let (permission_profile, active_permission_profile, profile_workspace_roots) = if let Some(permissions) = permissions { let Some(snapshot) = snapshot.as_ref() else { diff --git a/codex-rs/app-server/tests/suite/v2/command_exec.rs b/codex-rs/app-server/tests/suite/v2/command_exec.rs index 534f612e97..2d619dbf68 100644 --- a/codex-rs/app-server/tests/suite/v2/command_exec.rs +++ b/codex-rs/app-server/tests/suite/v2/command_exec.rs @@ -20,6 +20,7 @@ use codex_core::exec_env::CODEX_APPLY_PATCH_PRESERVE_LINE_ENDINGS_ENV_VAR; use codex_exec_server::CODEX_EXEC_SERVER_URL_ENV_VAR; use codex_protocol::models::BUILT_IN_PERMISSION_PROFILE_READ_ONLY; use codex_protocol::shell_environment::OPENAI_FEDERATION_RULE_ID_ENV_VAR; +use codex_utils_path_uri::LegacyAppPathString; use pretty_assertions::assert_eq; use std::collections::HashMap; use std::path::Path; @@ -380,7 +381,7 @@ async fn command_exec_enforces_managed_deny_read_requirements() -> Result<()> { for sandbox_policy in [ SandboxPolicy::DangerFullAccess, SandboxPolicy::WorkspaceWrite { - writable_roots: vec![nested_root.try_into()?], + writable_roots: vec![LegacyAppPathString::from_path(&nested_root)], network_access: false, exclude_tmpdir_env_var: false, exclude_slash_tmp: false, diff --git a/codex-rs/app-server/tests/suite/v2/thread_start.rs b/codex-rs/app-server/tests/suite/v2/thread_start.rs index 104a980819..c728c6d29b 100644 --- a/codex-rs/app-server/tests/suite/v2/thread_start.rs +++ b/codex-rs/app-server/tests/suite/v2/thread_start.rs @@ -585,7 +585,7 @@ async fn thread_start_accepts_absolute_runtime_workspace_roots() -> Result<()> { panic!("expected workspace-write sandbox"); }; assert!( - writable_roots.contains(&extra_root.abs().canonicalize()?), + writable_roots.contains(&extra_root.abs().canonicalize()?.into()), "legacy sandbox projection should include the runtime workspace root" ); } @@ -616,7 +616,7 @@ async fn thread_start_accepts_absolute_runtime_workspace_roots() -> Result<()> { panic!("expected workspace-write sandbox"); }; assert!( - writable_roots.contains(&environment_root.abs().canonicalize()?), + writable_roots.contains(&environment_root.abs().canonicalize()?.into()), "legacy sandbox projection should include the environment workspace root" ); } diff --git a/codex-rs/app-server/tests/suite/v2/turn_start.rs b/codex-rs/app-server/tests/suite/v2/turn_start.rs index 9ac22017ee..054b4ab4a7 100644 --- a/codex-rs/app-server/tests/suite/v2/turn_start.rs +++ b/codex-rs/app-server/tests/suite/v2/turn_start.rs @@ -3534,7 +3534,7 @@ async fn turn_start_explicit_local_environment_updates_legacy_cwd_between_turns( approval_policy: Some(codex_app_server_protocol::AskForApproval::Never), approvals_reviewer: None, sandbox_policy: Some(codex_app_server_protocol::SandboxPolicy::WorkspaceWrite { - writable_roots: vec![first_writable_root], + writable_roots: vec![first_writable_root.into()], network_access: false, exclude_tmpdir_env_var: true, exclude_slash_tmp: true, diff --git a/codex-rs/tui/src/app/tests/permission_selection_tests.rs b/codex-rs/tui/src/app/tests/permission_selection_tests.rs index 725ee66cf4..b94ae92347 100644 --- a/codex-rs/tui/src/app/tests/permission_selection_tests.rs +++ b/codex-rs/tui/src/app/tests/permission_selection_tests.rs @@ -294,10 +294,10 @@ async fn custom_permission_selection_scenario() -> Result<()> { before ); let settings = next_thread_settings_updated(&mut server, thread_id).await; - let expected = PermissionProfile::from_legacy_sandbox_policy_for_cwd( - &settings.thread_settings.sandbox_policy.to_core(), - settings.thread_settings.cwd.as_path(), - ); + let expected = settings + .thread_settings + .sandbox_policy + .permission_profile_for_cwd(&settings.thread_settings.cwd.clone().try_into()?)?; assert!(matches!( settings.thread_settings.sandbox_policy, codex_app_server_protocol::SandboxPolicy::WorkspaceWrite { .. } diff --git a/codex-rs/tui/src/app/thread_settings.rs b/codex-rs/tui/src/app/thread_settings.rs index d7a26bdcc8..d99397e3be 100644 --- a/codex-rs/tui/src/app/thread_settings.rs +++ b/codex-rs/tui/src/app/thread_settings.rs @@ -284,6 +284,13 @@ pub(super) fn apply_thread_settings_to_session( settings: &ThreadSettings, cwd: &codex_utils_path_uri::PathUri, ) { + let permission_profile = match settings.sandbox_policy.permission_profile_for_cwd(cwd) { + Ok(profile) => profile, + Err(err) => { + tracing::warn!(%err, "Invalid sandbox policy in thread settings"); + return; + } + }; if settings.collaboration_mode.mode == ModeKind::Default { session.model = settings.model.clone(); session.reasoning_effort = settings.effort.clone(); @@ -292,10 +299,7 @@ pub(super) fn apply_thread_settings_to_session( session.service_tier = settings.service_tier.clone(); session.approval_policy = settings.approval_policy; session.approvals_reviewer = settings.approvals_reviewer.to_core(); - session.permission_profile = PermissionProfile::from_legacy_sandbox_policy_for_cwd( - &settings.sandbox_policy.to_core(), - settings.cwd.as_path(), - ); + session.permission_profile = permission_profile; session.active_permission_profile = settings.active_permission_profile.clone().map(Into::into); if let Some(environments) = &settings.environments { session.primary_environment_cwd = diff --git a/codex-rs/tui/src/app_server_session.rs b/codex-rs/tui/src/app_server_session.rs index db4c64e4c1..6aaf989f55 100644 --- a/codex-rs/tui/src/app_server_session.rs +++ b/codex-rs/tui/src/app_server_session.rs @@ -1245,18 +1245,16 @@ impl AppServerSession { self.history_support = ThreadHistorySupport::LegacyOnly; } // An explicit server selection must not reuse the client's local display policy. - let selected_permissions = selected_profile.map(|_| { - PermissionProfile::from_legacy_sandbox_policy_for_cwd( - &response.sandbox.to_core(), - response.cwd.as_path(), - ) - }); + let cwd = decode_thread_cwd(&response.cwd, self.path_convention())?; + let selected_permissions = selected_profile + .map(|_| response.sandbox.permission_profile_for_cwd(&cwd)) + .transpose()?; let mut started = started_thread_from_start_response( response, local_settings, config, self.thread_params_mode(), - self.path_convention(), + cwd, ) .await?; if let Some(permissions) = selected_permissions { @@ -1623,18 +1621,16 @@ impl AppServerSession { ); } // Explicit selections use the server's effective policy, including on local daemons. - let selected_permissions = selected_profile.map(|_| { - PermissionProfile::from_legacy_sandbox_policy_for_cwd( - &response.sandbox.to_core(), - response.cwd.as_path(), - ) - }); + let cwd = decode_thread_cwd(&response.cwd, self.path_convention())?; + let selected_permissions = selected_profile + .map(|_| response.sandbox.permission_profile_for_cwd(&cwd)) + .transpose()?; let mut started = started_thread_from_fork_response( response, local_settings, &config, self.thread_params_mode(), - self.path_convention(), + cwd, ) .await?; if let Some(permissions) = selected_permissions { @@ -2415,12 +2411,14 @@ pub(crate) async fn start_thread_with_request_handle( .map_err(|err| { bootstrap_request_error("thread/start failed during TUI bootstrap", err) })?; + let convention = Platform::from_platform_os(request_handle.platform_os()).path_convention(); + let cwd = decode_thread_cwd(&response.cwd, convention)?; let mut started = started_thread_from_start_response( response, local_settings, &config, thread_params_mode, - Platform::from_platform_os(request_handle.platform_os()).path_convention(), + cwd, ) .await?; started.task_tools_available = task_tools_available; @@ -2698,6 +2696,61 @@ fn permission_profile_id_from_active_profile(active: ActivePermissionProfile) -> active.id } +/// Inherits settings for a child thread and prepares its first turn's permission override. +pub(crate) fn inherit_thread_start_settings( + thread_start: &mut ThreadStartParams, + source: ThreadResumeResponse, +) -> Result { + use codex_app_server_protocol::SandboxMode; + + thread_start.model = Some(source.model); + thread_start.service_tier = Some(source.service_tier); + thread_start.runtime_workspace_roots = Some(source.runtime_workspace_roots); + thread_start.approval_policy = Some(source.approval_policy); + thread_start.approvals_reviewer = Some(source.approvals_reviewer); + thread_start.permissions = source.active_permission_profile.map(|profile| profile.id); + if thread_start.permissions.is_some() { + thread_start.sandbox = None; + return Ok(TurnStartParams::default()); + } + let source_permissions = source + .sandbox + .permission_profile_template() + .map_err(|err| err.to_string())?; + thread_start.sandbox = Some(match &source_permissions { + PermissionProfile::Disabled => SandboxMode::DangerFullAccess, + PermissionProfile::Managed { .. } => { + if source_permissions + .file_system_sandbox_policy() + .entries + .iter() + .any(|entry| entry.access.can_write()) + { + SandboxMode::WorkspaceWrite + } else { + SandboxMode::ReadOnly + } + } + PermissionProfile::External { .. } => { + return Err( + "Cannot inherit an external sandbox without a permission profile".to_string(), + ); + } + }); + Ok(TurnStartParams { + // Forward the server's writable roots in their original path convention. + sandbox_policy: Some(source.sandbox), + ..TurnStartParams::default() + }) +} + +pub(crate) fn thread_started_with_read_only_sandbox(response: &ThreadStartResponse) -> bool { + matches!( + response.sandbox, + codex_app_server_protocol::SandboxPolicy::ReadOnly { .. } + ) +} + pub(crate) fn turn_permissions_overrides( permissions_override: TurnPermissionsOverride, cwd: &std::path::Path, @@ -2968,7 +3021,7 @@ async fn started_thread_from_start_response( local_settings: &LocalSettings, config: &Config, thread_params_mode: ThreadParamsMode, - cwd_convention: Option, + cwd: PathUri, ) -> Result { let blocks_direct_input = thread_blocks_direct_input(&response.thread); let session = thread_session_state_from_thread_start_response( @@ -2976,7 +3029,7 @@ async fn started_thread_from_start_response( local_settings, config, thread_params_mode, - cwd_convention, + cwd, ) .await .map_err(color_eyre::eyre::Report::msg)?; @@ -3011,7 +3064,7 @@ async fn started_thread_from_fork_response( local_settings: &LocalSettings, config: &Config, thread_params_mode: ThreadParamsMode, - cwd_convention: Option, + cwd: PathUri, ) -> Result { let blocks_direct_input = thread_blocks_direct_input(&response.thread); let session = thread_session_state_from_thread_fork_response( @@ -3019,7 +3072,7 @@ async fn started_thread_from_fork_response( local_settings, config, thread_params_mode, - cwd_convention, + cwd, ) .await .map_err(color_eyre::eyre::Report::msg)?; @@ -3036,14 +3089,14 @@ async fn thread_session_state_from_thread_start_response( local_settings: &LocalSettings, config: &Config, thread_params_mode: ThreadParamsMode, - cwd_convention: Option, + cwd: PathUri, ) -> Result { let permission_profile = display_permission_profile_from_thread_response( &response.sandbox, - response.cwd.as_path(), + &cwd, config, thread_params_mode, - ); + )?; let mut session = thread_session_state_from_thread_response( &response.thread.id, response.thread.environments.as_deref(), @@ -3057,7 +3110,7 @@ async fn thread_session_state_from_thread_start_response( response.approvals_reviewer.to_core(), permission_profile, response.active_permission_profile.clone().map(Into::into), - decode_thread_cwd(&response.cwd, cwd_convention).map_err(|err| err.to_string())?, + cwd, response.runtime_workspace_roots.clone(), response.instruction_source_path_uris(), response.reasoning_effort.clone(), @@ -3078,10 +3131,11 @@ async fn thread_session_state_from_thread_resume_response( ) -> Result { // The server owns restored rules. This legacy projection is for display only; // normal turns do not send it back as an execution override. - let permission_profile = PermissionProfile::from_legacy_sandbox_policy_for_cwd( - &response.sandbox.to_core(), - response.cwd.as_path(), - ); + let cwd = decode_thread_cwd(&response.cwd, cwd_convention).map_err(|err| err.to_string())?; + let permission_profile = response + .sandbox + .permission_profile_for_cwd(&cwd) + .map_err(|err| err.to_string())?; let mut session = thread_session_state_from_thread_response( &response.thread.id, response.thread.environments.as_deref(), @@ -3095,7 +3149,7 @@ async fn thread_session_state_from_thread_resume_response( response.approvals_reviewer.to_core(), permission_profile, response.active_permission_profile.clone().map(Into::into), - decode_thread_cwd(&response.cwd, cwd_convention).map_err(|err| err.to_string())?, + cwd, response.runtime_workspace_roots.clone(), response.instruction_source_path_uris(), response.reasoning_effort.clone(), @@ -3112,14 +3166,14 @@ async fn thread_session_state_from_thread_fork_response( local_settings: &LocalSettings, config: &Config, thread_params_mode: ThreadParamsMode, - cwd_convention: Option, + cwd: PathUri, ) -> Result { let permission_profile = display_permission_profile_from_thread_response( &response.sandbox, - response.cwd.as_path(), + &cwd, config, thread_params_mode, - ); + )?; let mut session = thread_session_state_from_thread_response( &response.thread.id, response.thread.environments.as_deref(), @@ -3133,7 +3187,7 @@ async fn thread_session_state_from_thread_fork_response( response.approvals_reviewer.to_core(), permission_profile, response.active_permission_profile.clone().map(Into::into), - decode_thread_cwd(&response.cwd, cwd_convention).map_err(|err| err.to_string())?, + cwd, response.runtime_workspace_roots.clone(), response.instruction_source_path_uris(), response.reasoning_effort.clone(), @@ -3146,10 +3200,10 @@ async fn thread_session_state_from_thread_fork_response( fn display_permission_profile_from_thread_response( sandbox: &codex_app_server_protocol::SandboxPolicy, - cwd: &std::path::Path, + cwd: &PathUri, config: &Config, thread_params_mode: ThreadParamsMode, -) -> PermissionProfile { +) -> Result { match thread_params_mode { ThreadParamsMode::Embedded if matches!( @@ -3160,12 +3214,14 @@ fn display_permission_profile_from_thread_response( codex_app_server_protocol::SandboxPolicy::DangerFullAccess ) => { - PermissionProfile::from_legacy_sandbox_policy_for_cwd(&sandbox.to_core(), cwd) - } - ThreadParamsMode::Embedded => config.permissions.effective_permission_profile(), - ThreadParamsMode::Remote | ThreadParamsMode::Cloud => { - PermissionProfile::from_legacy_sandbox_policy_for_cwd(&sandbox.to_core(), cwd) + sandbox + .permission_profile_for_cwd(cwd) + .map_err(|err| err.to_string()) } + ThreadParamsMode::Embedded => Ok(config.permissions.effective_permission_profile()), + ThreadParamsMode::Remote | ThreadParamsMode::Cloud => sandbox + .permission_profile_for_cwd(cwd) + .map_err(|err| err.to_string()), } } @@ -5395,10 +5451,11 @@ mod tests { assert_eq!( display_permission_profile_from_thread_response( &sandbox, - cwd.as_path(), + &PathUri::from_abs_path(&cwd), &config, ThreadParamsMode::Remote, - ), + ) + .unwrap(), PermissionProfile::read_only() ); } @@ -5420,10 +5477,11 @@ mod tests { assert_eq!( display_permission_profile_from_thread_response( &codex_app_server_protocol::SandboxPolicy::DangerFullAccess, - cwd.as_path(), + &PathUri::from_abs_path(&cwd), &config, ThreadParamsMode::Embedded, - ), + ) + .unwrap(), PermissionProfile::read_only() ); } diff --git a/codex-rs/tui/src/chatwidget/settings.rs b/codex-rs/tui/src/chatwidget/settings.rs index 261b19c994..904aef62c2 100644 --- a/codex-rs/tui/src/chatwidget/settings.rs +++ b/codex-rs/tui/src/chatwidget/settings.rs @@ -545,6 +545,13 @@ impl ChatWidget { tracing::warn!("Invalid cwd in thread settings"); return; }; + let permission_profile = match settings.sandbox_policy.permission_profile_for_cwd(&cwd) { + Ok(profile) => profile, + Err(err) => { + tracing::warn!(%err, "Invalid sandbox policy in thread settings"); + return; + } + }; let cwd_changed = self.current_cwd != cwd; self.status_line_project_root_name_cache = None; if let Ok(local) = cwd.to_abs_path() { @@ -566,10 +573,6 @@ impl ChatWidget { } self.set_approvals_reviewer(settings.approvals_reviewer.to_core()); - let permission_profile = PermissionProfile::from_legacy_sandbox_policy_for_cwd( - &settings.sandbox_policy.to_core(), - settings.cwd.as_path(), - ); let permission_snapshot = PermissionProfileSnapshot::from_session_snapshot( permission_profile, settings.active_permission_profile.take().map(Into::into), diff --git a/codex-rs/tui/src/dynamic_tools.rs b/codex-rs/tui/src/dynamic_tools.rs index 39838132cd..8b112de723 100644 --- a/codex-rs/tui/src/dynamic_tools.rs +++ b/codex-rs/tui/src/dynamic_tools.rs @@ -21,7 +21,6 @@ use codex_app_server_protocol::ImageReference; use codex_app_server_protocol::ModelListParams; use codex_app_server_protocol::ModelListResponse; use codex_app_server_protocol::RequestId; -use codex_app_server_protocol::SandboxMode; use codex_app_server_protocol::SortDirection; use codex_app_server_protocol::Thread; use codex_app_server_protocol::ThreadArchiveParams; @@ -59,7 +58,6 @@ use codex_features::Feature; use codex_features::Features; use codex_protocol::ThreadId; use codex_protocol::models::FunctionCallOutputBody; -use codex_protocol::models::PermissionProfile; use serde::Deserialize; use serde::de::DeserializeOwned; use serde_json::Value; @@ -574,43 +572,10 @@ async fn execute_inner( }, ) .await?; - thread_start_params.model = Some(source.model); - thread_start_params.service_tier = Some(source.service_tier); - thread_start_params.runtime_workspace_roots = Some(source.runtime_workspace_roots); - thread_start_params.approval_policy = Some(source.approval_policy); - thread_start_params.approvals_reviewer = Some(source.approvals_reviewer); - let source_permissions = - PermissionProfile::from_legacy_sandbox_policy_template(&source.sandbox.to_core()); - let permission_profile_override = - if let Some(profile) = source.active_permission_profile { - thread_start_params.permissions = Some(profile.id); - thread_start_params.sandbox = None; - None - } else { - thread_start_params.permissions = None; - thread_start_params.sandbox = Some(match &source_permissions { - PermissionProfile::Disabled => SandboxMode::DangerFullAccess, - PermissionProfile::Managed { .. } => { - if source_permissions - .file_system_sandbox_policy() - .entries - .iter() - .any(|entry| entry.access.can_write()) - { - SandboxMode::WorkspaceWrite - } else { - SandboxMode::ReadOnly - } - } - PermissionProfile::External { .. } => { - return Err( - "Cannot inherit an external sandbox without a permission profile" - .to_string(), - ); - } - }); - Some(source_permissions) - }; + let turn_start_params = crate::app_server_session::inherit_thread_start_settings( + &mut thread_start_params, + source, + )?; if let Some(model) = arguments.model { thread_start_params.model = Some(model); } @@ -654,7 +619,7 @@ async fn execute_inner( "create_thread", prompt, /*model*/ None, - permission_profile_override, + turn_start_params, cyber_access_program, ) .await?; @@ -792,7 +757,7 @@ async fn execute_inner( "send_message_to_thread", prompt, arguments.model, - /*permission_profile_override*/ None, + TurnStartParams::default(), cyber_access_program, ) .await?; @@ -1300,13 +1265,9 @@ async fn start_turn( tool: &str, prompt: String, model: Option, - permission_profile_override: Option, + turn_start_params: TurnStartParams, cyber_access_program: Option, ) -> Result { - let sandbox_policy = permission_profile_override - .map(|profile| profile.to_legacy_sandbox_policy_template().map(Into::into)) - .transpose() - .map_err(|error| error.to_string())?; request(handle, |request_id| ClientRequest::TurnStart { request_id, params: TurnStartParams { @@ -1321,9 +1282,8 @@ async fn start_turn( output: FunctionCallOutputBody::Text(prompt), })), model, - sandbox_policy, cyber_access_program, - ..TurnStartParams::default() + ..turn_start_params }, }) .await diff --git a/codex-rs/tui/src/dynamic_tools_tests.rs b/codex-rs/tui/src/dynamic_tools_tests.rs index e876f845a1..df374c08d8 100644 --- a/codex-rs/tui/src/dynamic_tools_tests.rs +++ b/codex-rs/tui/src/dynamic_tools_tests.rs @@ -815,7 +815,8 @@ async fn task_creation_and_followup_start_background_turns() -> color_eyre::Resu let inherited_sandbox = codex_app_server_protocol::SandboxPolicy::WorkspaceWrite { writable_roots: vec![ - codex_utils_absolute_path::AbsolutePathBuf::from_absolute_path(codex_home.path())?, + codex_utils_absolute_path::AbsolutePathBuf::from_absolute_path(codex_home.path())? + .into(), ], network_access: true, exclude_tmpdir_env_var: true, diff --git a/codex-rs/tui/src/temporary_structured_request.rs b/codex-rs/tui/src/temporary_structured_request.rs index bea02620aa..1aee59b151 100644 --- a/codex-rs/tui/src/temporary_structured_request.rs +++ b/codex-rs/tui/src/temporary_structured_request.rs @@ -19,7 +19,6 @@ use codex_app_server_protocol::TurnStartResponse; use codex_app_server_protocol::TurnStatus; use codex_app_server_protocol::UserInput; use codex_protocol::models::BUILT_IN_PERMISSION_PROFILE_READ_ONLY; -use codex_protocol::models::PermissionProfile; use codex_protocol::openai_models::ReasoningEffort; use color_eyre::eyre::eyre; use serde_json::Value; @@ -163,21 +162,11 @@ pub(crate) async fn start_temporary_thread( "temporary structured thread did not preserve permission profile {expected_profile}" )); } - } else { - let profile = - PermissionProfile::from_legacy_sandbox_policy_template(&response.sandbox.to_core()); - if !matches!(profile, PermissionProfile::Managed { .. }) - || profile - .file_system_sandbox_policy() - .entries - .iter() - .any(|entry| entry.access.can_write()) - { - unsubscribe_temporary_thread(request_handle, response.thread.id).await; - return Err(eyre!( - "temporary structured thread did not start with read-only permissions" - )); - } + } else if !crate::app_server_session::thread_started_with_read_only_sandbox(&response) { + unsubscribe_temporary_thread(request_handle, response.thread.id).await; + return Err(eyre!( + "temporary structured thread did not start with read-only permissions" + )); } Ok(response)