Lightweight coding agent that runs in your terminal
Rust
Allow stdin review under active grants with sandbox prompts disabled (#54119)
Oliver Tepmand292f721242e
diff --git a/codex-rs/core/src/tools/approvals.rs b/codex-rs/core/src/tools/approvals.rsindex 2052f5948c..7840013fe3 100644--- a/codex-rs/core/src/tools/approvals.rs+++ b/codex-rs/core/src/tools/approvals.rs@@ -86,6 +86,8 @@ pub(crate) enum ApprovalAction {tty: bool,sandbox_permissions: SandboxPermissions,additional_permissions: Option<AdditionalPermissionProfile>,+ #[serde(skip)]+ additional_permissions_preapproved: bool,},ApplyPatch {id: String,@@ -167,6 +169,7 @@ impl ApprovalAction {tty,sandbox_permissions,additional_permissions,+ additional_permissions_preapproved: _,} => PermissionRequestPayload {tool_name: HookToolName::new("write_stdin"),tool_input: serde_json::json!({@@ -299,6 +302,7 @@ impl ApprovalAction {tty,sandbox_permissions,additional_permissions,+ additional_permissions_preapproved: _,} => crate::guardian::GuardianApprovalRequest::WriteStdin {id,approval_id,@@ -449,11 +453,12 @@ impl Session {action: ApprovalAction,ctx: ApprovalContext,) -> ApprovalResult {- // Stdin that exceeds current permissions needs a fresh sandbox approval.- // Strict review of ordinary input follows the same routing as ordinary exec.+ // Retained authority outside current grants needs a new sandbox approval.+ // Current grants permit review of the input; they never approve the input itself.let policy = ctx.review_context.turn().approval_policy();- if matches!(&action, ApprovalAction::WriteStdin { sandbox_permissions, .. }- if sandbox_permissions.requests_sandbox_override())+ if matches!(&action, ApprovalAction::WriteStdin { sandbox_permissions, additional_permissions_preapproved, .. }+ if sandbox_permissions.requests_sandbox_override()+ && (!additional_permissions_preapproved || matches!(policy, AskForApproval::Never)))&& !(ctx.strict_auto_review && matches!(policy, AskForApproval::Never))&& let Some(reason) =prompt_is_rejected_by_policy(policy, /*prompt_is_rule*/ false)diff --git a/codex-rs/core/src/unified_exec/stdin_approval.rs b/codex-rs/core/src/unified_exec/stdin_approval.rsindex 646ea8ec9b..35d3e363d2 100644--- a/codex-rs/core/src/unified_exec/stdin_approval.rs+++ b/codex-rs/core/src/unified_exec/stdin_approval.rs@@ -20,6 +20,7 @@ use codex_protocol::models::AdditionalPermissionProfile;use codex_protocol::models::PermissionProfile;use codex_protocol::models::SandboxPermissions;use codex_protocol::permissions::NetworkSandboxPolicy;+use codex_protocol::protocol::AskForApproval;use codex_sandboxing::policy_transforms::effective_permission_profile;use codex_sandboxing::policy_transforms::merge_permission_profiles;@@ -237,6 +238,39 @@ impl ProcessEntry {let reason = permissions.approval_reason(sandbox_permissions).map_err(approval_error)?;+ // A scoped grant can authorize retained authority without permitting new+ // sandbox escalations. Still review every input, and only recognize grants+ // that remain active for this terminal's environment with the same policy.+ let additional_permissions_preapproved = matches!(+ context.step_context.turn.approval_policy(),+ AskForApproval::Granular(policy) if !policy.sandbox_approval+ ) && sandbox_permissions+ == SandboxPermissions::WithAdditionalPermissions+ && permissions+ .additional_permissions+ .as_ref()+ .zip(+ context+ .step_context+ .turn+ .granted_permissions(&self.environment_id),+ )+ .is_some_and(|(retained, current_grants)| {+ // Root containment does not prove filesystem coverage: child+ // restrictions, protected metadata, and symlinks can differ.+ // Require the original filesystem grants, including their order.+ retained.file_system == current_grants.file_system+ && (retained+ .network+ .as_ref()+ .and_then(|network| network.enabled)+ != Some(true)+ || current_grants+ .network+ .as_ref()+ .and_then(|network| network.enabled)+ == Some(true))+ });let action = ApprovalAction::WriteStdin {id: self.call_id.clone(),approval_id: context.call_id.clone(),@@ -247,6 +281,7 @@ impl ProcessEntry {tty: self.tty,sandbox_permissions,additional_permissions: permissions.additional_permissions.clone(),+ additional_permissions_preapproved,};Ok(Some((action, reason)))}diff --git a/codex-rs/core/tests/suite/unified_exec_stdin_approval.rs b/codex-rs/core/tests/suite/unified_exec_stdin_approval.rsindex 705eccf35e..ad945521e2 100644--- a/codex-rs/core/tests/suite/unified_exec_stdin_approval.rs+++ b/codex-rs/core/tests/suite/unified_exec_stdin_approval.rs@@ -8,6 +8,7 @@ use codex_extension_api::ExtensionRegistryBuilder;use codex_features::Feature;use codex_protocol::approvals::ExecApprovalKind;use codex_protocol::models::AdditionalPermissionProfile;+use codex_protocol::models::FileSystemPermissions;use codex_protocol::models::PermissionProfile;use codex_protocol::permissions::FileSystemAccessMode;use codex_protocol::permissions::FileSystemPath;@@ -22,6 +23,7 @@ use codex_protocol::protocol::ThreadSettingsOverrides;use codex_protocol::request_permissions::PermissionGrantScope;use codex_protocol::request_permissions::RequestPermissionsResponse;use codex_protocol::user_input::UserInput;+use core_test_support::create_directory_symlink;use core_test_support::responses::ev_assistant_message;use core_test_support::responses::ev_completed;use core_test_support::responses::ev_function_call;@@ -30,6 +32,7 @@ use core_test_support::responses::mount_sse_once;use core_test_support::responses::mount_sse_sequence;use core_test_support::responses::sse;use core_test_support::skip_if_no_network;+use core_test_support::skip_if_remote;use core_test_support::skip_if_sandbox;use core_test_support::skip_if_target_windows;use core_test_support::test_codex::TestCodexBuilder;@@ -428,3 +431,353 @@ async fn strict_stdin_review_reaches_guardian_with_sandbox_prompts_disabled() ->assert!(output.to_string().contains("STDIN_REVIEW_OK"), "{output}");Ok(())}++#[derive(Clone, Copy)]+enum StdinReviewer {+ User,+ Guardian,+}++#[derive(Clone, Copy)]+enum GrantChange {+ Unchanged,+ ReadOnlyChildExpires,+ MetadataWriteExpires,+ SymlinkWriteExpires,+ UnchangedOrderedDenies,+}++#[derive(Clone, Copy)]+enum LaterApprovalPolicy {+ Inherit,+ Never,+}++/// A grant active at launch permits later input to reach review without enabling+/// sandbox escalation, including grants with interleaved denials. Expired authority+/// beneath parent grants and Never policy must block input without delivery.+#[test_case::test_case(PermissionGrantScope::Turn, StdinReviewer::User, GrantChange::Unchanged, LaterApprovalPolicy::Inherit; "turn_grant_user_review")]+#[test_case::test_case(PermissionGrantScope::Turn, StdinReviewer::Guardian, GrantChange::Unchanged, LaterApprovalPolicy::Inherit; "turn_grant_strict_review")]+#[test_case::test_case(PermissionGrantScope::Session, StdinReviewer::User, GrantChange::Unchanged, LaterApprovalPolicy::Never; "session_grant_never_policy")]+#[test_case::test_case(PermissionGrantScope::Session, StdinReviewer::User, GrantChange::ReadOnlyChildExpires, LaterApprovalPolicy::Inherit; "read_only_child_grant_expiry")]+#[test_case::test_case(PermissionGrantScope::Session, StdinReviewer::User, GrantChange::MetadataWriteExpires, LaterApprovalPolicy::Inherit; "explicit_metadata_grant_expiry")]+#[test_case::test_case(PermissionGrantScope::Session, StdinReviewer::User, GrantChange::SymlinkWriteExpires, LaterApprovalPolicy::Inherit; "symlink_grant_expiry")]+#[test_case::test_case(PermissionGrantScope::Session, StdinReviewer::User, GrantChange::UnchangedOrderedDenies, LaterApprovalPolicy::Inherit; "unchanged_interleaved_denials")]+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn stdin_reviews_current_grants_with_sandbox_prompts_disabled(+ scope: PermissionGrantScope,+ reviewer: StdinReviewer,+ grant_change: GrantChange,+ later_policy: LaterApprovalPolicy,+) -> Result<()> {+ skip_if_target_windows!(Ok(()), "uses a POSIX interactive shell");+ skip_if_no_network!(Ok(()));+ skip_if_sandbox!(Ok(()));+ if matches!(grant_change, GrantChange::SymlinkWriteExpires) {+ skip_if_remote!(Ok(()), "creates a symlink on the local executor filesystem");+ if !cfg!(target_os = "linux") {+ eprintln!("Skipping Linux symlink grant regression on another host OS");+ return Ok(());+ }+ }+ let harness = harness(test_codex()).await?;+ let test = harness.test();+ harness.create_dir_all("allowed").await?;+ let allowed = test.workspace_path_uri("allowed")?.to_abs_path()?;+ let mut permission_profile = PermissionProfile::read_only();+ let mut grants = vec![(json!({"network":{"enabled":true}}), scope)];+ match grant_change {+ GrantChange::ReadOnlyChildExpires+ | GrantChange::MetadataWriteExpires+ | GrantChange::SymlinkWriteExpires => {+ let child = if matches!(grant_change, GrantChange::MetadataWriteExpires) {+ "allowed/.git"+ } else if matches!(grant_change, GrantChange::SymlinkWriteExpires) {+ "allowed/link"+ } else {+ "allowed/child"+ };+ if matches!(grant_change, GrantChange::SymlinkWriteExpires) {+ harness.create_dir_all("outside").await?;+ create_directory_symlink(&harness.path("outside"), &harness.path(child));+ } else {+ harness.create_dir_all(child).await?;+ }+ let child = test.workspace_path_uri(child)?.to_abs_path()?;+ if matches!(grant_change, GrantChange::ReadOnlyChildExpires) {+ let mut file_system = permission_profile.file_system_sandbox_policy();+ file_system.entries.push(FileSystemSandboxEntry::new(+ child.clone().into(),+ FileSystemAccessMode::Read,+ ));+ permission_profile = PermissionProfile::from_runtime_permissions(+ &file_system,+ NetworkSandboxPolicy::Restricted,+ );+ }+ grants = vec![+ (json!({"file_system":{"write":[allowed]}}), scope),+ (+ json!({"file_system":{"write":[child]}}),+ PermissionGrantScope::Turn,+ ),+ ];+ }+ GrantChange::UnchangedOrderedDenies => {+ harness+ .write_file("allowed/a/private/secret", "secret")+ .await?;+ harness.create_dir_all("allowed/b").await?;+ let write_a =+ FileSystemSandboxEntry::new(allowed.join("a").into(), FileSystemAccessMode::Write);+ let deny_a = FileSystemSandboxEntry::new(+ allowed.join("a/private").into(),+ FileSystemAccessMode::Deny,+ );+ let write_b =+ FileSystemSandboxEntry::new(allowed.join("b").into(), FileSystemAccessMode::Write);+ let retained = FileSystemPermissions {+ entries: vec![write_a, deny_a],+ glob_scan_max_depth: None,+ };+ let extra = FileSystemPermissions {+ entries: vec![write_b],+ glob_scan_max_depth: None,+ };+ grants = vec![+ (json!({"file_system":retained}), scope),+ (json!({"file_system":extra}), scope),+ ];+ }+ GrantChange::Unchanged => {}+ }+ let turn_grant_expires = matches!(+ grant_change,+ GrantChange::ReadOnlyChildExpires+ | GrantChange::MetadataWriteExpires+ | GrantChange::SymlinkWriteExpires+ );+ let decision = |outcome: &str| {+ sse(vec![+ ev_assistant_message(outcome, &json!({"risk_level":"low", "user_authorization":"high", "outcome":outcome, "rationale":"stdin grant test"}).to_string()),+ ev_completed(outcome),+ ])+ };+ let mut responses = Vec::new();+ for (id, (permissions, _)) in ["grant", "extra_grant"].into_iter().zip(&grants) {+ responses.push(tool_response(+ id,+ "request_permissions",+ json!({"reason":"allow terminal access", "permissions":permissions}),+ ));+ }+ responses.push(tool_response(+ "open",+ "exec_command",+ json!({"cmd":"/bin/bash --noprofile --norc", "tty":true, "yield_time_ms":200}),+ ));+ if matches!(reviewer, StdinReviewer::Guardian) {+ responses.push(decision("allow"));+ }+ let grant_probe = match grant_change {+ GrantChange::ReadOnlyChildExpires => "printf launch > allowed/child/launched && ",+ GrantChange::MetadataWriteExpires => "printf launch > allowed/.git/launched && ",+ GrantChange::SymlinkWriteExpires => "printf launch > allowed/link/launched && ",+ GrantChange::UnchangedOrderedDenies => {+ "printf launch > allowed/a/launched && printf launch > allowed/b/launched && ! cat allowed/a/private/secret && "+ }+ GrantChange::Unchanged => "",+ };+ responses.push(tool_response("allowed", "write_stdin", json!({"session_id":1000, "chars":format!("{grant_probe}printf 'CURRENT_%s_OK\\n' GRANT\n")})));+ if matches!(reviewer, StdinReviewer::Guardian) {+ responses.push(decision("allow"));+ }+ responses.push(sse(vec![ev_completed("done")]));+ let writes = mount_sse_sequence(harness.server(), responses).await;+ test.codex+ .start_or_steer_turn(+ TurnInputRequest::user_input(vec![UserInput::Text {+ text: "grant permission, open a terminal, and send reviewed input".into(),+ text_elements: Vec::new(),+ }])+ .with_thread_settings(ThreadSettingsOverrides {+ permission_profile: Some(permission_profile),+ approval_policy: Some(AskForApproval::Granular(GranularApprovalConfig {+ sandbox_approval: false,+ rules: false,+ skill_approval: true,+ request_permissions: true,+ mcp_elicitations: false,+ })),+ ..Default::default()+ }),+ )+ .await?;+ let mut grant_scopes = grants.into_iter().map(|(_, scope)| scope);+ let mut approvals = 0;+ loop {+ match wait_for_event(&test.codex, |_| true).await {+ EventMsg::RequestPermissions(request) => {+ test.codex+ .submit(Op::RequestPermissionsResponse {+ id: request.call_id,+ response: RequestPermissionsResponse {+ permissions: request.permissions,+ scope: grant_scopes.next().expect("requested grant"),+ strict_auto_review: matches!(reviewer, StdinReviewer::Guardian),+ },+ })+ .await?;+ }+ EventMsg::ExecApprovalRequest(request) => {+ assert!(matches!(reviewer, StdinReviewer::User));+ assert_eq!(+ (request.kind, request.effective_approval_id()),+ (ExecApprovalKind::WriteStdin, "allowed".to_string())+ );+ approvals += 1;+ test.codex+ .submit(Op::ExecApproval {+ id: request.effective_approval_id(),+ turn_id: Some(request.turn_id),+ decision: ReviewDecision::Approved,+ })+ .await?;+ }+ EventMsg::TurnComplete(_) => break,+ _ => {}+ }+ }+ assert_eq!(grant_scopes.next(), None);+ assert_eq!(+ approvals,+ usize::from(matches!(reviewer, StdinReviewer::User))+ );+ let output = writes+ .function_call_output_text("allowed")+ .expect("stdin output");+ assert!(output.contains("CURRENT_GRANT_OK"), "{output}");+ if matches!(reviewer, StdinReviewer::Guardian) {+ assert_eq!(+ writes+ .requests()+ .iter()+ .filter(|request| request.body_contains_text("Planned action JSON:"))+ .count(),+ 2+ );+ return Ok(());+ }++ let later = mount_function_call_agent_response(+ harness.server(),+ "later",+ &json!({"session_id":1000, "chars":"LATER=1; printf 'LATER_%s_OK\\n' GRANT\n"}).to_string(),+ "write_stdin",+ )+ .await;+ test.codex+ .start_or_steer_turn(+ TurnInputRequest::user_input(vec![UserInput::Text {+ text: "send input in a later turn".into(),+ text_elements: Vec::new(),+ }])+ .with_thread_settings(ThreadSettingsOverrides {+ approval_policy: match later_policy {+ LaterApprovalPolicy::Inherit => None,+ LaterApprovalPolicy::Never => Some(AskForApproval::Never),+ },+ ..Default::default()+ }),+ )+ .await?;+ let later_input_allowed = matches!(scope, PermissionGrantScope::Session)+ && !turn_grant_expires+ && matches!(later_policy, LaterApprovalPolicy::Inherit);+ let mut later_approvals = 0;+ loop {+ match wait_for_event(&test.codex, |_| true).await {+ EventMsg::ExecApprovalRequest(request) => {+ assert!(later_input_allowed, "unexpected stdin review: {request:?}");+ assert_eq!(+ (request.kind, request.effective_approval_id()),+ (ExecApprovalKind::WriteStdin, "later".to_string())+ );+ later_approvals += 1;+ test.codex+ .submit(Op::ExecApproval {+ id: request.effective_approval_id(),+ turn_id: Some(request.turn_id),+ decision: ReviewDecision::Approved,+ })+ .await?;+ }+ EventMsg::TurnComplete(_) => break,+ _ => {}+ }+ }+ assert_eq!(later_approvals, usize::from(later_input_allowed));+ let output = later+ .completion+ .function_call_output_text("later")+ .expect("later stdin output");+ if matches!(later_policy, LaterApprovalPolicy::Never) {+ assert!(+ output.contains("AskForApproval is set to Never"),+ "{output}"+ );+ } else if later_input_allowed {+ assert!(output.contains("LATER_GRANT_OK"), "{output}");+ } else {+ assert!(+ output.contains("AskForApproval::Granular.sandbox_approval is false"),+ "{output}"+ );+ }+ if !later_input_allowed {+ let probe = mount_function_call_agent_response(+ harness.server(),+ "probe",+ &json!({"session_id":1000, "chars":"test -z \"${LATER-}\" && printf 'REJECTED_%s_OK\\n' INPUT; exit\n"}).to_string(),+ "write_stdin",+ )+ .await;+ test.codex+ .start_or_steer_turn(+ TurnInputRequest::user_input(vec![UserInput::Text {+ text: "verify rejected input was not delivered".into(),+ text_elements: Vec::new(),+ }])+ .with_thread_settings(ThreadSettingsOverrides {+ approval_policy: Some(AskForApproval::OnRequest),+ ..Default::default()+ }),+ )+ .await?;+ loop {+ match wait_for_event(&test.codex, |_| true).await {+ EventMsg::ExecApprovalRequest(request) => {+ assert_eq!(+ (request.kind, request.effective_approval_id()),+ (ExecApprovalKind::WriteStdin, "probe".to_string())+ );+ test.codex+ .submit(Op::ExecApproval {+ id: request.effective_approval_id(),+ turn_id: Some(request.turn_id),+ decision: ReviewDecision::Approved,+ })+ .await?;+ }+ EventMsg::TurnComplete(_) => break,+ _ => {}+ }+ }+ let output = probe+ .completion+ .function_call_output_text("probe")+ .expect("probe output");+ assert!(output.contains("REJECTED_INPUT_OK"), "{output}");+ }+ Ok(())+}