Lightweight coding agent that runs in your terminal
Rust
Move permission profile snapshots into the protocol (#38651)
sayan-oaic530bcd4cd46
diff --git a/codex-rs/core-api/src/lib.rs b/codex-rs/core-api/src/lib.rsindex effe8c697f..a97099f0b6 100644--- a/codex-rs/core-api/src/lib.rs+++ b/codex-rs/core-api/src/lib.rs@@ -110,6 +110,7 @@ pub use codex_protocol::dynamic_tools::DynamicToolNamespaceTool;pub use codex_protocol::dynamic_tools::DynamicToolSpec;pub use codex_protocol::error::Result as CodexResult;pub use codex_protocol::models::PermissionProfile;+pub use codex_protocol::models::PermissionProfileSnapshot;pub use codex_protocol::openai_models::ModelPreset;pub use codex_protocol::protocol::AskForApproval;pub use codex_protocol::protocol::EnvironmentConfigState;diff --git a/codex-rs/core/src/config/mod.rs b/codex-rs/core/src/config/mod.rsindex 07f1bdfbeb..2361fea0cd 100644--- a/codex-rs/core/src/config/mod.rs+++ b/codex-rs/core/src/config/mod.rs@@ -106,6 +106,7 @@ use codex_protocol::config_types::WindowsSandboxLevel;use codex_protocol::models::ActivePermissionProfile;use codex_protocol::models::BaseInstructionsProvenance;use codex_protocol::models::PermissionProfile;+pub use codex_protocol::models::PermissionProfileSnapshot;use codex_protocol::models::SandboxEnforcement;use codex_protocol::openai_models::ModelMessages;use codex_protocol::openai_models::ModelsResponse;@@ -179,7 +180,6 @@ use permission_profile_catalog::permission_profile_catalog_from_permissions;use permission_profile_catalog::permission_profile_is_allowed;use permission_profile_catalog::validate_permission_profile_for_deny_read;pub(crate) use permissions::is_builtin_permission_profile_name;-pub use resolved_permission_profile::PermissionProfileSnapshot;pub(crate) use resolved_permission_profile::PermissionProfileState;const DEFAULT_IGNORE_LARGE_UNTRACKED_DIRS: i64 = 200;@@ -361,10 +361,8 @@ impl Permissions {snapshot: PermissionProfileSnapshot,) -> ConstraintResult<()> {let permission_profile = Constrained::allow_only(snapshot.permission_profile().clone());- self.permission_profile_state = PermissionProfileState::from_constrained_resolved(- permission_profile,- snapshot.into_resolved_permission_profile(),- )?;+ self.permission_profile_state =+ PermissionProfileState::from_constrained_snapshot(permission_profile, snapshot)?;Ok(())}diff --git a/codex-rs/core/src/config/resolved_permission_profile.rs b/codex-rs/core/src/config/resolved_permission_profile.rsindex 22f0357e56..ba61c765b2 100644--- a/codex-rs/core/src/config/resolved_permission_profile.rs+++ b/codex-rs/core/src/config/resolved_permission_profile.rs@@ -1,241 +1,22 @@use codex_config::Constrained;use codex_config::ConstraintResult;use codex_protocol::models::ActivePermissionProfile;-use codex_protocol::models::BUILT_IN_PERMISSION_PROFILE_DANGER_FULL_ACCESS;-use codex_protocol::models::BUILT_IN_PERMISSION_PROFILE_READ_ONLY;-use codex_protocol::models::BUILT_IN_PERMISSION_PROFILE_WORKSPACE;use codex_protocol::models::PermissionProfile;+use codex_protocol::models::PermissionProfileSnapshot;use codex_utils_absolute_path::AbsolutePathBuf;-#[derive(Debug, Clone, Copy, PartialEq, Eq)]-pub(crate) enum BuiltInPermissionProfileId {- ReadOnly,- Workspace,- DangerFullAccess,-}--impl BuiltInPermissionProfileId {- fn from_str(id: &str) -> Option<Self> {- match id {- BUILT_IN_PERMISSION_PROFILE_READ_ONLY => Some(Self::ReadOnly),- BUILT_IN_PERMISSION_PROFILE_WORKSPACE => Some(Self::Workspace),- BUILT_IN_PERMISSION_PROFILE_DANGER_FULL_ACCESS => Some(Self::DangerFullAccess),- _ => None,- }- }-- fn as_str(self) -> &'static str {- match self {- Self::ReadOnly => BUILT_IN_PERMISSION_PROFILE_READ_ONLY,- Self::Workspace => BUILT_IN_PERMISSION_PROFILE_WORKSPACE,- Self::DangerFullAccess => BUILT_IN_PERMISSION_PROFILE_DANGER_FULL_ACCESS,- }- }-}--#[derive(Debug, Clone, PartialEq, Eq)]-pub(crate) enum ResolvedPermissionProfile {- Legacy(LegacyPermissionProfile),- BuiltIn(BuiltInPermissionProfile),- Named(NamedPermissionProfile),-}--/// Trusted snapshot of a resolved permission profile.-///-/// This is a bridge for already-resolved session/config state. It keeps the-/// concrete `PermissionProfile`, optional active profile id, and-/// profile-defined workspace roots together so `Permissions` can validate and-/// install them atomically. It is not a resolver: callers that are handling-/// user-selected profile ids should resolve those ids through config instead-/// of constructing this type directly.-#[derive(Debug, Clone, PartialEq, Eq)]-pub struct PermissionProfileSnapshot {- resolved_permission_profile: ResolvedPermissionProfile,-}--#[derive(Debug, Clone, PartialEq, Eq)]-pub(crate) struct LegacyPermissionProfile {- permission_profile: PermissionProfile,-}--#[derive(Debug, Clone, PartialEq, Eq)]-pub(crate) struct BuiltInPermissionProfile {- id: BuiltInPermissionProfileId,- extends: Option<String>,- permission_profile: PermissionProfile,- profile_workspace_roots: Vec<AbsolutePathBuf>,-}--#[derive(Debug, Clone, PartialEq, Eq)]-pub(crate) struct NamedPermissionProfile {- id: String,- extends: Option<String>,- permission_profile: PermissionProfile,- profile_workspace_roots: Vec<AbsolutePathBuf>,-}--impl ResolvedPermissionProfile {- pub(crate) fn from_active_profile(- permission_profile: PermissionProfile,- active_permission_profile: Option<ActivePermissionProfile>,- profile_workspace_roots: Vec<AbsolutePathBuf>,- ) -> Self {- let Some(active_permission_profile) = active_permission_profile else {- return Self::legacy(permission_profile);- };-- let ActivePermissionProfile { id, extends } = active_permission_profile;- if let Some(built_in_id) = BuiltInPermissionProfileId::from_str(&id) {- Self::BuiltIn(BuiltInPermissionProfile {- id: built_in_id,- extends,- permission_profile,- profile_workspace_roots,- })- } else {- Self::Named(NamedPermissionProfile {- id,- extends,- permission_profile,- profile_workspace_roots,- })- }- }-- pub(crate) fn legacy(permission_profile: PermissionProfile) -> Self {- Self::Legacy(LegacyPermissionProfile { permission_profile })- }-- pub(crate) fn permission_profile(&self) -> &PermissionProfile {- match self {- Self::Legacy(profile) => &profile.permission_profile,- Self::BuiltIn(profile) => &profile.permission_profile,- Self::Named(profile) => &profile.permission_profile,- }- }-- pub(crate) fn active_permission_profile(&self) -> Option<ActivePermissionProfile> {- match self {- Self::Legacy(_) => None,- Self::BuiltIn(profile) => Some(ActivePermissionProfile {- id: profile.id.as_str().to_string(),- extends: profile.extends.clone(),- }),- Self::Named(profile) => Some(ActivePermissionProfile {- id: profile.id.clone(),- extends: profile.extends.clone(),- }),- }- }-- pub(crate) fn profile_workspace_roots(&self) -> &[AbsolutePathBuf] {- match self {- Self::Legacy(_) => &[],- Self::BuiltIn(profile) => &profile.profile_workspace_roots,- Self::Named(profile) => &profile.profile_workspace_roots,- }- }-}--impl PermissionProfileSnapshot {- /// Create a snapshot with no active profile id.- ///- /// Prefer this only for legacy data or local overrides that genuinely do- /// not have a named/built-in profile identity. Using this for a built-in or- /// named profile will intentionally clear the active profile metadata.- pub fn legacy(permission_profile: PermissionProfile) -> Self {- Self {- resolved_permission_profile: ResolvedPermissionProfile::legacy(permission_profile),- }- }-- /// Create a snapshot for a known active profile id.- ///- /// Use this only after a trusted caller has already resolved the active id- /// to the supplied concrete `PermissionProfile`. This constructor does not- /// verify that the id and profile match; `Permissions` will still enforce- /// configured permission constraints when the snapshot is installed.- pub fn active(- permission_profile: PermissionProfile,- active_permission_profile: ActivePermissionProfile,- ) -> Self {- Self::active_with_profile_workspace_roots(- permission_profile,- active_permission_profile,- Vec::new(),- )- }-- /// Create a snapshot for a known active profile id with profile roots.- ///- /// As with `active`, the caller is responsible for passing the concrete- /// profile and active id that were resolved together. Use this variant when- /// the selected profile declared workspace roots that should remain- /// distinct from turn-scoped runtime workspace roots.- pub fn active_with_profile_workspace_roots(- permission_profile: PermissionProfile,- active_permission_profile: ActivePermissionProfile,- profile_workspace_roots: Vec<AbsolutePathBuf>,- ) -> Self {- Self {- resolved_permission_profile: ResolvedPermissionProfile::from_active_profile(- permission_profile,- Some(active_permission_profile),- profile_workspace_roots,- ),- }- }-- /// Reconstruct a trusted snapshot from session state.- ///- /// This is intended for session responses emitted by core, where the- /// concrete profile and active profile id were captured together. Avoid- /// using this as a shortcut for arbitrary user input because mismatched- /// arguments can still misrepresent the active profile identity.- pub fn from_session_snapshot(- permission_profile: PermissionProfile,- active_permission_profile: Option<ActivePermissionProfile>,- ) -> Self {- match active_permission_profile {- Some(active_permission_profile) => {- Self::active(permission_profile, active_permission_profile)- }- None => Self::legacy(permission_profile),- }- }-- /// Borrow the concrete permission profile captured in this snapshot.- pub fn permission_profile(&self) -> &PermissionProfile {- self.resolved_permission_profile.permission_profile()- }-- /// Return the active profile id captured in this snapshot, if any.- pub fn active_permission_profile(&self) -> Option<ActivePermissionProfile> {- self.resolved_permission_profile.active_permission_profile()- }-- /// Borrow profile-declared workspace roots captured in this snapshot.- pub fn profile_workspace_roots(&self) -> &[AbsolutePathBuf] {- self.resolved_permission_profile.profile_workspace_roots()- }-- pub(crate) fn into_resolved_permission_profile(self) -> ResolvedPermissionProfile {- self.resolved_permission_profile- }-}-#[derive(Debug, Clone, PartialEq)]pub(crate) struct PermissionProfileState {- resolved_permission_profile: Constrained<ResolvedPermissionProfile>,+ permission_profile: Constrained<PermissionProfileSnapshot>,}impl PermissionProfileState {pub(crate) fn from_constrained_legacy(constrained_permission_profile: Constrained<PermissionProfile>,) -> ConstraintResult<Self> {- let resolved =- ResolvedPermissionProfile::legacy(constrained_permission_profile.get().clone());- Self::from_constrained_resolved(constrained_permission_profile, resolved)+ let snapshot =+ PermissionProfileSnapshot::legacy(constrained_permission_profile.get().clone());+ Self::from_constrained_snapshot(constrained_permission_profile, snapshot)}pub(crate) fn from_constrained_active_profile(@@ -243,73 +24,66 @@ impl PermissionProfileState {active_permission_profile: Option<ActivePermissionProfile>,profile_workspace_roots: Vec<AbsolutePathBuf>,) -> ConstraintResult<Self> {- let resolved = ResolvedPermissionProfile::from_active_profile(- constrained_permission_profile.get().clone(),- active_permission_profile,- profile_workspace_roots,- );- Self::from_constrained_resolved(constrained_permission_profile, resolved)+ let permission_profile = constrained_permission_profile.get().clone();+ let snapshot = match active_permission_profile {+ Some(active_permission_profile) => {+ PermissionProfileSnapshot::active_with_profile_workspace_roots(+ permission_profile,+ active_permission_profile,+ profile_workspace_roots,+ )+ }+ None => PermissionProfileSnapshot::legacy(permission_profile),+ };+ Self::from_constrained_snapshot(constrained_permission_profile, snapshot)}- pub(crate) fn from_constrained_resolved(+ pub(crate) fn from_constrained_snapshot(constrained_permission_profile: Constrained<PermissionProfile>,- resolved_permission_profile: ResolvedPermissionProfile,+ permission_profile: PermissionProfileSnapshot,) -> ConstraintResult<Self> {- let permission_profile_constraint = constrained_permission_profile;- let resolved_permission_profile = Constrained::new(- resolved_permission_profile,- move |candidate: &ResolvedPermissionProfile| {- permission_profile_constraint.can_set(candidate.permission_profile())- },- )?;- Ok(Self {- resolved_permission_profile,- })+ let permission_profile = Constrained::new(permission_profile, move |candidate| {+ constrained_permission_profile.can_set(candidate.permission_profile())+ })?;+ Ok(Self { permission_profile })}pub(crate) fn permission_profile(&self) -> &PermissionProfile {- self.resolved_permission_profile.get().permission_profile()+ self.permission_profile.get().permission_profile()}pub(crate) fn snapshot(&self) -> PermissionProfileSnapshot {- PermissionProfileSnapshot {- resolved_permission_profile: self.resolved_permission_profile.get().clone(),- }+ self.permission_profile.get().clone()}pub(crate) fn active_permission_profile(&self) -> Option<ActivePermissionProfile> {- self.resolved_permission_profile- .get()- .active_permission_profile()+ self.permission_profile.get().active_permission_profile()}pub(crate) fn profile_workspace_roots(&self) -> &[AbsolutePathBuf] {- self.resolved_permission_profile- .get()- .profile_workspace_roots()+ self.permission_profile.get().profile_workspace_roots()}pub(crate) fn can_set_legacy_permission_profile(&self,permission_profile: &PermissionProfile,) -> ConstraintResult<()> {- let candidate = ResolvedPermissionProfile::legacy(permission_profile.clone());- self.resolved_permission_profile.can_set(&candidate)+ let candidate = PermissionProfileSnapshot::legacy(permission_profile.clone());+ self.permission_profile.can_set(&candidate)}pub(crate) fn set_legacy_permission_profile(&mut self,permission_profile: PermissionProfile,) -> ConstraintResult<()> {- self.resolved_permission_profile- .set(ResolvedPermissionProfile::legacy(permission_profile))+ self.permission_profile+ .set(PermissionProfileSnapshot::legacy(permission_profile))}pub(crate) fn set_permission_profile_snapshot(&mut self,snapshot: PermissionProfileSnapshot,) -> ConstraintResult<()> {- self.resolved_permission_profile- .set(snapshot.into_resolved_permission_profile())+ self.permission_profile.set(snapshot)}}diff --git a/codex-rs/protocol/src/lib.rs b/codex-rs/protocol/src/lib.rsindex 7bb02d316b..5608f5d8ea 100644--- a/codex-rs/protocol/src/lib.rs+++ b/codex-rs/protocol/src/lib.rs@@ -30,6 +30,7 @@ pub mod network_policy;pub mod num_format;pub mod openai_models;pub mod parse_command;+mod permission_profile_snapshot;pub mod permissions;pub mod plan_tool;pub mod protocol;diff --git a/codex-rs/protocol/src/models.rs b/codex-rs/protocol/src/models.rsindex 5d10a56f3a..dad99f2dc4 100644--- a/codex-rs/protocol/src/models.rs+++ b/codex-rs/protocol/src/models.rs@@ -33,6 +33,7 @@ mod executed_tool_calls;pub use crate::local_media::MAX_PROMPT_AUDIO_INPUT_BYTES;pub use crate::local_media::snapshot_local_user_input;+pub use crate::permission_profile_snapshot::PermissionProfileSnapshot;pub use executed_tool_calls::ExecutedToolCall;pub use executed_tool_calls::ExecutedToolCallArguments;pub use executed_tool_calls::ExecutedToolCallTruncation;diff --git a/codex-rs/protocol/src/permission_profile_snapshot.rs b/codex-rs/protocol/src/permission_profile_snapshot.rsnew file mode 100644index 0000000000..0f97cc202d--- /dev/null+++ b/codex-rs/protocol/src/permission_profile_snapshot.rs@@ -0,0 +1,86 @@+use codex_utils_absolute_path::AbsolutePathBuf;++use crate::models::ActivePermissionProfile;+use crate::models::PermissionProfile;++/// Trusted snapshot of a resolved permission profile.+///+/// Keeps the concrete permissions, optional active profile identity, and+/// profile-defined workspace roots together for atomic installation. Callers+/// handling user-selected profile ids must resolve those ids before+/// constructing a snapshot.+#[derive(Debug, Clone, PartialEq, Eq)]+pub struct PermissionProfileSnapshot {+ permission_profile: PermissionProfile,+ active_permission_profile: Option<ActivePermissionProfile>,+ profile_workspace_roots: Vec<AbsolutePathBuf>,+}++impl PermissionProfileSnapshot {+ /// Create a snapshot with no active profile identity.+ ///+ /// Use this only for legacy data or local overrides that genuinely do not+ /// have a named or built-in profile identity.+ pub fn legacy(permission_profile: PermissionProfile) -> Self {+ Self {+ permission_profile,+ active_permission_profile: None,+ profile_workspace_roots: Vec::new(),+ }+ }++ /// Create a snapshot for an already-resolved active profile.+ pub fn active(+ permission_profile: PermissionProfile,+ active_permission_profile: ActivePermissionProfile,+ ) -> Self {+ Self::active_with_profile_workspace_roots(+ permission_profile,+ active_permission_profile,+ Vec::new(),+ )+ }++ /// Create a snapshot for an active profile and its declared roots.+ ///+ /// Profile roots remain distinct from turn-scoped runtime workspace roots.+ pub fn active_with_profile_workspace_roots(+ permission_profile: PermissionProfile,+ active_permission_profile: ActivePermissionProfile,+ profile_workspace_roots: Vec<AbsolutePathBuf>,+ ) -> Self {+ Self {+ permission_profile,+ active_permission_profile: Some(active_permission_profile),+ profile_workspace_roots,+ }+ }++ /// Reconstruct a trusted snapshot from already-resolved session state.+ pub fn from_session_snapshot(+ permission_profile: PermissionProfile,+ active_permission_profile: Option<ActivePermissionProfile>,+ ) -> Self {+ match active_permission_profile {+ Some(active_permission_profile) => {+ Self::active(permission_profile, active_permission_profile)+ }+ None => Self::legacy(permission_profile),+ }+ }++ /// Borrow the concrete permissions captured in this snapshot.+ pub fn permission_profile(&self) -> &PermissionProfile {+ &self.permission_profile+ }++ /// Return the active profile identity captured in this snapshot, if any.+ pub fn active_permission_profile(&self) -> Option<ActivePermissionProfile> {+ self.active_permission_profile.clone()+ }++ /// Borrow profile-declared workspace roots captured in this snapshot.+ pub fn profile_workspace_roots(&self) -> &[AbsolutePathBuf] {+ &self.profile_workspace_roots+ }+}