Preserve executor paths in Guardian approval reviews (#42838)

## Why

Guardian approval actions can contain paths from a remote executor whose path convention differs from the host, such as Windows paths reviewed on a POSIX host. Converting those paths to host-native absolute paths prevents the action from being reviewed.

## What changed

- Render command working directories using the executor's reported path convention, and preserve URI-backed paths for attribution.
- Carry foreign command and patch paths through Guardian events and app-server schemas as legacy path strings.
- Bound remote plugin attribution within the overall review deadline and reject Guardian action payloads that exceed the review byte limit.

## Testing

- Cover Windows and POSIX executor path rendering, foreign patch paths, protocol round trips, oversized payload rejection, and remote Guardian review context.

GitOrigin-RevId: 38be0fcdac897139519e74e077eb5cb4f8f8017e
This commit is contained in:
iceweasel-oai authored and copyberry committed 2026-09-04 19:56:31 +00:00
1 parent 83b62a02fa
commit 773f0b081d
27 files changed
+442 -203

No files matched your search

+57 -23
View File
@@ -1,3 +1,4 @@
#[cfg(unix)]
use std::path::Path;
use codex_analytics::GuardianReviewedAction;
@@ -6,12 +7,15 @@ use codex_protocol::approvals::GuardianCommandSource;
use codex_protocol::approvals::NetworkApprovalProtocol;
use codex_protocol::models::AdditionalPermissionProfile;
use codex_protocol::request_permissions::RequestPermissionProfile;
#[cfg(unix)]
use codex_utils_absolute_path::AbsolutePathBuf;
use codex_utils_path_uri::LegacyAppPathString;
use codex_utils_path_uri::PathUri;
use serde::Serialize;
use serde::ser::Error as _;
use serde_json::Value;
use super::GUARDIAN_MAX_ACTION_BYTES;
use super::GUARDIAN_MAX_ACTION_STRING_TOKENS;
use super::prompt::guardian_truncate_text;
@@ -19,8 +23,11 @@ use super::prompt::guardian_truncate_text;
pub(crate) enum GuardianApprovalRequest {
ExecCommand {
id: String,
environment_id: String,
command: Vec<String>,
cwd: AbsolutePathBuf,
cwd: PathUri,
/// Executor-native rendering sent to Guardian; `cwd` remains typed for attribution.
guardian_cwd: LegacyAppPathString,
sandbox_permissions: crate::sandboxing::SandboxPermissions,
additional_permissions: Option<AdditionalPermissionProfile>,
justification: Option<String>,
@@ -48,8 +55,8 @@ pub(crate) enum GuardianApprovalRequest {
},
ApplyPatch {
id: String,
cwd: AbsolutePathBuf,
files: Vec<AbsolutePathBuf>,
cwd: PathUri,
files: Vec<PathUri>,
patch: String,
},
NetworkAccess {
@@ -112,7 +119,7 @@ pub(crate) struct GuardianMcpAnnotations {
struct CommandApprovalAction<'a> {
tool: &'a str,
command: &'a [String],
cwd: &'a Path,
cwd: LegacyAppPathString,
sandbox_permissions: crate::sandboxing::SandboxPermissions,
#[serde(skip_serializing_if = "Option::is_none")]
additional_permissions: Option<&'a AdditionalPermissionProfile>,
@@ -122,6 +129,14 @@ struct CommandApprovalAction<'a> {
tty: Option<bool>,
}
#[derive(Serialize)]
struct ApplyPatchApprovalAction<'a> {
tool: &'static str,
cwd: LegacyAppPathString,
files: Vec<LegacyAppPathString>,
patch: &'a str,
}
#[derive(Serialize)]
struct WriteStdinApprovalAction<'a> {
tool: &'static str,
@@ -197,7 +212,7 @@ fn serialize_guardian_action(value: impl Serialize) -> serde_json::Result<Value>
fn serialize_command_guardian_action(
tool: &'static str,
command: &[String],
cwd: &Path,
cwd: LegacyAppPathString,
sandbox_permissions: crate::sandboxing::SandboxPermissions,
additional_permissions: Option<&AdditionalPermissionProfile>,
justification: Option<&String>,
@@ -217,7 +232,7 @@ fn serialize_command_guardian_action(
fn command_assessment_action(
source: GuardianCommandSource,
command: &[String],
cwd: &AbsolutePathBuf,
cwd: &LegacyAppPathString,
) -> GuardianAssessmentAction {
GuardianAssessmentAction::Command {
source,
@@ -283,8 +298,10 @@ pub(crate) fn guardian_approval_request_to_json(
match action {
GuardianApprovalRequest::ExecCommand {
id: _,
environment_id: _,
command,
cwd,
cwd: _,
guardian_cwd,
sandbox_permissions,
additional_permissions,
justification,
@@ -292,7 +309,7 @@ pub(crate) fn guardian_approval_request_to_json(
} => serialize_command_guardian_action(
"exec_command",
command,
cwd,
guardian_cwd.clone(),
*sandbox_permissions,
additional_permissions.as_ref(),
justification.as_ref(),
@@ -337,12 +354,12 @@ pub(crate) fn guardian_approval_request_to_json(
cwd,
files,
patch,
} => Ok(serde_json::json!({
"tool": "apply_patch",
"cwd": cwd,
"files": files,
"patch": patch,
})),
} => serialize_guardian_action(ApplyPatchApprovalAction {
tool: "apply_patch",
cwd: cwd.clone().into(),
files: files.iter().cloned().map(Into::into).collect(),
patch,
}),
GuardianApprovalRequest::NetworkAccess {
id: _,
turn_id: _,
@@ -408,9 +425,11 @@ pub(crate) fn guardian_assessment_action(
action: &GuardianApprovalRequest,
) -> GuardianAssessmentAction {
match action {
GuardianApprovalRequest::ExecCommand { command, cwd, .. } => {
command_assessment_action(GuardianCommandSource::UnifiedExec, command, cwd)
}
GuardianApprovalRequest::ExecCommand {
command,
guardian_cwd,
..
} => command_assessment_action(GuardianCommandSource::UnifiedExec, command, guardian_cwd),
GuardianApprovalRequest::WriteStdin {
approval_id,
process_id,
@@ -438,8 +457,8 @@ pub(crate) fn guardian_assessment_action(
},
GuardianApprovalRequest::ApplyPatch { cwd, files, .. } => {
GuardianAssessmentAction::ApplyPatch {
cwd: cwd.clone(),
files: files.clone(),
cwd: cwd.clone().into(),
files: files.iter().cloned().map(Into::into).collect(),
}
}
GuardianApprovalRequest::NetworkAccess {
@@ -570,8 +589,23 @@ pub(crate) fn format_guardian_action_pretty(
) -> serde_json::Result<FormattedGuardianAction> {
let value = guardian_approval_request_to_json(action)?;
let (value, truncated) = truncate_guardian_action_value(value);
Ok(FormattedGuardianAction {
text: serde_json::to_string_pretty(&value)?,
truncated,
})
let text = enforce_guardian_action_byte_limit(serde_json::to_string_pretty(&value)?)?;
Ok(FormattedGuardianAction { text, truncated })
}
fn enforce_guardian_action_byte_limit(text: String) -> serde_json::Result<String> {
if text.len() > GUARDIAN_MAX_ACTION_BYTES {
return Err(serde_json::Error::custom(format!(
"Guardian action exceeds the {GUARDIAN_MAX_ACTION_BYTES}-byte review limit"
)));
}
Ok(text)
}
pub(crate) fn format_guardian_action_compact(
action: &GuardianApprovalRequest,
) -> serde_json::Result<String> {
enforce_guardian_action_byte_limit(serde_json::to_string(&guardian_approval_request_to_json(
action,
)?)?)
}
+1
View File
@@ -74,6 +74,7 @@ const GUARDIAN_MAX_TOOL_TRANSCRIPT_TOKENS: usize = 10_000;
const GUARDIAN_MAX_MESSAGE_ENTRY_TOKENS: usize = 5_000;
const GUARDIAN_MAX_TOOL_ENTRY_TOKENS: usize = 1_000;
pub(crate) const GUARDIAN_MAX_NODE_REPL_TOOL_RESULT_TOKENS: usize = 6_000;
pub(crate) const GUARDIAN_MAX_ACTION_BYTES: usize = 8_000;
const GUARDIAN_MAX_ACTION_STRING_TOKENS: usize = 16_000;
const GUARDIAN_RECENT_ENTRY_LIMIT: usize = 40;
+111 -20
View File
@@ -31,6 +31,7 @@ use codex_protocol::protocol::TurnAbortReason;
use codex_protocol::protocol::WarningEvent;
use futures::future::BoxFuture;
use std::sync::Arc;
use std::time::Duration;
use tokio::sync::oneshot;
use tokio::time::Instant;
use tokio::time::sleep_until;
@@ -53,8 +54,8 @@ use super::GuardianAssessmentOutcome;
use super::GuardianRejectionCircuitBreakerAction;
use super::GuardianRejectionCircuitBreakerPolicy;
use super::GuardianReviewContext;
use super::approval_request::format_guardian_action_compact;
use super::approval_request::format_guardian_action_pretty;
use super::approval_request::guardian_approval_request_to_json;
use super::approval_request::guardian_assessment_action;
use super::approval_request::guardian_request_target_item_id;
use super::approval_request::guardian_request_turn_id;
@@ -81,14 +82,36 @@ const GUARDIAN_TIMEOUT_INSTRUCTIONS: &str = concat!(
);
const GUARDIAN_REVIEW_MAX_ATTEMPTS: i64 = 3;
const GUARDIAN_PLUGIN_ATTRIBUTION_TIMEOUT: Duration = Duration::from_secs(5);
fn plugin_attribution_for_guardian_request(
turn: &TurnContext,
async fn plugin_attribution_for_guardian_request(
context: &GuardianReviewContext,
request: &GuardianApprovalRequest,
) -> Option<PluginCommandAttribution> {
let turn = context.turn();
match request {
GuardianApprovalRequest::ExecCommand { command, cwd, .. } => {
turn.plugin_attribution_for_command(command, cwd)
GuardianApprovalRequest::ExecCommand {
environment_id,
command,
cwd,
..
} => {
let turn_environment =
context
.environments()
.turn_environments()
.find(|environment| {
environment.selection.environment_id.as_str() == environment_id
})?;
if turn_environment.environment.is_remote() {
let file_system = turn_environment.environment.get_filesystem();
turn.plugin_attribution_for_executor_command(command, cwd, file_system.as_ref())
.await
} else {
cwd.to_abs_path()
.ok()
.and_then(|cwd| turn.plugin_attribution_for_command(command, &cwd))
}
}
#[cfg(unix)]
GuardianApprovalRequest::Execve {
@@ -364,14 +387,14 @@ async fn run_guardian_review(
.external_cancel
.as_ref()
.is_none_or(|cancel| !cancel.is_cancelled())
&& let Ok(action) = guardian_approval_request_to_json(&request)
&& let Ok(action) = format_guardian_action_compact(&request)
&& let Some(decision) = session
.services
.extensions
.fast_approval_decision(
&session.services.session_extension_data,
&session.services.thread_extension_data,
&action.to_string(),
&action,
Some(crate::session::extension_metrics::from_session_telemetry(
turn.session_telemetry.clone(),
)),
@@ -440,10 +463,41 @@ pub(super) async fn run_synchronous_review(
external_cancel,
require_synchronous_review: _,
} = options;
// Bound executor attribution and the Guardian session with one review deadline.
let deadline = Instant::now() + GUARDIAN_REVIEW_TIMEOUT;
let target_item_id = guardian_request_target_item_id(&request).map(str::to_string);
let assessment_turn_id = guardian_request_turn_id(&request, &turn.sub_id).to_string();
let plugin_attribution = plugin_attribution_override
.or_else(|| plugin_attribution_for_guardian_request(turn.as_ref(), &request));
let plugin_attribution = match plugin_attribution_override {
Some(attribution) => Some(attribution),
None if matches!(&request, GuardianApprovalRequest::ExecCommand { .. }) => {
let cancellation = external_cancel
.clone()
.unwrap_or_else(CancellationToken::new);
let attribution_deadline = std::cmp::min(
deadline,
Instant::now() + GUARDIAN_PLUGIN_ATTRIBUTION_TIMEOUT,
);
let attribution = tokio::select! {
biased;
_ = cancellation.cancelled() => return ReviewDecision::Abort,
attribution = tokio::time::timeout_at(
attribution_deadline,
plugin_attribution_for_guardian_request(&context, &request),
) => attribution,
};
match attribution {
Ok(attribution) => attribution,
Err(_) => {
tracing::warn!(
timeout_ms = GUARDIAN_PLUGIN_ATTRIBUTION_TIMEOUT.as_millis(),
"Guardian plugin attribution timed out"
);
None
}
}
}
None => plugin_attribution_for_guardian_request(&context, &request).await,
};
let (plugin_id, script_path) = plugin_attribution
.as_ref()
.map(PluginCommandAttribution::serialized_fields)
@@ -551,16 +605,20 @@ pub(super) async fn run_synchronous_review(
} else {
None
};
let (mut outcome, analytics_result) = Box::pin(run_guardian_review_session_with_retry(
session.clone(),
context,
request,
reasons,
schema,
external_cancel,
GUARDIAN_REVIEW_MAX_ATTEMPTS,
))
.await;
let (mut outcome, analytics_result) =
Box::pin(run_guardian_review_session_with_retry_before_deadline(
session.clone(),
context,
request,
reasons,
schema,
external_cancel,
GuardianReviewSessionLimits {
max_attempts: GUARDIAN_REVIEW_MAX_ATTEMPTS,
deadline,
},
))
.await;
if session.enabled(Feature::GuardianThreadContext)
&& matches!(&outcome, GuardianReviewOutcome::Completed(assessment) if assessment.outcome == GuardianAssessmentOutcome::Allow)
&& root_authorization_version
@@ -1127,6 +1185,7 @@ async fn run_guardian_review_session_before_deadline(
}
}
#[cfg(test)]
pub(super) async fn run_guardian_review_session_with_retry(
session: Arc<Session>,
context: impl Into<GuardianReviewContext>,
@@ -1136,9 +1195,41 @@ pub(super) async fn run_guardian_review_session_with_retry(
external_cancel: Option<CancellationToken>,
max_attempts: i64,
) -> (GuardianReviewOutcome, GuardianReviewAnalyticsResult) {
run_guardian_review_session_with_retry_before_deadline(
session,
context,
request,
reasons,
schema,
external_cancel,
GuardianReviewSessionLimits {
max_attempts,
deadline: Instant::now() + GUARDIAN_REVIEW_TIMEOUT,
},
)
.await
}
struct GuardianReviewSessionLimits {
max_attempts: i64,
deadline: Instant,
}
async fn run_guardian_review_session_with_retry_before_deadline(
session: Arc<Session>,
context: impl Into<GuardianReviewContext>,
request: GuardianApprovalRequest,
reasons: ApprovalRequestReasons,
schema: serde_json::Value,
external_cancel: Option<CancellationToken>,
limits: GuardianReviewSessionLimits,
) -> (GuardianReviewOutcome, GuardianReviewAnalyticsResult) {
let GuardianReviewSessionLimits {
max_attempts,
deadline,
} = limits;
let context = context.into();
assert!(max_attempts > 0, "guardian review must run at least once");
let deadline = Instant::now() + GUARDIAN_REVIEW_TIMEOUT;
let mut attempt_count = 1;
loop {
let (outcome, mut analytics_result) = run_guardian_review_session_before_deadline(
@@ -103,8 +103,10 @@ async fn test_review_params() -> GuardianReviewSessionParams {
node_repl_policy: GuardianNodeReplPolicy::from_model_messages(/*messages*/ None),
request: GuardianApprovalRequest::ExecCommand {
id: "shell-1".to_string(),
environment_id: codex_exec_server::LOCAL_ENVIRONMENT_ID.to_string(),
command: vec!["git".to_string(), "status".to_string()],
cwd,
cwd: cwd.clone().into(),
guardian_cwd: codex_utils_path_uri::LegacyAppPathString::from_abs_path(&cwd),
sandbox_permissions: crate::sandboxing::SandboxPermissions::UseDefault,
additional_permissions: None,
justification: Some("Inspect repo state.".to_string()),
+155 -49
View File
@@ -7,6 +7,7 @@ use crate::config::NetworkProxySpec;
use crate::config::PermissionProfileSnapshot;
use crate::config::test_config;
use crate::environment_selection::TurnEnvironmentState;
use crate::guardian::approval_request::format_guardian_action_compact;
use crate::guardian::approval_request::guardian_request_target_item_id;
use crate::guardian::prompt::BUNDLED_GUARDIAN_POLICY;
use crate::guardian::prompt::BUNDLED_GUARDIAN_POLICY_TEMPLATE;
@@ -64,6 +65,7 @@ use codex_protocol::protocol::GuardianRiskLevel;
use codex_protocol::protocol::GuardianUserAuthorization;
use codex_protocol::protocol::ReviewDecision;
use codex_protocol::protocol::TurnCompleteEvent;
use codex_utils_path_uri::LegacyAppPathString;
use codex_utils_path_uri::PathUri;
use core_test_support::PathBufExt;
use core_test_support::TempDirExt;
@@ -289,11 +291,17 @@ async fn guardian_test_session_turn_and_rx(
(session, turn, rx)
}
fn native_guardian_cwd(path: &str) -> LegacyAppPathString {
LegacyAppPathString::from_abs_path(&test_path_buf(path).abs())
}
fn guardian_exec_command_request(id: &str) -> GuardianApprovalRequest {
GuardianApprovalRequest::ExecCommand {
id: id.to_string(),
environment_id: codex_exec_server::LOCAL_ENVIRONMENT_ID.to_string(),
command: vec!["git".to_string(), "push".to_string()],
cwd: test_path_buf("/repo/codex-rs/core").abs(),
cwd: test_path_buf("/repo/codex-rs/core").abs().into(),
guardian_cwd: native_guardian_cwd("/repo/codex-rs/core"),
sandbox_permissions: crate::sandboxing::SandboxPermissions::UseDefault,
additional_permissions: None,
justification: Some("Need to push the reviewed docs fix.".to_string()),
@@ -508,8 +516,10 @@ async fn build_guardian_prompt_full_mode_preserves_initial_review_format() -> an
Some("Sandbox denied outbound git push to github.com.".to_string()),
GuardianApprovalRequest::ExecCommand {
id: "shell-1".to_string(),
environment_id: codex_exec_server::LOCAL_ENVIRONMENT_ID.to_string(),
command: vec!["git".to_string(), "push".to_string()],
cwd: test_path_buf("/repo/codex-rs/core").abs(),
cwd: test_path_buf("/repo/codex-rs/core").abs().into(),
guardian_cwd: native_guardian_cwd("/repo/codex-rs/core"),
sandbox_permissions: crate::sandboxing::SandboxPermissions::UseDefault,
additional_permissions: None,
justification: Some("Need to push the reviewed docs fix.".to_string()),
@@ -545,8 +555,10 @@ async fn build_guardian_prompt_prefers_retry_reason_over_approval_reason() -> an
},
GuardianApprovalRequest::ExecCommand {
id: "shell-1".to_string(),
environment_id: codex_exec_server::LOCAL_ENVIRONMENT_ID.to_string(),
command: vec!["git".to_string(), "push".to_string()],
cwd: test_path_buf("/repo/codex-rs/core").abs(),
cwd: test_path_buf("/repo/codex-rs/core").abs().into(),
guardian_cwd: native_guardian_cwd("/repo/codex-rs/core"),
sandbox_permissions: crate::sandboxing::SandboxPermissions::UseDefault,
additional_permissions: None,
justification: None,
@@ -584,8 +596,10 @@ async fn build_guardian_prompt_truncates_oversized_approval_reason() -> anyhow::
},
GuardianApprovalRequest::ExecCommand {
id: "shell-1".to_string(),
environment_id: codex_exec_server::LOCAL_ENVIRONMENT_ID.to_string(),
command: vec!["git".to_string(), "push".to_string()],
cwd: test_path_buf("/repo/codex-rs/core").abs(),
cwd: test_path_buf("/repo/codex-rs/core").abs().into(),
guardian_cwd: native_guardian_cwd("/repo/codex-rs/core"),
sandbox_permissions: crate::sandboxing::SandboxPermissions::UseDefault,
additional_permissions: None,
justification: None,
@@ -675,8 +689,10 @@ async fn build_guardian_prompt_includes_parent_turn_denied_reads() -> anyhow::Re
},
GuardianApprovalRequest::ExecCommand {
id: "shell-1".to_string(),
environment_id: codex_exec_server::LOCAL_ENVIRONMENT_ID.to_string(),
command: vec!["cat".to_string(), "/repo/private/secret.txt".to_string()],
cwd: test_path_buf("/repo").abs(),
cwd: test_path_buf("/repo").abs().into(),
guardian_cwd: native_guardian_cwd("/repo"),
sandbox_permissions: crate::sandboxing::SandboxPermissions::RequireEscalated,
additional_permissions: None,
justification: Some("Need to inspect the secret file.".to_string()),
@@ -732,8 +748,10 @@ async fn build_guardian_prompt_delta_mode_preserves_original_numbering() -> anyh
/*retry_reason*/ None,
GuardianApprovalRequest::ExecCommand {
id: "shell-2".to_string(),
environment_id: codex_exec_server::LOCAL_ENVIRONMENT_ID.to_string(),
command: vec!["git".to_string(), "push".to_string()],
cwd: test_path_buf("/repo/codex-rs/core").abs(),
cwd: test_path_buf("/repo/codex-rs/core").abs().into(),
guardian_cwd: native_guardian_cwd("/repo/codex-rs/core"),
sandbox_permissions: crate::sandboxing::SandboxPermissions::UseDefault,
additional_permissions: None,
justification: Some("Need to push the second docs fix.".to_string()),
@@ -771,8 +789,10 @@ async fn build_guardian_prompt_delta_mode_handles_empty_delta() -> anyhow::Resul
/*retry_reason*/ None,
GuardianApprovalRequest::ExecCommand {
id: "shell-2".to_string(),
environment_id: codex_exec_server::LOCAL_ENVIRONMENT_ID.to_string(),
command: vec!["git".to_string(), "push".to_string()],
cwd: test_path_buf("/repo/codex-rs/core").abs(),
cwd: test_path_buf("/repo/codex-rs/core").abs().into(),
guardian_cwd: native_guardian_cwd("/repo/codex-rs/core"),
sandbox_permissions: crate::sandboxing::SandboxPermissions::UseDefault,
additional_permissions: None,
justification: Some("Need to push the second docs fix.".to_string()),
@@ -807,8 +827,10 @@ async fn build_guardian_prompt_stale_delta_cursor_falls_back_to_full_prompt() ->
/*retry_reason*/ None,
GuardianApprovalRequest::ExecCommand {
id: "shell-3".to_string(),
environment_id: codex_exec_server::LOCAL_ENVIRONMENT_ID.to_string(),
command: vec!["git".to_string(), "push".to_string()],
cwd: test_path_buf("/repo/codex-rs/core").abs(),
cwd: test_path_buf("/repo/codex-rs/core").abs().into(),
guardian_cwd: native_guardian_cwd("/repo/codex-rs/core"),
sandbox_permissions: crate::sandboxing::SandboxPermissions::UseDefault,
additional_permissions: None,
justification: Some("Need to push the docs fix.".to_string()),
@@ -893,8 +915,10 @@ async fn build_guardian_prompt_stale_delta_version_falls_back_to_full_prompt() -
/*retry_reason*/ None,
GuardianApprovalRequest::ExecCommand {
id: "shell-4".to_string(),
environment_id: codex_exec_server::LOCAL_ENVIRONMENT_ID.to_string(),
command: vec!["git".to_string(), "push".to_string()],
cwd: test_path_buf("/repo/codex-rs/core").abs(),
cwd: test_path_buf("/repo/codex-rs/core").abs().into(),
guardian_cwd: native_guardian_cwd("/repo/codex-rs/core"),
sandbox_permissions: crate::sandboxing::SandboxPermissions::UseDefault,
additional_permissions: None,
justification: Some("Need to push after the compaction.".to_string()),
@@ -1199,22 +1223,26 @@ fn guardian_truncate_text_keeps_prefix_suffix_and_xml_marker() {
}
#[test]
fn format_guardian_action_pretty_truncates_large_string_fields() -> serde_json::Result<()> {
let patch = "line\n".repeat(100_000);
fn guardian_action_formatters_reject_large_aggregate_payloads() {
let file: PathUri = test_path_buf("/tmp/file").abs().into();
let action = GuardianApprovalRequest::ApplyPatch {
id: "patch-1".to_string(),
cwd: test_path_buf("/tmp").abs(),
files: Vec::new(),
patch: patch.clone(),
cwd: test_path_buf("/tmp").abs().into(),
files: vec![file; 1_000],
patch: String::new(),
};
let rendered = format_guardian_action_pretty(&action)?;
assert!(rendered.text.contains("\"tool\": \"apply_patch\""));
assert!(rendered.text.contains("<truncated omitted_approx_tokens="));
assert!(rendered.text.len() < patch.len());
assert!(rendered.truncated);
Ok(())
for error in [
format_guardian_action_pretty(&action).map(|_| ()),
format_guardian_action_compact(&action).map(|_| ()),
] {
assert_eq!(
error
.expect_err("aggregate action should exceed the review limit")
.to_string(),
"Guardian action exceeds the 8000-byte review limit"
);
}
}
#[test]
@@ -1222,7 +1250,7 @@ fn format_guardian_action_pretty_reports_no_truncation_for_small_payload() -> se
{
let action = GuardianApprovalRequest::ApplyPatch {
id: "patch-1".to_string(),
cwd: test_path_buf("/tmp").abs(),
cwd: test_path_buf("/tmp").abs().into(),
files: Vec::new(),
patch: "line\n".to_string(),
};
@@ -1520,26 +1548,80 @@ fn guardian_write_stdin_preserves_input_and_foreign_cwd(
Ok(())
}
#[test_case::test_case(codex_utils_path_uri::PathConvention::Windows, r"C:\workspace"; "windows")]
#[test_case::test_case(codex_utils_path_uri::PathConvention::Posix, "/C:/workspace"; "posix")]
fn guardian_exec_command_uses_executor_cwd_convention(
cwd_convention: codex_utils_path_uri::PathConvention,
expected_cwd: &str,
) -> serde_json::Result<()> {
let cwd = PathUri::parse("file:///C:/workspace").expect("valid executor cwd");
let action = crate::tools::sandboxing::ApprovalAction::ExecCommand {
id: "command-1".to_string(),
environment_id: codex_exec_server::REMOTE_ENVIRONMENT_ID.to_string(),
command: vec!["git".to_string(), "status".to_string()],
hook_command: "git status".to_string(),
cwd,
sandbox_permissions: SandboxPermissions::UseDefault,
additional_permissions: None,
justification: None,
tty: false,
proposed_execpolicy_amendment: None,
}
.into_guardian_request(Some(cwd_convention))
.expect("Guardian request should render executor cwd");
assert_eq!(
guardian_approval_request_to_json(&action)?,
serde_json::json!({
"tool": "exec_command",
"command": ["git", "status"],
"cwd": expected_cwd,
"sandbox_permissions": "use_default",
"tty": false,
}),
);
assert_eq!(
guardian_assessment_action(&action),
GuardianAssessmentAction::Command {
source: codex_protocol::approvals::GuardianCommandSource::UnifiedExec,
command: "git status".to_string(),
cwd: LegacyAppPathString::from_string(expected_cwd),
},
);
Ok(())
}
#[test]
fn guardian_assessment_action_redacts_apply_patch_patch_text() {
let cwd = test_path_buf("/tmp").abs();
let file = test_path_buf("/tmp/guardian.txt").abs();
fn guardian_apply_patch_preserves_foreign_paths_and_redacts_patch_text() -> serde_json::Result<()> {
let cwd = PathUri::parse("file:///C:/workspace").expect("valid executor cwd");
let file =
PathUri::parse("file:///C:/workspace/guardian.txt").expect("valid executor file path");
let patch = "*** Begin Patch\n*** Update File: guardian.txt\n@@\n+secret\n*** End Patch";
let action = GuardianApprovalRequest::ApplyPatch {
id: "patch-1".to_string(),
cwd: cwd.clone(),
files: vec![file.clone()],
patch: "*** Begin Patch\n*** Update File: guardian.txt\n@@\n+secret\n*** End Patch"
.to_string(),
cwd,
files: vec![file],
patch: patch.to_string(),
};
assert_eq!(
serde_json::to_value(guardian_assessment_action(&action)).expect("serialize action"),
guardian_approval_request_to_json(&action)?,
serde_json::json!({
"type": "apply_patch",
"cwd": cwd,
"files": [file],
"tool": "apply_patch",
"cwd": r"C:\workspace",
"files": [r"C:\workspace\guardian.txt"],
"patch": patch,
}),
);
assert_eq!(
serde_json::to_value(guardian_assessment_action(&action))?,
serde_json::json!({
"type": "apply_patch",
"cwd": r"C:\workspace",
"files": [r"C:\workspace\guardian.txt"],
}),
);
Ok(())
}
#[test]
@@ -1555,8 +1637,8 @@ fn guardian_request_turn_id_prefers_network_access_owner_turn() {
};
let apply_patch = GuardianApprovalRequest::ApplyPatch {
id: "patch-1".to_string(),
cwd: test_path_buf("/tmp").abs(),
files: vec![test_path_buf("/tmp/guardian.txt").abs()],
cwd: test_path_buf("/tmp").abs().into(),
files: vec![test_path_buf("/tmp/guardian.txt").abs().into()],
patch: "*** Begin Patch\n*** Update File: guardian.txt\n@@\n+hello\n*** End Patch"
.to_string(),
};
@@ -1607,8 +1689,8 @@ async fn cancelled_guardian_review_emits_terminal_abort_without_warning() {
"review-cancelled-guardian".to_string(),
GuardianApprovalRequest::ApplyPatch {
id: "patch-1".to_string(),
cwd: test_path_buf("/tmp").abs(),
files: vec![test_path_buf("/tmp/guardian.txt").abs()],
cwd: test_path_buf("/tmp").abs().into(),
files: vec![test_path_buf("/tmp/guardian.txt").abs().into()],
patch: "*** Begin Patch\n*** Update File: guardian.txt\n@@\n+hello\n*** End Patch"
.to_string(),
},
@@ -1990,8 +2072,10 @@ async fn guardian_request_model_for_auto_review(
turn,
GuardianApprovalRequest::ExecCommand {
id: "shell-1".to_string(),
environment_id: codex_exec_server::LOCAL_ENVIRONMENT_ID.to_string(),
command: vec!["git".to_string(), "push".to_string()],
cwd: test_path_buf("/repo/codex-rs/core").abs(),
cwd: test_path_buf("/repo/codex-rs/core").abs().into(),
guardian_cwd: native_guardian_cwd("/repo/codex-rs/core"),
sandbox_permissions: crate::sandboxing::SandboxPermissions::UseDefault,
additional_permissions: None,
justification: None,
@@ -2231,13 +2315,15 @@ async fn guardian_review_request_layout_matches_model_visible_request_snapshot()
let request = GuardianApprovalRequest::ExecCommand {
id: "shell-1".to_string(),
environment_id: codex_exec_server::LOCAL_ENVIRONMENT_ID.to_string(),
command: vec![
"git".to_string(),
"push".to_string(),
"origin".to_string(),
"guardian-approval-mvp".to_string(),
],
cwd: test_path_buf("/repo/codex-rs/core").abs(),
cwd: test_path_buf("/repo/codex-rs/core").abs().into(),
guardian_cwd: native_guardian_cwd("/repo/codex-rs/core"),
sandbox_permissions: crate::sandboxing::SandboxPermissions::UseDefault,
additional_permissions: None,
justification: Some("Need to push the reviewed docs fix to the repo remote.".to_string()),
@@ -2397,8 +2483,10 @@ async fn build_guardian_prompt_items_includes_parent_session_id() -> anyhow::Res
/*retry_reason*/ None,
GuardianApprovalRequest::ExecCommand {
id: "shell-1".to_string(),
environment_id: codex_exec_server::LOCAL_ENVIRONMENT_ID.to_string(),
command: vec!["git".to_string(), "status".to_string()],
cwd: test_path_buf("/repo").abs(),
cwd: test_path_buf("/repo").abs().into(),
guardian_cwd: native_guardian_cwd("/repo"),
sandbox_permissions: crate::sandboxing::SandboxPermissions::UseDefault,
additional_permissions: None,
justification: None,
@@ -2491,8 +2579,10 @@ async fn guardian_reuses_prompt_cache_key_and_appends_prior_reviews() -> anyhow:
let first_request = GuardianApprovalRequest::ExecCommand {
id: "shell-1".to_string(),
environment_id: codex_exec_server::LOCAL_ENVIRONMENT_ID.to_string(),
command: vec!["git".to_string(), "push".to_string()],
cwd: test_path_buf("/repo/codex-rs/core").abs(),
cwd: test_path_buf("/repo/codex-rs/core").abs().into(),
guardian_cwd: native_guardian_cwd("/repo/codex-rs/core"),
sandbox_permissions: crate::sandboxing::SandboxPermissions::UseDefault,
additional_permissions: None,
justification: Some("Need to push the first docs fix.".to_string()),
@@ -2538,12 +2628,14 @@ async fn guardian_reuses_prompt_cache_key_and_appends_prior_reviews() -> anyhow:
.await;
let second_request = GuardianApprovalRequest::ExecCommand {
id: "shell-2".to_string(),
environment_id: codex_exec_server::LOCAL_ENVIRONMENT_ID.to_string(),
command: vec![
"git".to_string(),
"push".to_string(),
"--force-with-lease".to_string(),
],
cwd: test_path_buf("/repo/codex-rs/core").abs(),
cwd: test_path_buf("/repo/codex-rs/core").abs().into(),
guardian_cwd: native_guardian_cwd("/repo/codex-rs/core"),
sandbox_permissions: crate::sandboxing::SandboxPermissions::UseDefault,
additional_permissions: None,
justification: Some("Need to push the second docs fix.".to_string()),
@@ -2612,8 +2704,10 @@ async fn guardian_reuses_prompt_cache_key_and_appends_prior_reviews() -> anyhow:
.await;
let third_request = GuardianApprovalRequest::ExecCommand {
id: "shell-3".to_string(),
environment_id: codex_exec_server::LOCAL_ENVIRONMENT_ID.to_string(),
command: vec!["git".to_string(), "push".to_string()],
cwd: test_path_buf("/repo/codex-rs/core").abs(),
cwd: test_path_buf("/repo/codex-rs/core").abs().into(),
guardian_cwd: native_guardian_cwd("/repo/codex-rs/core"),
sandbox_permissions: crate::sandboxing::SandboxPermissions::UseDefault,
additional_permissions: None,
justification: Some("Need to push the third docs fix.".to_string()),
@@ -2860,8 +2954,10 @@ async fn guardian_reused_trunk_ignores_stale_prior_turn_completion() -> anyhow::
Arc::clone(&turn),
GuardianApprovalRequest::ExecCommand {
id: "shell-1".to_string(),
environment_id: codex_exec_server::LOCAL_ENVIRONMENT_ID.to_string(),
command: vec!["git".to_string(), "push".to_string()],
cwd: test_path_buf("/repo/codex-rs/core").abs(),
cwd: test_path_buf("/repo/codex-rs/core").abs().into(),
guardian_cwd: native_guardian_cwd("/repo/codex-rs/core"),
sandbox_permissions: crate::sandboxing::SandboxPermissions::UseDefault,
additional_permissions: None,
justification: Some("Need to push the first docs fix.".to_string()),
@@ -2906,8 +3002,10 @@ async fn guardian_reused_trunk_ignores_stale_prior_turn_completion() -> anyhow::
Arc::clone(&turn),
GuardianApprovalRequest::ExecCommand {
id: "shell-2".to_string(),
environment_id: codex_exec_server::LOCAL_ENVIRONMENT_ID.to_string(),
command: vec!["git".to_string(), "push".to_string()],
cwd: test_path_buf("/repo/codex-rs/core").abs(),
cwd: test_path_buf("/repo/codex-rs/core").abs().into(),
guardian_cwd: native_guardian_cwd("/repo/codex-rs/core"),
sandbox_permissions: crate::sandboxing::SandboxPermissions::UseDefault,
additional_permissions: None,
justification: Some("Need to push the second docs fix.".to_string()),
@@ -2987,8 +3085,10 @@ async fn guardian_review_surfaces_responses_api_errors_in_rejection_reason() ->
"review-shell-guardian-error".to_string(),
GuardianApprovalRequest::ExecCommand {
id: "shell-guardian-error".to_string(),
environment_id: codex_exec_server::LOCAL_ENVIRONMENT_ID.to_string(),
command: vec!["git".to_string(), "push".to_string()],
cwd: test_path_buf("/repo/codex-rs/core").abs(),
cwd: test_path_buf("/repo/codex-rs/core").abs().into(),
guardian_cwd: native_guardian_cwd("/repo/codex-rs/core"),
sandbox_permissions: crate::sandboxing::SandboxPermissions::UseDefault,
additional_permissions: None,
justification: Some("Need to push the reviewed docs fix.".to_string()),
@@ -3442,8 +3542,10 @@ async fn guardian_ephemeral_retry_preserves_parallel_trunk_and_fork_history() ->
let initial_request = GuardianApprovalRequest::ExecCommand {
id: "shell-guardian-1".to_string(),
environment_id: codex_exec_server::LOCAL_ENVIRONMENT_ID.to_string(),
command: vec!["git".to_string(), "status".to_string()],
cwd: test_path_buf("/repo/codex-rs/core").abs(),
cwd: test_path_buf("/repo/codex-rs/core").abs().into(),
guardian_cwd: native_guardian_cwd("/repo/codex-rs/core"),
sandbox_permissions: crate::sandboxing::SandboxPermissions::UseDefault,
additional_permissions: None,
justification: Some("Inspect repo state before proceeding.".to_string()),
@@ -3486,8 +3588,10 @@ async fn guardian_ephemeral_retry_preserves_parallel_trunk_and_fork_history() ->
let second_request = GuardianApprovalRequest::ExecCommand {
id: "shell-guardian-2".to_string(),
environment_id: codex_exec_server::LOCAL_ENVIRONMENT_ID.to_string(),
command: vec!["git".to_string(), "diff".to_string()],
cwd: test_path_buf("/repo/codex-rs/core").abs(),
cwd: test_path_buf("/repo/codex-rs/core").abs().into(),
guardian_cwd: native_guardian_cwd("/repo/codex-rs/core"),
sandbox_permissions: crate::sandboxing::SandboxPermissions::UseDefault,
additional_permissions: None,
justification: Some("Inspect pending changes before proceeding.".to_string()),
@@ -3495,8 +3599,10 @@ async fn guardian_ephemeral_retry_preserves_parallel_trunk_and_fork_history() ->
};
let third_request = GuardianApprovalRequest::ExecCommand {
id: "shell-guardian-3".to_string(),
environment_id: codex_exec_server::LOCAL_ENVIRONMENT_ID.to_string(),
command: vec!["git".to_string(), "push".to_string()],
cwd: test_path_buf("/repo/codex-rs/core").abs(),
cwd: test_path_buf("/repo/codex-rs/core").abs().into(),
guardian_cwd: native_guardian_cwd("/repo/codex-rs/core"),
sandbox_permissions: crate::sandboxing::SandboxPermissions::UseDefault,
additional_permissions: None,
justification: Some("Inspect whether pushing is safe before proceeding.".to_string()),