Preserve saved sandbox permissions when resuming codex exec (#62194)

## Why

`codex exec resume` sends the current process's sandbox defaults as
overrides. A session started with `:read-only` can therefore resume with
workspace write access when the configured default is `:workspace`.

## What changed

- Restore the saved permission selection, working directory, and workspace
  roots by default. Honor explicit overrides and append directories requested
  with `--add-dir` to the resumed workspace roots.
- Recover built-in read-only permissions from older history without widening
  current read access. Require an explicit permission selection when a saved
  named profile cannot be loaded or saved read-only access cannot be restored.
- Report sandbox permissions and writable roots from the running thread.

## Testing

Add regression coverage for a denied write on the first resumed shell call,
legacy read-only history, explicit permission overrides, and workspace root
preservation with and without `--add-dir`.

GitOrigin-RevId: ed2cf3132f9ce34570661f801c9534a55696e3a5
This commit is contained in:
viyatb-oai
2026-11-18 05:13:56 +00:00
committed by copyberry
parent b78fa4af86
commit 89feadf3cc
16 changed files with 756 additions and 150 deletions
+64 -68
View File
@@ -2965,6 +2965,50 @@ async fn permission_profile_override_populates_runtime_permissions() -> std::io:
Ok(())
}
#[tokio::test]
async fn persisted_read_only_respects_read_allowlist_and_drops_default_proxy() -> anyhow::Result<()>
{
let codex_home = TempDir::new()?;
let cwd = TempDir::new()?;
let config_toml = toml::from_str(
r#"
default_permissions = "dev"
[permissions.dev.filesystem]
":workspace_roots" = "write"
[permissions.dev.network]
enabled = true
"#,
)?;
let config = Config::load_from_base_config_with_overrides(
config_toml,
ConfigOverrides {
cwd: Some(cwd.path().to_path_buf()),
persisted_permission_profile: Some(PermissionProfile::read_only()),
..Default::default()
},
codex_home.abs(),
)
.await?;
let (file_system, network) = config
.permissions
.effective_permission_profile()
.to_runtime_permissions();
let cwd = cwd.path();
assert_eq!(
(
file_system.can_read_local_path_with_cwd(cwd, cwd),
file_system.can_write_local_path_with_cwd(cwd, cwd),
file_system.can_read_local_path_with_cwd(codex_home.path(), cwd),
network,
),
(true, false, false, NetworkSandboxPolicy::Restricted)
);
assert!(config.permissions.network.is_none());
Ok(())
}
#[tokio::test]
async fn persisted_permissions_initialize_proxy_with_expandable_managed_allowlist()
-> anyhow::Result<()> {
@@ -3072,20 +3116,20 @@ extends = ":workspace"
}
#[tokio::test]
async fn missing_persisted_permission_profile_id_uses_configured_default() -> std::io::Result<()> {
async fn missing_persisted_permission_profile_id_requires_explicit_selection() -> std::io::Result<()>
{
let codex_home = TempDir::new()?;
let cwd = TempDir::new()?;
let project_key = cwd.path().to_string_lossy().to_string();
for (configured_default, configured_sandbox, expected_active_profile) in [
for (configured_default, configured_sandbox) in [
(
Some(BUILT_IN_PERMISSION_PROFILE_READ_ONLY.to_string()),
Some(BUILT_IN_PERMISSION_PROFILE_DANGER_FULL_ACCESS.to_string()),
None,
Some(ActivePermissionProfile::read_only()),
),
(None, Some(SandboxMode::ReadOnly), None),
(None, Some(SandboxMode::WorkspaceWrite)),
] {
let config = Config::load_from_base_config_with_overrides(
let error = Config::load_from_base_config_with_overrides(
ConfigToml {
default_permissions: configured_default,
sandbox_mode: configured_sandbox,
@@ -3104,34 +3148,34 @@ async fn missing_persisted_permission_profile_id_uses_configured_default() -> st
},
codex_home.abs(),
)
.await?;
.await
.expect_err("a missing saved profile must require an explicit selection");
assert_eq!(
config.permissions.active_permission_profile(),
expected_active_profile
);
assert_eq!(
config.permissions.effective_permission_profile(),
PermissionProfile::read_only()
assert_eq!(error.kind(), std::io::ErrorKind::InvalidInput);
assert!(
error
.to_string()
.contains("saved permission profile `removed-profile`")
);
}
Ok(())
}
#[tokio::test]
async fn invalid_persisted_permission_profile_uses_configured_default() -> std::io::Result<()> {
async fn invalid_persisted_permission_profile_requires_explicit_selection() -> std::io::Result<()> {
let codex_home = TempDir::new()?;
let cwd = TempDir::new()?;
for invalid_profile in [
"extends = \"removed-parent\"",
"extends = \":read-only\"\n\n[permissions.dev.filesystem]\nglob_scan_max_depth = 0",
"extends = \"base\"\n\n[permissions.base]\nextends = \"dev\"",
] {
let config_toml = toml::from_str(&format!(
"default_permissions = \":danger-full-access\"\n\n[permissions.dev]\n{invalid_profile}"
))
.expect("permission profile config should deserialize");
let config = Config::load_from_base_config_with_overrides(
let error = Config::load_from_base_config_with_overrides(
config_toml,
ConfigOverrides {
cwd: Some(cwd.path().to_path_buf()),
@@ -3140,63 +3184,15 @@ async fn invalid_persisted_permission_profile_uses_configured_default() -> std::
},
codex_home.abs(),
)
.await?;
.await
.expect_err("an invalid saved profile must require an explicit selection");
assert_eq!(
config.permissions.active_permission_profile(),
Some(ActivePermissionProfile::new(
BUILT_IN_PERMISSION_PROFILE_DANGER_FULL_ACCESS,
))
);
assert_eq!(
config.permissions.effective_permission_profile(),
PermissionProfile::Disabled
);
assert_eq!(error.kind(), std::io::ErrorKind::InvalidInput);
assert!(error.to_string().contains("saved permission profile `dev`"));
}
Ok(())
}
#[tokio::test]
async fn persisted_profile_cycle_uses_configured_default() -> std::io::Result<()> {
let codex_home = TempDir::new()?;
let cwd = TempDir::new()?;
let config_toml = toml::from_str(
r#"
default_permissions = ":danger-full-access"
[permissions.dev]
extends = "base"
[permissions.base]
extends = "dev"
"#,
)
.expect("permission profile config should deserialize");
let config = Config::load_from_base_config_with_overrides(
config_toml,
ConfigOverrides {
cwd: Some(cwd.path().to_path_buf()),
persisted_permission_profile_id: Some("dev".to_string()),
..Default::default()
},
codex_home.abs(),
)
.await?;
assert_eq!(
config.permissions.active_permission_profile(),
Some(ActivePermissionProfile::new(
BUILT_IN_PERMISSION_PROFILE_DANGER_FULL_ACCESS,
))
);
assert_eq!(
config.permissions.effective_permission_profile(),
PermissionProfile::Disabled
);
Ok(())
}
#[tokio::test]
async fn missing_explicit_default_permissions_remains_an_error() -> std::io::Result<()> {
let codex_home = TempDir::new()?;
+58 -16
View File
@@ -2798,11 +2798,12 @@ pub struct ConfigOverrides {
pub permission_profile: Option<PermissionProfile>,
pub default_permissions: Option<String>,
/// Permission profile ID recovered from persisted thread state. Explicit
/// permission overrides take precedence, and stale profile IDs fall back
/// to the configured default.
/// permission overrides take precedence. An unavailable saved profile
/// requires an explicit selection.
pub persisted_permission_profile_id: Option<String>,
/// Unnamed permissions from a thread-owned rollout snapshot. These are
/// fallback state: explicit overrides and current requirements take priority.
/// Unnamed permissions from a thread-owned rollout snapshot, or canonical
/// read-only permissions recovered from older history. Explicit overrides
/// and current requirements take priority.
pub persisted_permission_profile: Option<PermissionProfile>,
pub model_provider: Option<String>,
pub service_tier: Option<Option<String>>,
@@ -3739,12 +3740,29 @@ impl Config {
sandbox_mode,
);
let requirements_toml = config_layer_stack.requirements_toml();
let restore_persisted_profile = sandbox_mode.is_none()
&& permission_profile.is_none()
&& default_permissions_override.is_none()
&& persisted_permission_profile_id.is_none();
let persisted_read_only = restore_persisted_profile
&& persisted_permission_profile
.as_ref()
.is_some_and(|profile| *profile == PermissionProfile::read_only());
if persisted_read_only
&& !permission_profile_is_allowed(
&config_layer_stack,
BUILT_IN_READ_ONLY_PROFILE,
&PermissionProfile::read_only(),
)
{
return Err(std::io::Error::new(
std::io::ErrorKind::InvalidInput,
"The saved read-only permission profile is disallowed by requirements. Select a permission profile explicitly to continue.",
));
}
let persisted_permission_profile = persisted_permission_profile.filter(|profile| {
sandbox_mode.is_none()
&& permission_profile.is_none()
&& default_permissions_override.is_none()
&& persisted_permission_profile_id.is_none()
&& requirements_toml.allowed_permission_profiles.is_none()
restore_persisted_profile
&& (persisted_read_only || requirements_toml.allowed_permission_profiles.is_none())
// Executor-owned enforcement and materialized grants are not portable
// thread defaults. Reject the original mode before preserving denials.
&& !matches!(profile, PermissionProfile::External { .. })
@@ -3881,7 +3899,7 @@ impl Config {
};
dedupe_absolute_paths(&mut workspace_roots);
let (
configured_network_proxy_config,
mut configured_network_proxy_config,
mut permission_profile,
mut file_system_sandbox_policy,
mut active_permission_profile,
@@ -4022,6 +4040,21 @@ impl Config {
)
};
if let Some(saved) = persisted_permission_profile {
// Canonical read-only recovery can remove writes without replacing a
// narrower read allowlist from the current configuration.
let saved = if persisted_read_only
&& (!file_system_sandbox_policy.has_full_disk_read_access()
|| matches!(permission_profile, PermissionProfile::External { .. }))
{
permission_profile.intersect_with_read_only().ok_or_else(|| {
std::io::Error::new(
std::io::ErrorKind::InvalidInput,
"Could not restore the saved read-only permission profile under external enforcement. Select a permission profile explicitly to continue.",
)
})?
} else {
saved
};
let (mut saved_file_system, saved_network) = saved.to_runtime_permissions();
saved_file_system.preserve_deny_read_restrictions_from(&file_system_sandbox_policy);
let restored = PermissionProfile::from_runtime_permissions_with_enforcement(
@@ -4035,6 +4068,9 @@ impl Config {
) {
permission_profile = restored;
file_system_sandbox_policy = saved_file_system;
if persisted_read_only {
configured_network_proxy_config = NetworkProxyConfig::default();
}
active_permission_profile = None;
profile_workspace_roots.clear();
}
@@ -5231,7 +5267,7 @@ fn resolve_effective_permission_selection<'a>(
let profiles = merge_managed_permission_profiles(configured_profiles, requirements_toml)?;
validate_user_permission_profile_names(profiles.as_ref())?;
validate_required_permission_profile_catalog(requirements_toml, profiles.as_ref())?;
let valid_persisted_profile_id = persisted_profile_id.and_then(|(profile_id, context)| {
if let Some((profile_id, context)) = persisted_profile_id {
compile_permission_profile(
profiles.as_ref(),
profile_id,
@@ -5239,11 +5275,17 @@ fn resolve_effective_permission_selection<'a>(
/*workspace_write*/ None,
&mut Vec::new(),
)
.is_ok()
.then_some(profile_id)
});
.map_err(|err| {
std::io::Error::new(
std::io::ErrorKind::InvalidInput,
format!(
"Could not load saved permission profile `{profile_id}`: {err}. Select a permission profile explicitly to continue."
),
)
})?;
}
let selected_profile_id = resolve_default_permissions(
default_permissions_override.or(valid_persisted_profile_id),
default_permissions_override.or(persisted_profile_id.map(|(profile_id, _)| profile_id)),
configured_default_profile_id,
requirements_toml,
startup_warnings,
@@ -5253,7 +5295,7 @@ fn resolve_effective_permission_selection<'a>(
profiles,
selected_profile_id,
persisted_profile_id_was_provided: default_permissions_override.is_none()
&& valid_persisted_profile_id.is_some(),
&& persisted_profile_id.is_some(),
requirements_force_profile_selection: requirements_toml
.allowed_permission_profiles
.is_some(),