Skip to content

Commit 764e58d

Browse files
committed
utils: summarize permission profiles directly
1 parent c37f743 commit 764e58d

4 files changed

Lines changed: 152 additions & 76 deletions

File tree

‎codex-rs/tui/src/status/tests.rs‎

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -528,6 +528,7 @@ async fn status_snapshot_shows_auto_review_permissions() {
528528
async fn status_permissions_full_disk_managed_with_network_is_danger_full_access() {
529529
let temp_home = TempDir::new().expect("temp home");
530530
let mut config = test_config(&temp_home).await;
531+
config.approvals_reviewer = ApprovalsReviewer::User;
531532
config
532533
.permissions
533534
.approval_policy
@@ -548,9 +549,10 @@ async fn status_permissions_full_disk_managed_with_network_is_danger_full_access
548549
}
549550

550551
#[tokio::test]
551-
async fn status_permissions_full_disk_managed_without_network_is_external_sandbox() {
552+
async fn status_permissions_full_disk_managed_without_network_is_custom_permissions() {
552553
let temp_home = TempDir::new().expect("temp home");
553554
let mut config = test_config(&temp_home).await;
555+
config.approvals_reviewer = ApprovalsReviewer::User;
554556
config
555557
.permissions
556558
.approval_policy
@@ -566,7 +568,7 @@ async fn status_permissions_full_disk_managed_without_network_is_external_sandbo
566568

567569
assert_eq!(
568570
permissions_text_for(&config).as_deref(),
569-
Some("Custom (external-sandbox, on-request)")
571+
Some("Custom (custom permissions, on-request)")
570572
);
571573
}
572574

‎codex-rs/utils/sandbox-summary/src/config_summary.rs‎

Lines changed: 4 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
use codex_core::config::Config;
22
use codex_model_provider_info::WireApi;
33

4-
use crate::sandbox_summary::summarize_sandbox_policy;
4+
use crate::sandbox_summary::summarize_permission_profile;
55

66
/// Build a list of key/value pairs summarizing the effective configuration.
77
pub fn create_config_summary_entries(config: &Config, model: &str) -> Vec<(&'static str, String)> {
@@ -15,10 +15,9 @@ pub fn create_config_summary_entries(config: &Config, model: &str) -> Vec<(&'sta
1515
),
1616
(
1717
"sandbox",
18-
summarize_sandbox_policy(
19-
&config
20-
.permissions
21-
.legacy_sandbox_policy(config.cwd.as_path()),
18+
summarize_permission_profile(
19+
&config.permissions.permission_profile(),
20+
config.cwd.as_path(),
2221
),
2322
),
2423
];

‎codex-rs/utils/sandbox-summary/src/lib.rs‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3,4 +3,3 @@ mod sandbox_summary;
33

44
pub use config_summary::create_config_summary_entries;
55
pub use sandbox_summary::summarize_permission_profile;
6-
pub use sandbox_summary::summarize_sandbox_policy;

‎codex-rs/utils/sandbox-summary/src/sandbox_summary.rs‎

Lines changed: 144 additions & 68 deletions
Original file line numberDiff line numberDiff line change
@@ -1,109 +1,185 @@
11
use codex_protocol::models::PermissionProfile;
2-
use codex_protocol::protocol::NetworkAccess;
3-
use codex_protocol::protocol::SandboxPolicy;
2+
use codex_protocol::permissions::FileSystemSandboxPolicy;
3+
use codex_protocol::permissions::NetworkSandboxPolicy;
44
use std::path::Path;
55

6-
pub fn summarize_sandbox_policy(sandbox_policy: &SandboxPolicy) -> String {
7-
match sandbox_policy {
8-
SandboxPolicy::DangerFullAccess => "danger-full-access".to_string(),
9-
SandboxPolicy::ReadOnly { network_access, .. } => {
10-
let mut summary = "read-only".to_string();
11-
if *network_access {
12-
summary.push_str(" (network access enabled)");
13-
}
14-
summary
15-
}
16-
SandboxPolicy::ExternalSandbox { network_access } => {
17-
let mut summary = "external-sandbox".to_string();
18-
if matches!(network_access, NetworkAccess::Enabled) {
19-
summary.push_str(" (network access enabled)");
20-
}
21-
summary
6+
pub fn summarize_permission_profile(permission_profile: &PermissionProfile, cwd: &Path) -> String {
7+
match permission_profile {
8+
PermissionProfile::Disabled => "danger-full-access".to_string(),
9+
PermissionProfile::External { network } => {
10+
summary_with_network("external-sandbox", network.is_enabled())
2211
}
23-
SandboxPolicy::WorkspaceWrite {
24-
writable_roots,
25-
network_access,
26-
exclude_tmpdir_env_var,
27-
exclude_slash_tmp,
28-
} => {
29-
let mut summary = "workspace-write".to_string();
12+
PermissionProfile::Managed {
13+
file_system,
14+
network,
15+
} => summarize_managed_profile(&file_system.to_sandbox_policy(), *network, cwd),
16+
}
17+
}
3018

31-
let mut writable_entries = Vec::<String>::new();
32-
writable_entries.push("workdir".to_string());
33-
if !*exclude_slash_tmp {
34-
writable_entries.push("/tmp".to_string());
35-
}
36-
if !*exclude_tmpdir_env_var {
37-
writable_entries.push("$TMPDIR".to_string());
38-
}
39-
writable_entries.extend(
40-
writable_roots
41-
.iter()
42-
.map(|p| p.to_string_lossy().to_string()),
43-
);
19+
fn summarize_managed_profile(
20+
file_system: &FileSystemSandboxPolicy,
21+
network: NetworkSandboxPolicy,
22+
cwd: &Path,
23+
) -> String {
24+
let network_enabled = network.is_enabled();
25+
if file_system.has_full_disk_write_access() {
26+
if network_enabled {
27+
return "danger-full-access".to_string();
28+
}
29+
return custom_summary(network_enabled);
30+
}
4431

45-
summary.push_str(&format!(" [{}]", writable_entries.join(", ")));
46-
if *network_access {
47-
summary.push_str(" (network access enabled)");
48-
}
49-
summary
32+
let writable_roots = file_system.get_writable_roots_with_cwd(cwd);
33+
if writable_roots.is_empty() {
34+
if file_system.has_full_disk_read_access() {
35+
return summary_with_network("read-only", network_enabled);
5036
}
37+
return custom_summary(network_enabled);
5138
}
39+
if !file_system.can_write_path_with_cwd(cwd, cwd) {
40+
return custom_summary(network_enabled);
41+
}
42+
43+
let writable_entries = writable_roots
44+
.iter()
45+
.map(|root| writable_root_display(root.root.as_path(), cwd))
46+
.collect::<Vec<_>>();
47+
summary_with_network(
48+
&format!("workspace-write [{}]", writable_entries.join(", ")),
49+
network_enabled,
50+
)
5251
}
5352

54-
pub fn summarize_permission_profile(permission_profile: &PermissionProfile, cwd: &Path) -> String {
55-
match permission_profile.to_legacy_sandbox_policy(cwd) {
56-
Ok(policy) => summarize_sandbox_policy(&policy),
57-
Err(_) => {
58-
if permission_profile.network_sandbox_policy().is_enabled() {
59-
"custom permissions (network access enabled)".to_string()
60-
} else {
61-
"custom permissions".to_string()
62-
}
63-
}
53+
fn writable_root_display(root: &Path, cwd: &Path) -> String {
54+
if root == cwd {
55+
return "workdir".to_string();
56+
}
57+
if cfg!(unix) && root == Path::new("/tmp") {
58+
return "/tmp".to_string();
59+
}
60+
if root == std::env::temp_dir() {
61+
return "$TMPDIR".to_string();
62+
}
63+
root.display().to_string()
64+
}
65+
66+
fn summary_with_network(base: &str, network_enabled: bool) -> String {
67+
if network_enabled {
68+
format!("{base} (network access enabled)")
69+
} else {
70+
base.to_string()
6471
}
6572
}
6673

74+
fn custom_summary(network_enabled: bool) -> String {
75+
summary_with_network("custom permissions", network_enabled)
76+
}
77+
6778
#[cfg(test)]
6879
mod tests {
6980
use super::*;
81+
use codex_protocol::permissions::FileSystemAccessMode;
82+
use codex_protocol::permissions::FileSystemPath;
83+
use codex_protocol::permissions::FileSystemSandboxEntry;
84+
use codex_protocol::permissions::FileSystemSpecialPath;
7085
use codex_utils_absolute_path::AbsolutePathBuf;
7186
use pretty_assertions::assert_eq;
7287

7388
#[test]
7489
fn summarizes_external_sandbox_without_network_access_suffix() {
75-
let summary = summarize_sandbox_policy(&SandboxPolicy::ExternalSandbox {
76-
network_access: NetworkAccess::Restricted,
77-
});
90+
let summary = summarize_permission_profile(
91+
&PermissionProfile::External {
92+
network: NetworkSandboxPolicy::Restricted,
93+
},
94+
Path::new("/repo"),
95+
);
7896
assert_eq!(summary, "external-sandbox");
7997
}
8098

8199
#[test]
82100
fn summarizes_external_sandbox_with_enabled_network() {
83-
let summary = summarize_sandbox_policy(&SandboxPolicy::ExternalSandbox {
84-
network_access: NetworkAccess::Enabled,
85-
});
101+
let summary = summarize_permission_profile(
102+
&PermissionProfile::External {
103+
network: NetworkSandboxPolicy::Enabled,
104+
},
105+
Path::new("/repo"),
106+
);
86107
assert_eq!(summary, "external-sandbox (network access enabled)");
87108
}
88109

89110
#[test]
90111
fn summarizes_read_only_with_enabled_network() {
91-
let summary = summarize_sandbox_policy(&SandboxPolicy::ReadOnly {
92-
network_access: true,
93-
});
112+
let file_system = FileSystemSandboxPolicy::restricted(vec![FileSystemSandboxEntry {
113+
path: FileSystemPath::Special {
114+
value: FileSystemSpecialPath::Root,
115+
},
116+
access: FileSystemAccessMode::Read,
117+
}]);
118+
let profile = PermissionProfile::from_runtime_permissions(
119+
&file_system,
120+
NetworkSandboxPolicy::Enabled,
121+
);
122+
let summary = summarize_permission_profile(&profile, Path::new("/repo"));
94123
assert_eq!(summary, "read-only (network access enabled)");
95124
}
96125

126+
#[test]
127+
fn unrestricted_filesystem_without_network_is_custom_permissions() {
128+
let profile = PermissionProfile::from_runtime_permissions(
129+
&FileSystemSandboxPolicy::unrestricted(),
130+
NetworkSandboxPolicy::Restricted,
131+
);
132+
let summary = summarize_permission_profile(&profile, Path::new("/repo"));
133+
assert_eq!(summary, "custom permissions");
134+
}
135+
136+
#[test]
137+
fn explicit_writable_root_outside_cwd_is_custom_permissions() {
138+
let writable_root = AbsolutePathBuf::try_from(if cfg!(windows) {
139+
"C:\\outside"
140+
} else {
141+
"/outside"
142+
})
143+
.unwrap();
144+
let file_system = FileSystemSandboxPolicy::restricted(vec![
145+
FileSystemSandboxEntry {
146+
path: FileSystemPath::Special {
147+
value: FileSystemSpecialPath::Root,
148+
},
149+
access: FileSystemAccessMode::Read,
150+
},
151+
FileSystemSandboxEntry {
152+
path: FileSystemPath::Path {
153+
path: writable_root,
154+
},
155+
access: FileSystemAccessMode::Write,
156+
},
157+
]);
158+
let profile = PermissionProfile::from_runtime_permissions(
159+
&file_system,
160+
NetworkSandboxPolicy::Restricted,
161+
);
162+
let cwd = if cfg!(windows) { "C:\\repo" } else { "/repo" };
163+
let summary = summarize_permission_profile(&profile, Path::new(cwd));
164+
assert_eq!(summary, "custom permissions");
165+
}
166+
97167
#[test]
98168
fn workspace_write_summary_still_includes_network_access() {
99169
let root = if cfg!(windows) { "C:\\repo" } else { "/repo" };
100170
let writable_root = AbsolutePathBuf::try_from(root).unwrap();
101-
let summary = summarize_sandbox_policy(&SandboxPolicy::WorkspaceWrite {
102-
writable_roots: vec![writable_root.clone()],
103-
network_access: true,
104-
exclude_tmpdir_env_var: true,
105-
exclude_slash_tmp: true,
106-
});
171+
let cwd = if cfg!(windows) {
172+
"C:\\workdir"
173+
} else {
174+
"/workdir"
175+
};
176+
let profile = PermissionProfile::workspace_write_with(
177+
std::slice::from_ref(&writable_root),
178+
NetworkSandboxPolicy::Enabled,
179+
/*exclude_tmpdir_env_var*/ true,
180+
/*exclude_slash_tmp*/ true,
181+
);
182+
let summary = summarize_permission_profile(&profile, Path::new(cwd));
107183
assert_eq!(
108184
summary,
109185
format!(

0 commit comments

Comments
 (0)