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
+335 -4
View File
@@ -676,11 +676,16 @@ async fn exec_resume_by_id_appends_to_existing_file() -> anyhow::Result<()> {
let server = responses::start_sse_server().await;
let _response_mock = mount_exec_responses(&server, /*count*/ 2).await;
// 1) First run: create a session
std::fs::write(
test.home_path().join("config.toml"),
"default_permissions = ':workspace'",
)?;
// Start read-only despite the writable process default.
let marker = format!("resume-by-id-{}", Uuid::new_v4());
let prompt = format!("echo {marker}");
test.cmd_with_server(&server)
.args(["-c", "default_permissions=':read-only'"])
.arg("--skip-git-repo-check")
.arg(&prompt)
.assert()
@@ -699,13 +704,21 @@ async fn exec_resume_by_id_appends_to_existing_file() -> anyhow::Result<()> {
let marker2 = format!("resume-by-id-2-{}", Uuid::new_v4());
let prompt2 = format!("echo {marker2}");
test.cmd_with_server(&server)
let output = test
.cmd_with_server(&server)
.arg("--skip-git-repo-check")
.args(["--color", "never"])
.arg(&prompt2)
.arg("resume")
.arg(&session_id)
.assert()
.success();
.output()?;
assert!(output.status.success(), "resume failed: {output:?}");
let stderr = String::from_utf8(output.stderr)?;
let sandbox_summary = stderr
.lines()
.find(|line| line.starts_with("sandbox: "))
.context("missing sandbox startup summary")?;
insta::assert_snapshot!(sandbox_summary, @"sandbox: read-only");
let resumed_path = find_session_file_containing_marker(&sessions_dir, &marker2)
.expect("no resumed session file containing marker2");
@@ -716,6 +729,324 @@ async fn exec_resume_by_id_appends_to_existing_file() -> anyhow::Result<()> {
let content = std::fs::read_to_string(&resumed_path)?;
assert!(content.contains(&marker));
assert!(content.contains(&marker2));
let turn_profiles = content
.lines()
.map(serde_json::from_str::<Value>)
.collect::<Result<Vec<_>, _>>()?
.into_iter()
.filter(|item| item["type"] == "turn_context")
.map(|item| item["payload"]["active_permission_profile"]["id"].clone())
.collect::<Vec<_>>();
assert_eq!(turn_profiles, [":read-only", ":read-only"]);
Ok(())
}
#[cfg(unix)]
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn exec_resume_enforces_read_only_on_first_shell_call() -> anyhow::Result<()> {
skip_if_no_network!(Ok(()));
core_test_support::skip_if_sandbox!(Ok(()));
#[cfg(target_os = "linux")]
if super::sandbox::linux_sandbox_test_env().await.is_none() {
return Ok(());
}
let test = test_codex_exec();
let server = responses::start_sse_server().await;
std::fs::write(
test.home_path().join("config.toml"),
"default_permissions = ':workspace'",
)?;
let shell_args = serde_json::json!({
"cmd": "printf 'shell reached\\n'; printf probe > resume-write.txt",
"shell": "/bin/sh",
"login": false,
});
let mock = responses::mount_sse_sequence(
&server,
vec![
exec_sse_response(/*index*/ 0),
responses::sse(vec![
responses::ev_function_call("write-probe", "exec_command", &shell_args.to_string()),
responses::ev_completed("response-with-probe"),
]),
exec_sse_response(/*index*/ 2),
],
)
.await;
let marker = format!("resume-enforcement-{}", Uuid::new_v4());
test.cmd_with_server(&server)
.args([
"--skip-git-repo-check",
"-c",
"default_permissions=':read-only'",
])
.arg(&marker)
.assert()
.success();
let path = find_session_file_containing_marker(&test.home_path().join("sessions"), &marker)
.context("missing initial session")?;
let session_id = extract_conversation_id(&path);
test.cmd_with_server(&server)
.args([
"--skip-git-repo-check",
"resume",
&session_id,
"check workspace write access",
])
.assert()
.success();
let tool_output = mock
.last_request()
.and_then(|request| request.function_call_output_text("write-probe"))
.context("missing first-turn shell output")?;
assert!(
tool_output.lines().any(|line| line == "shell reached"),
"the shell did not start: {tool_output}",
);
let tool_output_lower = tool_output.to_ascii_lowercase();
assert!(
[
"permission denied",
"operation not permitted",
"read-only file system"
]
.iter()
.any(|denial| tool_output_lower.contains(denial)),
"expected the shell write to be denied: {tool_output}",
);
assert!(!test.cwd_path().join("resume-write.txt").try_exists()?);
Ok(())
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn exec_resume_adds_only_requested_roots_to_saved_workspace() -> anyhow::Result<()> {
skip_if_no_network!(Ok(()));
let test = test_codex_exec();
let server = responses::start_sse_server().await;
let _mock = mount_exec_responses(&server, /*count*/ 3).await;
let cwd =
codex_utils_absolute_path::canonicalize_existing_preserving_symlinks(test.cwd_path())?;
let scratch = cwd.join("scratch");
let extra = cwd.join("extra");
std::fs::create_dir(&scratch)?;
std::fs::create_dir(&extra)?;
let marker = "start with only scratch writable";
test.cmd_with_server(&server)
.args([
"--skip-git-repo-check",
"-c",
"default_permissions=':workspace'",
"-C",
])
.arg(&scratch)
.arg(marker)
.assert()
.success();
let rollout = find_session_file_containing_marker(&test.home_path().join("sessions"), marker)
.context("missing initial session")?;
let id = extract_conversation_id(&rollout);
for (args, expected_roots) in [
(vec![], vec![&scratch]),
(vec!["--add-dir", "extra"], vec![&scratch, &extra]),
] {
let output = test
.cmd_with_server(&server)
.arg("--skip-git-repo-check")
.args(args)
.args(["resume", &id, "continue"])
.output()?;
assert!(output.status.success(), "resume failed: {output:?}");
if expected_roots.contains(&&extra) {
let stderr = String::from_utf8(output.stderr)?;
let summary = stderr
.lines()
.find(|line| line.starts_with("sandbox: "))
.context("missing sandbox summary")?;
assert!(summary.contains(&*extra.to_string_lossy()), "{summary}");
}
let settings = std::fs::read_to_string(&rollout)?
.lines()
.rev()
.map(serde_json::from_str::<Value>)
.collect::<Result<Vec<_>, _>>()?
.into_iter()
.find(|item| item["payload"]["type"] == "thread_settings_applied")
.context("missing resumed settings")?;
let snapshot = &settings["payload"]["thread_settings"];
assert_eq!(snapshot["cwd"], serde_json::json!(scratch));
assert_eq!(
snapshot["runtime_workspace_roots"],
serde_json::json!(expected_roots)
);
}
Ok(())
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn exec_resume_restores_unnamed_read_only_from_legacy_history() -> anyhow::Result<()> {
skip_if_no_network!(Ok(()));
let test = test_codex_exec();
let server = responses::start_sse_server().await;
let _mock = mount_exec_responses(&server, /*count*/ 2).await;
std::fs::write(
test.home_path().join("config.toml"),
"default_permissions = ':workspace'",
)?;
let marker = format!("resume-legacy-{}", Uuid::new_v4());
test.cmd_with_server(&server)
.args(["--skip-git-repo-check", "--sandbox", "read-only"])
.arg(&marker)
.assert()
.success();
let path = find_session_file_containing_marker(&test.home_path().join("sessions"), &marker)
.context("missing initial session")?;
let session_id = extract_conversation_id(&path);
let history = std::fs::read_to_string(&path)?;
let mut legacy_history = String::new();
for line in history.lines() {
let item: Value = serde_json::from_str(line)?;
if item["type"] == "event_msg" && item["payload"]["type"] == "thread_settings_applied" {
continue;
}
if item["type"] == "turn_context" {
assert!(item["payload"]["active_permission_profile"].is_null());
}
legacy_history.push_str(line);
legacy_history.push('\n');
}
std::fs::write(&path, legacy_history)?;
let output = test
.cmd_with_server(&server)
.args([
"--skip-git-repo-check",
"--color",
"never",
"resume",
&session_id,
"resume an older read-only session",
])
.output()?;
assert!(output.status.success(), "resume failed: {output:?}");
let stderr = String::from_utf8(output.stderr)?;
let summary = stderr
.lines()
.find(|line| line.starts_with("sandbox: "))
.context("missing startup permission summary")?;
insta::assert_snapshot!(summary, @"sandbox: read-only");
Ok(())
}
#[cfg(unix)]
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn exec_resume_preserves_explicit_legacy_workspace_settings() -> anyhow::Result<()> {
use codex_protocol::permissions::FileSystemPath;
use codex_protocol::permissions::FileSystemSpecialPath;
skip_if_no_network!(Ok(()));
let test = test_codex_exec();
let server = responses::start_sse_server().await;
let _mock = mount_exec_responses(&server, /*count*/ 3).await;
std::fs::create_dir(test.cwd_path().join("scratch"))?;
std::fs::write(
test.home_path().join("config.toml"),
r#"
sandbox_mode = "workspace-write"
[permissions.partial]
extends = ":read-only"
[permissions.partial.filesystem.":workspace_roots"]
scratch = "write"
"#,
)?;
let marker = format!("resume-legacy-{}", Uuid::new_v4());
test.cmd_with_server(&server)
.args([
"--skip-git-repo-check",
"-c",
"default_permissions='partial'",
])
.arg(&marker)
.assert()
.success();
let path = find_session_file_containing_marker(&test.home_path().join("sessions"), &marker)
.context("missing initial session")?;
let session_id = extract_conversation_id(&path);
let output = test
.cmd_with_server(&server)
.args([
"--skip-git-repo-check",
"--color",
"never",
"resume",
&session_id,
"resume with the saved profile",
])
.output()?;
assert!(output.status.success(), "resume failed: {output:?}");
let stderr = String::from_utf8(output.stderr)?;
let sandbox_summary = stderr
.lines()
.find(|line| line.starts_with("sandbox: "))
.context("missing sandbox startup summary")?;
insta::assert_snapshot!(sandbox_summary, @"sandbox: custom permissions");
test.cmd_with_server(&server)
.args([
"--skip-git-repo-check",
"-c",
"sandbox_workspace_write.exclude_tmpdir_env_var=true",
])
.args([
"resume",
&session_id,
"resume with explicit legacy settings",
])
.assert()
.success();
let turns = std::fs::read_to_string(path)?
.lines()
.map(serde_json::from_str::<codex_rollout::RolloutItem>)
.collect::<Result<Vec<_>, _>>()?
.into_iter()
.filter_map(|item| match item {
codex_rollout::RolloutItem::TurnContext(turn) => Some(turn),
_ => None,
})
.collect::<Vec<_>>();
let [started, restored, overridden] = turns.as_slice() else {
anyhow::bail!("expected three turns, got {}", turns.len());
};
assert_eq!(
[started, restored, overridden].map(|turn| turn
.active_permission_profile
.as_ref()
.map(|profile| profile.id.as_str())),
[Some("partial"), Some("partial"), None],
);
let (file_system, _) = overridden.permission_profile.to_runtime_permissions();
assert!(
file_system
.can_write_local_path_with_cwd(overridden.cwd.as_path(), overridden.cwd.as_path())
);
assert!(!file_system.entries.iter().any(|entry| {
entry.access.can_write()
&& matches!(
entry.path,
FileSystemPath::Special {
value: FileSystemSpecialPath::Tmpdir
}
)
}));
Ok(())
}