Lightweight coding agent that runs in your terminal
Rust
Preserve local launch permissions across TUI sessions and reconnects (#49809)
Eric Traut2fde968de8bc
diff --git a/codex-rs/tui/src/app/agents_overview.rs b/codex-rs/tui/src/app/agents_overview.rsindex f7639dd86b..341e116648 100644--- a/codex-rs/tui/src/app/agents_overview.rs+++ b/codex-rs/tui/src/app/agents_overview.rs@@ -775,6 +775,9 @@ impl App {.set_workspace_roots(self.config.permissions.workspace_roots().to_vec());}self.config = destination_config;+ if is_new_session {+ self.remember_launch_permissions();+ }if !read_only {let approval = self.config.permissions.approval_policy.value();if selfdiff --git a/codex-rs/tui/src/app/reconnect.rs b/codex-rs/tui/src/app/reconnect.rsindex 132f4f9388..bdb643db84 100644--- a/codex-rs/tui/src/app/reconnect.rs+++ b/codex-rs/tui/src/app/reconnect.rs@@ -147,6 +147,11 @@ impl App {{session.approval_policy = policy;}+ if let Some(reviewer) = self.runtime_approvals_reviewer_override+ && reviewer == cached.approvals_reviewer+ {+ session.approvals_reviewer = reviewer;+ }if let Some(profile) = &self.runtime_permission_profile_override&& profile.permission_profile == cached.permission_profile&& profile.active_permission_profile == cached.active_permission_profilediff --git a/codex-rs/tui/src/app/session_lifecycle.rs b/codex-rs/tui/src/app/session_lifecycle.rsindex 4ffd85ed63..c1bdc28b26 100644--- a/codex-rs/tui/src/app/session_lifecycle.rs+++ b/codex-rs/tui/src/app/session_lifecycle.rs@@ -1038,6 +1038,7 @@ impl App {self.local_settings = self.local_settings.reloaded(&config);self.refresh_server_version_overview_notice(CODEX_CLI_VERSION);self.config = config;+ self.remember_launch_permissions();let name_error = if let Some(name) = new_thread_name {match app_serverdiff --git a/codex-rs/tui/src/app/startup.rs b/codex-rs/tui/src/app/startup.rsindex ce40f68450..0714428e9d 100644--- a/codex-rs/tui/src/app/startup.rs+++ b/codex-rs/tui/src/app/startup.rs@@ -3,6 +3,7 @@//! Owns the main app run loop from app-server bootstrap through terminal shutdown. Startup input//! remains isolated from protected interactive requests until the initialized composer owns it.//! Queued resume history replaces the provisional loading frame only when it is ready to render.+//! Explicit local launch permissions remain runtime overrides across new sessions and reconnects.use super::reconnect::ReconnectState;use super::*;@@ -121,6 +122,41 @@ pub(super) fn startup_model(}impl App {+ /// Keep explicit local launch choices available for new sessions and reconnect recovery.+ pub(super) fn remember_launch_permissions(&mut self) {+ if self.app_server_target.thread_params_mode()+ == crate::app_server_session::ThreadParamsMode::Remote+ {+ return;+ }+ let selected = crate::resume_permissions::ResumePermissions::from_overrides(+ &self.config,+ &self.harness_overrides,+ );+ if selected.approval_policy {+ self.runtime_approval_policy_override = Some(RuntimeApprovalPolicyOverride::Explicit(+ self.config.permissions.approval_policy.value().into(),+ ));+ }+ if selected.approvals_reviewer {+ self.runtime_approvals_reviewer_override = Some(self.config.approvals_reviewer);+ }+ if selected.profile {+ let profile = RuntimePermissionProfileOverride::from_config(&self.config);+ // The server owns constrained profiles that legacy turn parameters cannot express.+ self.runtime_permission_profile_override =+ (profile.active_permission_profile.is_some()+ || crate::app_server_session::turn_permissions_overrides(+ TurnPermissionsOverride::LegacySandbox(+ self.config.permissions.effective_permission_profile(),+ ),+ self.config.cwd.as_path(),+ )+ .is_ok())+ .then_some(profile);+ }+ }+/// Keep the provisional loading frame until queued history reaches the owned transcript./// Visible startup decisions and the agent overview must still render immediately.pub(super) fn render_startup_frame(@@ -889,6 +925,7 @@ See the Codex keymap documentation for supported actions and examples."#[cfg(test)]_test_codex_home: None,};+ app.remember_launch_permissions();if !tui.is_terminal_focused() {app.recap.note_focus_lost(Instant::now());}diff --git a/codex-rs/tui/src/app/tests/active_reconnect_tests.rs b/codex-rs/tui/src/app/tests/active_reconnect_tests.rsindex de130ba8d3..7723ab1b6b 100644--- a/codex-rs/tui/src/app/tests/active_reconnect_tests.rs+++ b/codex-rs/tui/src/app/tests/active_reconnect_tests.rs@@ -11,6 +11,22 @@ use tokio::net::TcpListener;use super::disconnect::serve_reconnect_requests;+#[tokio::test]+async fn reconnect_restores_launch_reviewer_without_a_profile_override() -> Result<()> {+ let (mut app, _events, _ops) = make_test_app_with_channels().await;+ let mut cached = test_thread_session(ThreadId::new(), app.config.cwd.to_path_buf());+ cached.approvals_reviewer = ApprovalsReviewer::AutoReview;+ app.primary_thread_id = Some(cached.thread_id);+ app.config.approvals_reviewer = ApprovalsReviewer::AutoReview;+ app.harness_overrides.approvals_reviewer = Some(ApprovalsReviewer::AutoReview);+ app.remember_launch_permissions();+ let mut resumed = cached.clone();+ resumed.approvals_reviewer = ApprovalsReviewer::User;+ app.restore_runtime_permissions(&mut resumed, &cached);+ assert_eq!(resumed, cached);+ Ok(())+}+#[tokio::test]async fn reconnect_restores_history_permissions_and_resumes_unsent_input() -> Result<()> {for (recovered_queue, edit_offline, resume_error_code, deferred_notice, notice_enabled) in [diff --git a/codex-rs/tui/src/app/tests/new_session_tests.rs b/codex-rs/tui/src/app/tests/new_session_tests.rsindex e77967d796..99c8addc39 100644--- a/codex-rs/tui/src/app/tests/new_session_tests.rs+++ b/codex-rs/tui/src/app/tests/new_session_tests.rs@@ -6,6 +6,78 @@ use crossterm::event::KeyEvent;use crossterm::event::KeyModifiers;use pretty_assertions::assert_eq;+#[tokio::test]+async fn new_sessions_preserve_yolo_launch_and_later_permission_choices() -> Result<()> {+ let (mut app, _events, _ops) = make_test_app_with_channels().await;+ app.harness_overrides.approval_policy = Some(AskForApproval::Never.to_core());+ app.harness_overrides.sandbox_mode =+ Some(codex_protocol::config_types::SandboxMode::DangerFullAccess);+ let (mut server, requests, proxy) = start_recording_app_server(+ &app.config,+ /*blocked_thread_list*/ None,+ /*failed_thread_name*/ None,+ )+ .await?;+ let mut tui = crate::tui::test_support::make_test_tui()?;+ let mut loaded_config = app.config.clone();+ loaded_config+ .permissions+ .approval_policy+ .set(AskForApproval::OnRequest.to_core())?;+ loaded_config+ .permissions+ .set_permission_profile(PermissionProfile::read_only())?;+ let loaded = server.start_thread(&loaded_config).await?;+ app.select_agents_overview_thread(&mut tui, &mut server, loaded.session.thread_id)+ .await?;+ for picker_change in [false, true] {+ if picker_change {+ app.chat_widget+ .set_approval_policy(AskForApproval::OnRequest);+ app.chat_widget+ .set_permission_profile_from_session_snapshot(PermissionProfileSnapshot::active(+ PermissionProfile::read_only(),+ ActivePermissionProfile::new(":read-only"),+ ))?;+ app.adopt_server_permissions();+ }+ app.start_fresh_session(+ &mut tui,+ &mut server,+ /*session_start_source*/ None,+ /*initial_user_message*/ None,+ /*new_thread_name*/ None,+ )+ .await;+ let cached = app.primary_session_configured.as_ref().unwrap().clone();+ let mut resumed = cached.clone();+ resumed.approval_policy = AskForApproval::OnRequest;+ resumed.permission_profile = PermissionProfile::read_only();+ resumed.active_permission_profile = None;+ app.restore_runtime_permissions(&mut resumed, &cached);+ assert_eq!(resumed, cached);+ }+ let params = recorded_params(&requests, "thread/start");+ assert_eq!(+ params+ .iter()+ .skip(1)+ .map(|params| serde_json::json!({+ "approvalPolicy": params["approvalPolicy"],+ "sandbox": params["sandbox"],+ "permissions": params["permissions"],+ }))+ .collect::<Vec<_>>(),+ vec![+ serde_json::json!({"approvalPolicy": "never", "sandbox": "danger-full-access", "permissions": null}),+ serde_json::json!({"approvalPolicy": "on-request", "sandbox": null, "permissions": ":read-only"}),+ ]+ );+ server.shutdown().await?;+ proxy.await??;+ Ok(())+}+#[tokio::test]async fn new_session_preserves_vim_line_yank() -> Result<()> {let (mut app, _events, _ops) = make_test_app_with_channels().await;diff --git a/codex-rs/tui/src/app/tests/turn_submission.rs b/codex-rs/tui/src/app/tests/turn_submission.rsindex 6fd095fbb8..15030ebae3 100644--- a/codex-rs/tui/src/app/tests/turn_submission.rs+++ b/codex-rs/tui/src/app/tests/turn_submission.rs@@ -358,6 +358,38 @@ async fn misalignment_policy_in_parent_stops_active_side_conversation() -> ResulOk(())}+#[tokio::test]+async fn launch_permissions_preserve_server_owned_constrained_profile() -> Result<()> {+ let (mut app, _events, _ops) = make_test_app_with_channels().await;+ app.harness_overrides.sandbox_mode =+ Some(codex_protocol::config_types::SandboxMode::DangerFullAccess);+ app.config+ .permissions+ .set_permission_profile(PermissionProfile::Disabled)?;+ app.remember_launch_permissions();+ let mut profile = PermissionProfile::workspace_write();+ let PermissionProfile::Managed {+ file_system: ManagedFileSystemPermissions::Restricted { entries, .. },+ ..+ } = &mut profile+ else {+ unreachable!("workspace-write uses managed permissions");+ };+ entries.push(FileSystemSandboxEntry {+ path: FileSystemPath::GlobPattern {+ pattern: "**/*.secret".into(),+ },+ access: FileSystemAccessMode::Deny,+ missing_path_behavior: None,+ });+ app.config.permissions.set_permission_profile(profile)?;+ app.harness_overrides.sandbox_mode =+ Some(codex_protocol::config_types::SandboxMode::WorkspaceWrite);+ app.remember_launch_permissions();+ assert_eq!(app.runtime_permission_profile_override, None);+ Ok(())+}+#[tokio::test]async fn unsupported_legacy_permissions_are_shown_without_exiting() -> Result<()> {let (mut app, mut app_event_rx, mut op_rx) = make_test_app_with_channels().await;diff --git a/codex-rs/tui/tests/suite/reconnect.rs b/codex-rs/tui/tests/suite/reconnect.rsindex e62dc3dbb3..609abe7910 100644--- a/codex-rs/tui/tests/suite/reconnect.rs+++ b/codex-rs/tui/tests/suite/reconnect.rs@@ -16,10 +16,13 @@ use tokio_tungstenite::tungstenite::Message;#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn automatic_reconnect_restores_draft_and_routes_new_notifications() -> Result<()> {- let repo_root = codex_utils_cargo_bin::repo_root()?;+ core_test_support::skip_if_sandbox!(Ok(()));+ // Use a workspace without project-specific permission requirements.+ let workspace = tempfile::tempdir()?;+ let workspace_path = workspace.path().canonicalize()?;// macOS's default temporary directory leaves too little room for the control socket path.let codex_home = tempfile::tempdir_in("/tmp")?;- write_test_config(codex_home.path(), &repo_root)?;+ write_test_config(codex_home.path(), &workspace_path)?;let config_path = codex_home.path().join("config.toml");let config = std::fs::read_to_string(&config_path)?;std::fs::write(@@ -31,11 +34,15 @@ async fn automatic_reconnect_restores_draft_and_routes_new_notifications() -> Relet listener = UnixListener::bind(socket.as_path())?;let (disconnect_tx, mut disconnect_rx) = tokio::sync::oneshot::channel();let (restore_tx, restore_rx) = tokio::sync::oneshot::channel();- let server_cwd = repo_root.clone();+ let (complete_tx, mut complete_rx) = tokio::sync::oneshot::channel();+ let (submitted_tx, submitted_rx) = tokio::sync::oneshot::channel();+ let server_cwd = workspace_path.clone();let id = "00000000-0000-0000-0000-000000000001";let server = tokio::spawn(async move {let mut methods = Vec::new();let mut restore_rx = Some(restore_rx);+ let mut recovered_completed = false;+ let mut submitted_tx = Some(submitted_tx);let thread = json!({"id": id, "sessionId": id, "preview": "", "ephemeral": false,"modelProvider": "openai", "createdAt": 1, "updatedAt": 2,@@ -53,6 +60,16 @@ async fn automatic_reconnect_restores_draft_and_routes_new_notifications() -> Re};loop {let frame = tokio::select! {+ _ = &mut complete_rx, if connection == 6 && !recovered_completed => {+ recovered_completed = true;+ socket.send(Message::Text(json!({+ "method": "turn/completed", "params": {+ "threadId": id, "turn": {"id": "running", "status": "completed", "error": null,+ "items": [{"type": "agentMessage", "id": "completed-item", "text": "Recovered turn completed."}]}+ }+ }).to_string().into())).await?;+ continue;+ }_ = &mut disconnect_rx, if connection == 0 => {socket.close(/*msg*/ None).await?;break;@@ -105,9 +122,34 @@ async fn automatic_reconnect_restores_draft_and_routes_new_notifications() -> Re}"configRequirements/read" => json!({"requirements": null}),"thread/start" | "thread/resume" => {+ let starting = request.method == "thread/start";+ if !starting {+ let params = request.params.as_ref().unwrap();+ assert_eq!(+ json!([+ params["approvalPolicy"],+ params["sandbox"],+ params["permissions"]+ ]),+ json!([null, null, null])+ );+ }json!({"thread": thread, "model": "gpt-5.6-terra", "modelProvider": "openai",- "cwd": server_cwd, "approvalPolicy": "never", "approvalsReviewer": "user",- "sandbox": {"type": "readOnly"}, "reasoningEffort": null})+ "cwd": server_cwd, "approvalPolicy": if starting { "never" } else { "on-request" }, "approvalsReviewer": "user",+ "sandbox": {"type": if starting { "dangerFullAccess" } else { "readOnly" }}, "reasoningEffort": null})+ }+ "turn/start" => {+ let params = request.params.as_ref().unwrap();+ assert_eq!(params["input"][0]["text"], "preserved-draft!");+ assert_eq!(+ json!([+ params["approvalPolicy"],+ params["sandboxPolicy"],+ params["permissions"]+ ]),+ json!(["never", {"type": "dangerFullAccess"}, null])+ );+ json!({"turn": {"id": "fresh", "items": [], "status": "inProgress", "error": null}})}"thread/read" => json!({"thread": thread}),"thread/goal/get" => json!({"goal": null}),@@ -132,6 +174,9 @@ async fn automatic_reconnect_restores_draft_and_routes_new_notifications() -> Re.into(),)).await?;+ if request.method == "turn/start" {+ submitted_tx.take().unwrap().send(()).unwrap();+ }if connection == 6 && request.method == "thread/resume" {// Keep the recovered turn running: its output must appear without waiting// for turn/completed or rebuilding the transcript.@@ -152,7 +197,8 @@ async fn automatic_reconnect_restores_draft_and_routes_new_notifications() -> Re}Ok::<_, anyhow::Error>(methods)});- let mut terminal = PtyCodex::start(&repo_root, codex_home, &["--no-alt-screen"])?;+ let mut terminal =+ PtyCodex::start(&workspace_path, codex_home, &["--yolo", "--no-alt-screen"])?;terminal.wait_for_startup()?;let mut disconnect_tx = Some(disconnect_tx);let mut restore_tx = Some(restore_tx);@@ -199,6 +245,10 @@ async fn automatic_reconnect_restores_draft_and_routes_new_notifications() -> Re"draft and notification did not remain visible after recovery; screen:\n{}",terminal.screen_contents());+ complete_tx.send(()).unwrap();+ terminal.wait_for_screen("Recovered turn completed.")?;+ terminal.write_input(b"\r")?;+ tokio::time::timeout(Duration::from_secs(/*secs*/ 10), submitted_rx).await??;drop(terminal);let methods = tokio::time::timeout(Duration::from_secs(/*secs*/ 5), server).await???;assert_eq!(@@ -208,6 +258,12 @@ async fn automatic_reconnect_restores_draft_and_routes_new_notifications() -> Re.count(),6);- assert!(!methods.iter().any(|method| method == "turn/start"));+ assert_eq!(+ methods+ .iter()+ .filter(|method| *method == "turn/start")+ .count(),+ 1+ );Ok(())}