Restore permission profiles when resuming threads (#39153)

## Why

Cold resumes and forks could lose the thread's active permission profile and
fall back to the current configured default.

## What changed

- Restore the latest persisted approval policy, approvals reviewer, and active
  permission-profile ID when resuming or forking a thread.
- Re-resolve persisted profile IDs through current configuration and
  requirements. Missing or invalid profiles fall back to the configured
  default, while threads without a persisted profile continue to use current
  configuration.
- Keep explicit permission and approval overrides ahead of persisted settings.

## Testing

Added coverage for legacy and paginated histories, settings updates, explicit
overrides, removed or changed profiles, requirement fallbacks, and forks.

GitOrigin-RevId: 2289af2f3206bf131a6ffe0e8447e8d402e76c47
This commit is contained in:
Shijie Rao authored and copyberry committed 2026-08-18 06:22:04 +00:00
1 parent 6f95f19103
commit 539a09cb28
11 files changed
+935 -268

No files matched your search

+226 -22
View File
@@ -2360,6 +2360,196 @@ async fn permission_profile_override_populates_runtime_permissions() -> std::io:
Ok(())
}
#[tokio::test]
async fn persisted_permission_profile_id_wins_over_configured_default() -> std::io::Result<()> {
let codex_home = TempDir::new()?;
let cwd = TempDir::new()?;
let config_toml = toml::from_str(
r#"
default_permissions = ":read-only"
[permissions.dev]
extends = ":workspace"
"#,
)
.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 {
id: "dev".to_string(),
extends: Some(BUILT_IN_PERMISSION_PROFILE_WORKSPACE.to_string()),
})
);
assert_eq!(
config.legacy_sandbox_policy(),
SandboxPolicy::new_workspace_write_policy()
);
Ok(())
}
#[tokio::test]
async fn missing_persisted_permission_profile_id_uses_configured_default() -> 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 [
(
Some(BUILT_IN_PERMISSION_PROFILE_READ_ONLY.to_string()),
None,
Some(ActivePermissionProfile::read_only()),
),
(None, Some(SandboxMode::ReadOnly), None),
] {
let config = Config::load_from_base_config_with_overrides(
ConfigToml {
default_permissions: configured_default,
sandbox_mode: configured_sandbox,
projects: Some(HashMap::from([(
project_key.clone(),
ProjectConfig {
trust_level: Some(TrustLevel::Trusted),
},
)])),
..Default::default()
},
ConfigOverrides {
cwd: Some(cwd.path().to_path_buf()),
persisted_permission_profile_id: Some("removed-profile".to_string()),
..Default::default()
},
codex_home.abs(),
)
.await?;
assert_eq!(
config.permissions.active_permission_profile(),
expected_active_profile
);
assert_eq!(
config.permissions.effective_permission_profile(),
PermissionProfile::read_only()
);
}
Ok(())
}
#[tokio::test]
async fn invalid_persisted_permission_profile_uses_configured_default() -> 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",
] {
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(
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 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()?;
let cwd = TempDir::new()?;
let error = Config::load_from_base_config_with_overrides(
ConfigToml::default(),
ConfigOverrides {
cwd: Some(cwd.path().to_path_buf()),
default_permissions: Some("removed-profile".to_string()),
..Default::default()
},
codex_home.abs(),
)
.await
.expect_err("explicit missing profile should be rejected");
assert_eq!(error.kind(), std::io::ErrorKind::InvalidInput);
assert_eq!(
error.to_string(),
"default_permissions requires a `[permissions]` table"
);
Ok(())
}
#[test]
fn permission_snapshot_setter_preserves_permission_constraints() {
let initial_profile = PermissionProfile::read_only();
@@ -10383,32 +10573,46 @@ async fn permission_profile_override_falls_back_when_disallowed_by_requirements(
#[tokio::test]
async fn active_profile_is_cleared_when_requirements_force_fallback() -> std::io::Result<()> {
let codex_home = TempDir::new()?;
let config = ConfigBuilder::without_managed_config_for_tests()
.codex_home(codex_home.path().to_path_buf())
.fallback_cwd(Some(codex_home.path().to_path_buf()))
.harness_overrides(ConfigOverrides {
for overrides in [
ConfigOverrides {
default_permissions: Some(BUILT_IN_PERMISSION_PROFILE_DANGER_FULL_ACCESS.to_string()),
..Default::default()
})
.cloud_config_bundle(
CloudConfigBundleFixture::loader_with_enterprise_requirement(
r#"allowed_sandbox_modes = ["read-only"]"#,
},
ConfigOverrides {
persisted_permission_profile_id: Some(
BUILT_IN_PERMISSION_PROFILE_DANGER_FULL_ACCESS.to_string(),
),
)
.build()
.await?;
..Default::default()
},
] {
let config = ConfigBuilder::without_managed_config_for_tests()
.codex_home(codex_home.path().to_path_buf())
.fallback_cwd(Some(codex_home.path().to_path_buf()))
.harness_overrides(overrides)
.cloud_config_bundle(
CloudConfigBundleFixture::loader_with_enterprise_requirement(
r#"allowed_sandbox_modes = ["read-only"]"#,
),
)
.build()
.await?;
assert_eq!(
config.permissions.effective_permission_profile(),
PermissionProfile::read_only()
);
assert_eq!(config.permissions.active_permission_profile(), None);
assert!(
config.startup_warnings.iter().any(|warning| warning
.contains("Configured value for `permission_profile` is disallowed by requirements")),
"{:?}",
config.startup_warnings
);
assert_eq!(
config.permissions.effective_permission_profile(),
PermissionProfile::read_only()
);
assert_eq!(config.permissions.active_permission_profile(), None);
assert!(
config
.startup_warnings
.iter()
.any(|warning| warning.contains(
"Configured value for `permission_profile` is disallowed by requirements"
)),
"{:?}",
config.startup_warnings
);
}
Ok(())
}
+48 -13
View File
@@ -2388,6 +2388,7 @@ struct PermissionSelectionToml {
struct EffectivePermissionSelection<'a> {
profiles: Option<PermissionsToml>,
selected_profile_id: Option<&'a str>,
persisted_profile_id_was_provided: bool,
requirements_force_profile_selection: bool,
}
@@ -2403,7 +2404,8 @@ impl EffectivePermissionSelection<'_> {
default_permissions_override: Option<&str>,
permission_config_syntax: Option<PermissionConfigSyntax>,
) -> bool {
self.requirements_force_profile_selection
self.persisted_profile_id_was_provided
|| self.requirements_force_profile_selection
|| default_permissions_override.is_some()
|| matches!(
permission_config_syntax,
@@ -2506,6 +2508,10 @@ pub struct ConfigOverrides {
pub sandbox_mode: Option<SandboxMode>,
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.
pub persisted_permission_profile_id: Option<String>,
pub model_provider: Option<String>,
pub service_tier: Option<Option<String>>,
pub codex_self_exe: Option<PathBuf>,
@@ -3153,6 +3159,7 @@ impl Config {
sandbox_mode,
permission_profile,
default_permissions: default_permissions_override,
persisted_permission_profile_id,
model_provider,
service_tier: service_tier_override,
codex_self_exe,
@@ -3297,9 +3304,23 @@ impl Config {
sandbox_mode,
);
let requirements_toml = config_layer_stack.requirements_toml();
let windows_sandbox_level = match effective_windows_sandbox_mode {
Some(WindowsSandboxModeToml::Elevated) => WindowsSandboxLevel::Elevated,
Some(WindowsSandboxModeToml::Unelevated) => WindowsSandboxLevel::RestrictedToken,
None => WindowsSandboxLevel::Disabled,
};
let persisted_permission_profile_id = if sandbox_mode.is_some()
|| permission_profile.is_some()
|| default_permissions_override.is_some()
{
None
} else {
persisted_permission_profile_id.as_deref()
};
let effective_permission_selection = resolve_effective_permission_selection(
cfg.permissions.as_ref(),
default_permissions_override.as_deref(),
persisted_permission_profile_id,
cfg.default_permissions.as_deref(),
requirements_toml,
&mut startup_warnings,
@@ -3318,11 +3339,6 @@ impl Config {
));
}
let windows_sandbox_level = match effective_windows_sandbox_mode {
Some(WindowsSandboxModeToml::Elevated) => WindowsSandboxLevel::Elevated,
Some(WindowsSandboxModeToml::Unelevated) => WindowsSandboxLevel::RestrictedToken,
None => WindowsSandboxLevel::Disabled,
};
let memories_config: MemoriesConfig = cfg.memories.clone().unwrap_or_default().into();
let memories_root = memory_root(&codex_home);
@@ -3330,7 +3346,9 @@ impl Config {
default_permissions_override.as_deref(),
permission_config_syntax,
);
let explicit_permission_profile_mode = default_permissions_override.is_some()
let explicit_permission_profile_mode = effective_permission_selection
.persisted_profile_id_was_provided
|| default_permissions_override.is_some()
|| matches!(
permission_config_syntax,
Some(PermissionConfigSyntax::Profiles)
@@ -3342,7 +3360,9 @@ impl Config {
.into_iter()
.filter(|profile| !is_builtin_permission_profile_name(&profile.id))
.collect();
let using_implicit_builtin_profile = permission_config_syntax.is_none()
let using_implicit_builtin_profile = !effective_permission_selection
.persisted_profile_id_was_provided
&& permission_config_syntax.is_none()
&& effective_permission_selection.selected_profile_id.is_none();
let should_seed_legacy_workspace_roots = effective_permission_selection
.selected_profile_id
@@ -4387,18 +4407,31 @@ fn merge_managed_permission_profiles(
}
fn resolve_effective_permission_selection<'a>(
configured_permissions: Option<&PermissionsToml>,
configured_profiles: Option<&PermissionsToml>,
default_permissions_override: Option<&'a str>,
configured_default_permissions: Option<&'a str>,
persisted_profile_id: Option<&'a str>,
configured_default_profile_id: Option<&'a str>,
requirements_toml: &'a ConfigRequirementsToml,
startup_warnings: &mut Vec<String>,
) -> std::io::Result<EffectivePermissionSelection<'a>> {
let profiles = merge_managed_permission_profiles(configured_permissions, requirements_toml)?;
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.filter(|profile_id| {
is_builtin_permission_profile_name(profile_id)
|| profiles.as_ref().is_some_and(|profiles| {
compile_permission_profile_selection(
Some(profiles),
profile_id,
/*workspace_write*/ None,
&mut Vec::new(),
)
.is_ok()
})
});
let selected_profile_id = resolve_default_permissions(
default_permissions_override,
configured_default_permissions,
default_permissions_override.or(valid_persisted_profile_id),
configured_default_profile_id,
requirements_toml,
startup_warnings,
)?;
@@ -4406,6 +4439,8 @@ fn resolve_effective_permission_selection<'a>(
Ok(EffectivePermissionSelection {
profiles,
selected_profile_id,
persisted_profile_id_was_provided: default_permissions_override.is_none()
&& valid_persisted_profile_id.is_some(),
requirements_force_profile_selection: requirements_toml
.allowed_permission_profiles
.is_some(),