openai/codex
1
0
Fork 0
mirror of https://github.com/openai/codex.git synced 2026-10-23 18:08:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

core tests: submit turns with permission profiles

Browse Source
This commit is contained in:
Michael Bolin
2026-04-28 13:00:58 -07:00
parent e8a482a2d9
commit 0b78a490ec
11 changed files with 322 additions and 117 deletions
Download Patch File Download Diff File Expand all files Collapse all files
codex-rs/tui/src/app_command.rs
+6 -11
View File
@@ -23,6 +23,8 @@ use codex_protocol::user_input::UserInput;
use serde::Serialize;
use serde_json::Value;
use crate::permission_compat::legacy_compatible_permission_profile;
#[derive(Debug, Clone, PartialEq, Serialize)]
pub(crate) struct AppCommand(Op);
@@ -148,19 +150,12 @@ impl AppCommand {
collaboration_mode: Option<CollaborationMode>,
personality: Option<Personality>,
) -> Self {
let sandbox_policy = permission_profile
let legacy_profile =
legacy_compatible_permission_profile(&permission_profile, cwd.as_path());
let sandbox_policy = legacy_profile
.to_legacy_sandbox_policy(cwd.as_path())
.unwrap_or_else(|err| {
tracing::warn!(
%err,
"permission profile cannot be projected to legacy UserTurn sandbox; using read-only compatibility fallback"
);
match PermissionProfile::read_only().to_legacy_sandbox_policy(cwd.as_path()) {
Ok(policy) => policy,
Err(err) => {
unreachable!("read-only permissions must be legacy-compatible: {err}")
}
}
unreachable!("legacy-compatible permissions must project to legacy policy: {err}")
});
Self(Op::UserTurn {
items,
codex-rs/tui/src/app_server_session.rs
+49 -16
View File
@@ -3,6 +3,7 @@ use crate::bottom_pane::FeedbackAudience;
use crate::legacy_core::append_message_history_entry;
use crate::legacy_core::config::Config;
use crate::legacy_core::message_history_metadata;
use crate::permission_compat::legacy_compatible_permission_profile;
use crate::status::StatusAccountDisplay;
use crate::status::plan_type_display_name;
use codex_app_server_client::AppServerClient;
@@ -542,21 +543,15 @@ impl AppServerSession {
) -> Result<TurnStartResponse> {
let request_id = self.next_request_id();
let sandbox_policy = if matches!(self.thread_params_mode(), ThreadParamsMode::Remote) {
let policy = match permission_profile.to_legacy_sandbox_policy(cwd.as_path()) {
Ok(policy) => policy,
Err(err) => {
tracing::warn!(
%err,
"permission profile cannot be projected for remote turn/start; using read-only compatibility fallback"
);
match PermissionProfile::read_only().to_legacy_sandbox_policy(cwd.as_path()) {
Ok(policy) => policy,
Err(err) => {
unreachable!("read-only permissions must be legacy-compatible: {err}")
}
}
}
};
let legacy_profile =
legacy_compatible_permission_profile(&permission_profile, cwd.as_path());
let policy = legacy_profile
.to_legacy_sandbox_policy(cwd.as_path())
.unwrap_or_else(|err| {
unreachable!(
"legacy-compatible permissions must project to legacy policy: {err}"
)
});
Some(policy.into())
} else {
None
@@ -1123,7 +1118,10 @@ fn sandbox_mode_from_permission_profile(
.network_sandbox_policy()
.is_enabled()
.then_some(codex_app_server_protocol::SandboxMode::DangerFullAccess)
} else if file_system_policy.can_write_path_with_cwd(cwd, cwd) {
} else if !file_system_policy
.get_writable_roots_with_cwd(cwd)
.is_empty()
{
Some(codex_app_server_protocol::SandboxMode::WorkspaceWrite)
} else {
Some(codex_app_server_protocol::SandboxMode::ReadOnly)
@@ -1513,6 +1511,12 @@ mod tests {
use codex_app_server_protocol::ThreadStatus;
use codex_app_server_protocol::Turn;
use codex_app_server_protocol::TurnStatus;
use codex_protocol::models::ManagedFileSystemPermissions;
use codex_protocol::permissions::FileSystemAccessMode;
use codex_protocol::permissions::FileSystemPath;
use codex_protocol::permissions::FileSystemSandboxEntry;
use codex_protocol::permissions::FileSystemSpecialPath;
use codex_protocol::permissions::NetworkSandboxPolicy;
use codex_utils_absolute_path::test_support::PathBufExt;
use codex_utils_absolute_path::test_support::test_path_buf;
use pretty_assertions::assert_eq;
@@ -1605,6 +1609,35 @@ mod tests {
assert_eq!(fork.permission_profile, None);
}
#[test]
fn sandbox_mode_preserves_non_cwd_write_roots_for_remote_sessions() {
let cwd = test_path_buf("/workspace/project").abs();
let extra_root = test_path_buf("/workspace/cache").abs();
let permission_profile = PermissionProfile::Managed {
file_system: ManagedFileSystemPermissions::Restricted {
entries: vec![
FileSystemSandboxEntry {
path: FileSystemPath::Special {
value: FileSystemSpecialPath::Root,
},
access: FileSystemAccessMode::Read,
},
FileSystemSandboxEntry {
path: FileSystemPath::Path { path: extra_root },
access: FileSystemAccessMode::Write,
},
],
glob_scan_max_depth: None,
},
network: NetworkSandboxPolicy::Restricted,
};
assert_eq!(
sandbox_mode_from_permission_profile(&permission_profile, cwd.as_path()),
Some(codex_app_server_protocol::SandboxMode::WorkspaceWrite)
);
}
#[tokio::test]
async fn thread_lifecycle_params_forward_explicit_remote_cwd_override_for_remote_sessions() {
let temp_dir = tempfile::tempdir().expect("tempdir");
codex-rs/tui/src/lib.rs
+1
View File
@@ -150,6 +150,7 @@ mod npm_registry;
pub(crate) mod onboarding;
mod oss_selection;
mod pager_overlay;
mod permission_compat;
pub(crate) mod public_widgets;
mod render;
mod resize_reflow_cap;
codex-rs/tui/src/permission_compat.rs
+102
View File
@@ -0,0 +1,102 @@
use codex_protocol::models::PermissionProfile;
use codex_protocol::permissions::FileSystemSandboxPolicy;
use codex_protocol::permissions::NetworkSandboxPolicy;
use codex_utils_absolute_path::AbsolutePathBuf;
use std::path::Path;
pub(crate) fn legacy_compatible_permission_profile(
permission_profile: &PermissionProfile,
cwd: &Path,
) -> PermissionProfile {
if permission_profile.to_legacy_sandbox_policy(cwd).is_ok() {
return permission_profile.clone();
}
let file_system_policy = permission_profile.file_system_sandbox_policy();
compatibility_workspace_write_profile(
&file_system_policy,
permission_profile.network_sandbox_policy(),
cwd,
)
}
fn compatibility_workspace_write_profile(
file_system_policy: &FileSystemSandboxPolicy,
network_policy: NetworkSandboxPolicy,
cwd: &Path,
) -> PermissionProfile {
let cwd_abs = AbsolutePathBuf::from_absolute_path(cwd).ok();
let writable_roots = file_system_policy
.get_writable_roots_with_cwd(cwd)
.into_iter()
.map(|root| root.root)
.filter(|root| cwd_abs.as_ref() != Some(root))
.collect::<Vec<_>>();
let tmpdir_writable = std::env::var_os("TMPDIR")
.filter(|tmpdir| !tmpdir.is_empty())
.and_then(|tmpdir| {
AbsolutePathBuf::from_absolute_path(std::path::PathBuf::from(tmpdir)).ok()
})
.is_some_and(|tmpdir| file_system_policy.can_write_path_with_cwd(tmpdir.as_path(), cwd));
let slash_tmp = Path::new("/tmp");
let slash_tmp_writable = slash_tmp.is_absolute()
&& slash_tmp.is_dir()
&& file_system_policy.can_write_path_with_cwd(slash_tmp, cwd);
PermissionProfile::workspace_write_with(
&writable_roots,
network_policy,
!tmpdir_writable,
!slash_tmp_writable,
)
}
#[cfg(test)]
mod tests {
use super::*;
use codex_protocol::models::ManagedFileSystemPermissions;
use codex_protocol::permissions::FileSystemAccessMode;
use codex_protocol::permissions::FileSystemPath;
use codex_protocol::permissions::FileSystemSandboxEntry;
use codex_protocol::permissions::FileSystemSpecialPath;
use pretty_assertions::assert_eq;
#[test]
fn compatibility_profile_preserves_unbridgeable_write_roots() {
let cwd = AbsolutePathBuf::try_from("/workspace/project").expect("absolute cwd");
let extra_root = AbsolutePathBuf::try_from("/workspace/extra").expect("absolute root");
let permission_profile = PermissionProfile::Managed {
file_system: ManagedFileSystemPermissions::Restricted {
entries: vec![
FileSystemSandboxEntry {
path: FileSystemPath::Special {
value: FileSystemSpecialPath::Root,
},
access: FileSystemAccessMode::Read,
},
FileSystemSandboxEntry {
path: FileSystemPath::Path {
path: extra_root.clone(),
},
access: FileSystemAccessMode::Write,
},
],
glob_scan_max_depth: None,
},
network: NetworkSandboxPolicy::Restricted,
};
let compatibility_profile =
legacy_compatible_permission_profile(&permission_profile, cwd.as_path());
let policy = compatibility_profile
.to_legacy_sandbox_policy(cwd.as_path())
.expect("compatibility profile should project to legacy policy");
let roots = policy
.get_writable_roots_with_cwd(cwd.as_path())
.into_iter()
.map(|root| root.root)
.collect::<Vec<_>>();
assert_eq!(roots, vec![extra_root, cwd]);
}
}