Files
codex/codex-rs/app-server/src/request_processors/persisted_resume_settings.rs
T
viyatb-oai 89feadf3cc 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
2026-11-18 05:13:56 +00:00

160 lines
6.3 KiB
Rust

use codex_protocol::ThreadId;
use codex_protocol::config_types::ApprovalsReviewer;
use codex_protocol::models::ActivePermissionProfile;
use codex_protocol::models::PermissionProfile;
use codex_protocol::protocol::AskForApproval;
use codex_protocol::protocol::EventMsg;
use codex_protocol::protocol::ThreadSettingsSnapshot;
use codex_rollout::InitialHistory;
use codex_rollout::RolloutItem;
#[derive(Debug, PartialEq, Eq)]
pub(super) struct PersistedResumeSettings {
pub(super) approval_policy: AskForApproval,
pub(super) approvals_reviewer: Option<ApprovalsReviewer>,
pub(super) active_permission_profile: Option<ActivePermissionProfile>,
pub(super) unnamed_permission_profile: Option<PermissionProfile>,
}
impl PersistedResumeSettings {
pub(super) fn from_history(history: &[RolloutItem], thread_id: ThreadId) -> Option<Self> {
// A running turn can record stale permissions. Prefer a settings update whose
// owner is known, including a legacy update following that owner's checkpoint.
let mut latest_legacy = None;
for item in history.iter().rev() {
let RolloutItem::EventMsg(EventMsg::ThreadSettingsApplied(event)) = item else {
continue;
};
match event.thread_id {
Some(owner) if owner == thread_id => {
return Some(Self::from(latest_legacy.unwrap_or(&event.thread_settings)));
}
Some(_) => latest_legacy = None,
None => {
latest_legacy.get_or_insert(&event.thread_settings);
}
}
}
latest_persisted_resume_settings(history)
}
}
impl From<&ThreadSettingsSnapshot> for PersistedResumeSettings {
fn from(settings: &ThreadSettingsSnapshot) -> Self {
Self {
approval_policy: settings.approval_policy,
approvals_reviewer: Some(
settings
.requested_approvals_reviewer
.unwrap_or(settings.approvals_reviewer),
),
active_permission_profile: settings.active_permission_profile.clone(),
unnamed_permission_profile: settings
.active_permission_profile
.is_none()
.then(|| settings.permission_profile.clone()),
}
}
}
pub(super) fn latest_owned_thread_settings(
history: &[RolloutItem],
thread_id: ThreadId,
) -> Option<&ThreadSettingsSnapshot> {
history.iter().rev().find_map(|item| match item {
RolloutItem::EventMsg(EventMsg::ThreadSettingsApplied(event))
if event.thread_id == Some(thread_id) =>
{
Some(&event.thread_settings)
}
_ => None,
})
}
fn latest_persisted_resume_settings(history: &[RolloutItem]) -> Option<PersistedResumeSettings> {
history
.iter()
.enumerate()
.rev()
.find_map(|(index, item)| match item {
RolloutItem::TurnContext(turn_context) => Some(PersistedResumeSettings {
approval_policy: turn_context.approval_policy,
approvals_reviewer: turn_context.approvals_reviewer.or_else(|| {
history[..index].iter().rev().find_map(|item| match item {
RolloutItem::TurnContext(turn_context) => turn_context.approvals_reviewer,
RolloutItem::EventMsg(EventMsg::ThreadSettingsApplied(event)) => Some(
event
.thread_settings
.requested_approvals_reviewer
.unwrap_or(event.thread_settings.approvals_reviewer),
),
_ => None,
})
}),
active_permission_profile: turn_context.active_permission_profile.clone(),
unnamed_permission_profile: unattributed_read_only_profile(
&turn_context.permission_profile,
turn_context.active_permission_profile.as_ref(),
),
}),
RolloutItem::EventMsg(EventMsg::ThreadSettingsApplied(event)) => {
let settings = &event.thread_settings;
Some(PersistedResumeSettings {
approval_policy: settings.approval_policy,
approvals_reviewer: Some(
settings
.requested_approvals_reviewer
.unwrap_or(settings.approvals_reviewer),
),
active_permission_profile: settings.active_permission_profile.clone(),
unnamed_permission_profile: if event.thread_id.is_none() {
unattributed_read_only_profile(
&settings.permission_profile,
settings.active_permission_profile.as_ref(),
)
} else {
None
},
})
}
_ => None,
})
}
fn unattributed_read_only_profile(
profile: &PermissionProfile,
active_profile: Option<&ActivePermissionProfile>,
) -> Option<PermissionProfile> {
// Unattributed history can preserve built-in read-only access. Other concrete
// profiles may carry grants that belong to another thread or executor.
let read_only = PermissionProfile::read_only();
(active_profile.is_none() && *profile == read_only).then_some(read_only)
}
pub(super) fn latest_persisted_model_settings(
history: &InitialHistory,
) -> Option<&ThreadSettingsSnapshot> {
let InitialHistory::Resumed(history) = history else {
return None;
};
let mut crossed_foreign_snapshot = false;
for item in history.history.iter().rev() {
let RolloutItem::EventMsg(EventMsg::ThreadSettingsApplied(event)) = item else {
continue;
};
match event.thread_id {
Some(thread_id) if thread_id == history.conversation_id => {
return Some(&event.thread_settings);
}
Some(_) => crossed_foreign_snapshot = true,
None if !crossed_foreign_snapshot => return Some(&event.thread_settings),
None => {}
}
}
None
}
#[cfg(test)]
#[path = "persisted_resume_settings_tests.rs"]
mod tests;