Lightweight coding agent that runs in your terminal
Rust
Stop treating Git commands as inherently safe (#39524)
iceweasel-oai3b45c29062ff
diff --git a/codex-rs/core/src/exec_policy_tests.rs b/codex-rs/core/src/exec_policy_tests.rsindex e7dfba8506..690f92a536 100644--- a/codex-rs/core/src/exec_policy_tests.rs+++ b/codex-rs/core/src/exec_policy_tests.rs@@ -992,6 +992,52 @@ async fn exec_approval_requirement_prefers_execpolicy_match() {.await;}+#[tokio::test]+async fn git_status_obeys_approval_policy_and_explicit_rules() {+ let command = vec_str(&["git", "status"]);+ let amendment = Some(ExecPolicyAmendment::new(command.clone()));++ for (approval_policy, policy_src, expected_requirement) in [+ (+ AskForApproval::UnlessTrusted,+ None,+ ExecApprovalRequirement::NeedsApproval {+ reason: None,+ proposed_execpolicy_amendment: amendment.clone(),+ },+ ),+ (+ AskForApproval::OnRequest,+ None,+ ExecApprovalRequirement::Skip {+ bypass_sandbox: false,+ proposed_execpolicy_amendment: amendment,+ },+ ),+ (+ AskForApproval::UnlessTrusted,+ Some(r#"prefix_rule(pattern=["git", "status"], decision="allow")"#.to_string()),+ ExecApprovalRequirement::Skip {+ bypass_sandbox: true,+ proposed_execpolicy_amendment: None,+ },+ ),+ ] {+ assert_exec_approval_requirement_for_command(+ ExecApprovalRequirementScenario {+ policy_src,+ command: command.clone(),+ approval_policy,+ permission_profile: PermissionProfile::workspace_write(),+ sandbox_permissions: SandboxPermissions::UseDefault,+ prefix_rule: None,+ },+ expected_requirement,+ )+ .await;+ }+}+#[tokio::test]async fn absolute_path_exec_approval_requirement_matches_host_executable_rules() {let git_path = host_program_path("git");@@ -1044,8 +1090,8 @@ prefix_rule(pattern=["git"], decision="prompt")sandbox_permissions: SandboxPermissions::UseDefault,prefix_rule: None,},- ExecApprovalRequirement::Skip {- bypass_sandbox: false,+ ExecApprovalRequirement::NeedsApproval {+ reason: None,proposed_execpolicy_amendment: Some(ExecPolicyAmendment::new(vec![disallowed_git_path,"status".to_string(),diff --git a/codex-rs/core/tests/suite/exec_policy.rs b/codex-rs/core/tests/suite/exec_policy.rsindex 13786af416..3c8789f6a8 100644--- a/codex-rs/core/tests/suite/exec_policy.rs+++ b/codex-rs/core/tests/suite/exec_policy.rs@@ -31,10 +31,12 @@ use core_test_support::responses::mount_sse_once;use core_test_support::responses::sse;use core_test_support::responses::start_mock_server;use core_test_support::skip_if_target_windows;+use core_test_support::skip_if_wine_exec;use core_test_support::test_codex::local_selections;use core_test_support::test_codex::test_codex;use core_test_support::test_codex::turn_permission_fields;use core_test_support::wait_for_event;+use pretty_assertions::assert_eq;use serde_json::Value;use serde_json::json;use std::fs;@@ -101,6 +103,91 @@ fn assert_no_matched_rules_invariant(output_item: &Value) {);}+#[tokio::test]+async fn git_status_requires_approval_under_unless_trusted() -> Result<()> {+ skip_if_wine_exec!(Ok(()), "command approval requires host-native paths");++ let server = start_mock_server().await;+ let mut builder = test_codex().with_model("gpt-5.2").with_config(|config| {+ config+ .features+ .enable(Feature::UnifiedExec)+ .expect("test config should allow feature update");+ config.permissions.approval_policy = Constrained::allow_any(AskForApproval::UnlessTrusted);+ config+ .permissions+ .set_permission_profile(PermissionProfile::workspace_write())+ .expect("set workspace-write permissions");+ config.approvals_reviewer = ApprovalsReviewer::User;+ });+ let test = builder.build_with_auto_env(&server).await?;+ let call_id = "git-status-approval";+ let args = json!({"cmd": "git status", "yield_time_ms": 1_000});+ let initial_mock = mount_sse_once(+ &server,+ sse(vec![+ ev_response_created("resp-git-status-1"),+ ev_function_call(call_id, "exec_command", &serde_json::to_string(&args)?),+ ev_completed("resp-git-status-1"),+ ]),+ )+ .await;+ let results_mock = mount_sse_once(+ &server,+ sse(vec![+ ev_assistant_message("msg-git-status-1", "done"),+ ev_completed("resp-git-status-2"),+ ]),+ )+ .await;++ test.codex+ .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {+ text: "check git status".into(),+ text_elements: Vec::new(),+ }]))+ .await?;+ let event = wait_for_event(&test.codex, |event| {+ matches!(+ event,+ EventMsg::ExecApprovalRequest(_) | EventMsg::TurnComplete(_)+ )+ })+ .await;+ let EventMsg::ExecApprovalRequest(approval) = event else {+ let output = results_mock.function_call_output_text(call_id);+ panic!(+ "expected git status to request approval before turn completion; output: {output:?}"+ );+ };+ assert_eq!(approval.call_id, call_id);+ test.codex+ .submit(Op::ExecApproval {+ id: approval.effective_approval_id(),+ turn_id: None,+ decision: ReviewDecision::denied("git status was not approved"),+ })+ .await?;+ wait_for_event(&test.codex, |event| {+ matches!(event, EventMsg::TurnComplete(_))+ })+ .await;+ assert!(+ initial_mock+ .single_request()+ .message_input_texts("user")+ .iter()+ .any(|text| text == "check git status")+ );+ let output = results_mock+ .single_request()+ .function_call_output_text(call_id)+ .expect("shell command output");+ assert!(output.contains("git status was not approved"), "{output}");++ Ok(())+}+#[tokio::test]async fn startup_migrates_default_policy_and_honors_ignore_rules() -> Result<()> {const LEGACY_POLICY: &str = r#"prefix_rule(pattern=["rm"], decision="allow")diff --git a/codex-rs/shell-command/src/command_safety/is_dangerous_command.rs b/codex-rs/shell-command/src/command_safety/is_dangerous_command.rsindex 59fce97566..d689afdccb 100644--- a/codex-rs/shell-command/src/command_safety/is_dangerous_command.rs+++ b/codex-rs/shell-command/src/command_safety/is_dangerous_command.rs@@ -67,31 +67,6 @@ pub fn dangerous_powershell_words_match(command: &[String]) -> Option<DangerousC}}-fn is_git_global_option_with_value(arg: &str) -> bool {- matches!(- arg,- "-C" | "-c"- | "--config-env"- | "--exec-path"- | "--git-dir"- | "--namespace"- | "--super-prefix"- | "--work-tree"- )-}--fn is_git_global_option_with_inline_value(arg: &str) -> bool {- matches!(- arg,- s if s.starts_with("--config-env=")- || s.starts_with("--exec-path=")- || s.starts_with("--git-dir=")- || s.starts_with("--namespace=")- || s.starts_with("--super-prefix=")- || s.starts_with("--work-tree=")- ) || ((arg.starts_with("-C") || arg.starts_with("-c")) && arg.len() > 2)-}-pub(crate) fn executable_name_lookup_key(raw: &str) -> Option<String> {#[cfg(windows)]{@@ -118,54 +93,6 @@ pub(crate) fn executable_name_lookup_key(raw: &str) -> Option<String> {}}-/// Find the first matching git subcommand, skipping known global options that-/// may appear before it (e.g., `-C`, `-c`, `--git-dir`).-///-/// Shared with `is_safe_command` to avoid git-global-option bypasses.-pub(crate) fn find_git_subcommand<'a>(- command: &'a [String],- subcommands: &[&str],-) -> Option<(usize, &'a str)> {- let cmd0 = command.first().map(String::as_str)?;- if executable_name_lookup_key(cmd0).as_deref() != Some("git") {- return None;- }-- let mut skip_next = false;- for (idx, arg) in command.iter().enumerate().skip(1) {- if skip_next {- skip_next = false;- continue;- }-- let arg = arg.as_str();-- if is_git_global_option_with_inline_value(arg) {- continue;- }-- if is_git_global_option_with_value(arg) {- skip_next = true;- continue;- }-- if arg == "--" || arg.starts_with('-') {- continue;- }-- if subcommands.contains(&arg) {- return Some((idx, arg));- }-- // In git, the first non-option token is the subcommand. If it isn't- // one of the subcommands we're looking for, we must stop scanning to- // avoid misclassifying later positional args (e.g., branch names).- return None;- }-- None-}-fn dangerous_command_match_for_exec(command: &[String],wrapper_depth: usize,diff --git a/codex-rs/shell-command/src/command_safety/is_safe_command.rs b/codex-rs/shell-command/src/command_safety/is_safe_command.rsindex bca44139cd..1f24a6d21d 100644--- a/codex-rs/shell-command/src/command_safety/is_safe_command.rs+++ b/codex-rs/shell-command/src/command_safety/is_safe_command.rs@@ -1,9 +1,5 @@use crate::bash::parse_shell_lc_plain_commands;use crate::command_safety::is_dangerous_command::executable_name_lookup_key;-// Find the first matching git subcommand, skipping known global options that-// may appear before it (e.g., `-C`, `-c`, `--git-dir`).-// Implemented in `is_dangerous_command` and shared here.-use crate::command_safety::is_dangerous_command::find_git_subcommand;#[cfg(windows)]use crate::command_safety::windows_safe_commands::is_safe_command_windows;#[cfg(windows)]@@ -153,8 +149,8 @@ fn is_safe_to_call_with_exec(command: &[String]) -> bool {})}- // Git- Some("git") => is_safe_git_command(command),+ // Repository configuration can make even read-only Git commands execute helpers.+ Some("git") => false,// Special-case `sed -n {N|M,N}p`Some("sed")@@ -172,128 +168,6 @@ fn is_safe_to_call_with_exec(command: &[String]) -> bool {}}-pub(crate) fn is_safe_git_command(command: &[String]) -> bool {- let Some((subcommand_idx, subcommand)) =- find_git_subcommand(command, &["status", "log", "diff", "show", "branch"])- else {- return false;- };-- let global_args = &command[1..subcommand_idx];- if git_has_unsafe_global_option(global_args) {- return false;- }-- let subcommand_args = &command[subcommand_idx + 1..];-- match subcommand {- "status" | "log" | "diff" | "show" => git_subcommand_args_are_read_only(subcommand_args),- "branch" => {- git_subcommand_args_are_read_only(subcommand_args)- && git_branch_is_read_only(subcommand_args)- }- other => {- debug_assert!(false, "unexpected git subcommand from matcher: {other}");- false- }- }-}--// Treat `git branch` as safe only when the arguments clearly indicate-// a read-only query, not a branch mutation (create/rename/delete).-fn git_branch_is_read_only(branch_args: &[String]) -> bool {- if branch_args.is_empty() {- // `git branch` with no additional args lists branches.- return true;- }-- let mut saw_read_only_flag = false;- for arg in branch_args.iter().map(String::as_str) {- match arg {- "--list" | "-l" | "--show-current" | "-a" | "--all" | "-r" | "--remotes" | "-v"- | "-vv" | "--verbose" => {- saw_read_only_flag = true;- }- _ if arg.starts_with("--format=") => {- saw_read_only_flag = true;- }- _ => {- // Any other flag or positional argument may create, rename, or delete branches.- return false;- }- }- }-- saw_read_only_flag-}--#[derive(Clone, Copy)]-enum GitOptionPattern {- Exact(&'static str),- ShortWithInlineValue(&'static str),- Prefix(&'static str),-}--const UNSAFE_GIT_GLOBAL_OPTIONS: &[GitOptionPattern] = &[- GitOptionPattern::Exact("-C"),- GitOptionPattern::ShortWithInlineValue("-C"),- GitOptionPattern::Exact("-c"),- GitOptionPattern::ShortWithInlineValue("-c"),- GitOptionPattern::Exact("-p"),- GitOptionPattern::Exact("--config-env"),- GitOptionPattern::Prefix("--config-env="),- GitOptionPattern::Exact("--exec-path"),- GitOptionPattern::Prefix("--exec-path="),- GitOptionPattern::Exact("--git-dir"),- GitOptionPattern::Prefix("--git-dir="),- GitOptionPattern::Exact("--namespace"),- GitOptionPattern::Prefix("--namespace="),- GitOptionPattern::Exact("--paginate"),- GitOptionPattern::Exact("--super-prefix"),- GitOptionPattern::Prefix("--super-prefix="),- GitOptionPattern::Exact("--work-tree"),- GitOptionPattern::Prefix("--work-tree="),-];--const UNSAFE_GIT_SUBCOMMAND_OPTIONS: &[GitOptionPattern] = &[- GitOptionPattern::Exact("--output"),- GitOptionPattern::Prefix("--output="),- GitOptionPattern::Exact("--ext-diff"),- GitOptionPattern::Exact("--textconv"),- GitOptionPattern::Exact("--exec"),- GitOptionPattern::Prefix("--exec="),-];--impl GitOptionPattern {- fn matches(self, arg: &str) -> bool {- match self {- GitOptionPattern::Exact(option) => arg == option,- GitOptionPattern::ShortWithInlineValue(option) => {- arg.starts_with(option) && arg.len() > option.len()- }- GitOptionPattern::Prefix(prefix) => arg.starts_with(prefix),- }- }-}--fn git_matches_option_pattern(arg: &str, patterns: &[GitOptionPattern]) -> bool {- patterns.iter().any(|pattern| pattern.matches(arg))-}--fn git_has_unsafe_global_option(global_args: &[String]) -> bool {- global_args- .iter()- .map(String::as_str)- .any(|arg| git_matches_option_pattern(arg, UNSAFE_GIT_GLOBAL_OPTIONS))-}--fn git_subcommand_args_are_read_only(args: &[String]) -> bool {- !args- .iter()- .map(String::as_str)- .any(|arg| git_matches_option_pattern(arg, UNSAFE_GIT_SUBCOMMAND_OPTIONS))-}-// (bash parsing helpers implemented in crate::bash)/* ----------------------------------------------------------@@ -345,13 +219,6 @@ mod tests {#[test]fn known_safe_examples() {assert!(is_safe_to_call_with_exec(&vec_str(&["ls"])));- assert!(is_safe_to_call_with_exec(&vec_str(&["git", "status"])));- assert!(is_safe_to_call_with_exec(&vec_str(&["git", "branch"])));- assert!(is_safe_to_call_with_exec(&vec_str(&[- "git",- "branch",- "--show-current"- ])));assert!(is_safe_to_call_with_exec(&vec_str(&["base64"])));assert!(is_safe_to_call_with_exec(&vec_str(&["sed", "-n", "1,5p", "file.txt"@@ -377,153 +244,25 @@ mod tests {}#[test]- fn git_branch_mutating_flags_are_not_safe() {- assert!(!is_known_safe_command(&vec_str(&[- "git", "branch", "-d", "feature"- ])));- assert!(!is_known_safe_command(&vec_str(&[- "git",- "branch",- "new-branch"- ])));- }-- #[test]- fn git_branch_global_options_respect_safety_rules() {- assert!(is_known_safe_command(&vec_str(&[- "git",- "branch",- "--show-current",- ])));- assert!(!is_known_safe_command(&vec_str(&[- "git", "branch", "-d", "feature",- ])));- assert!(!is_known_safe_command(&vec_str(&[- "bash",- "-lc",- "git branch -d feature",- ])));- }-- #[test]- fn git_first_positional_is_the_subcommand() {- // In git, the first non-option token is the subcommand. Later positional- // args (like branch names) must not be treated as subcommands.- assert!(!is_known_safe_command(&vec_str(&[- "git", "checkout", "status",- ])));- }-- #[test]- fn git_output_flags_are_not_safe() {- assert!(!is_known_safe_command(&vec_str(&[- "git",- "log",- "--output=/tmp/git-log-out-test",- "-n",- "1",- ])));- assert!(!is_known_safe_command(&vec_str(&[- "git",- "diff",- "--output",- "/tmp/git-diff-out-test",- ])));- assert!(!is_known_safe_command(&vec_str(&[- "git",- "show",- "--output=/tmp/git-show-out-test",- "HEAD",- ])));- }-- #[test]- fn git_global_pagination_flags_are_not_safe() {- assert!(!is_known_safe_command(&vec_str(&[- "git",- "--paginate",- "log",- "-1",- ])));- assert!(!is_known_safe_command(&vec_str(&[- "git", "-p", "log", "-1",- ])));- assert!(!is_known_safe_command(&vec_str(&[- "bash",- "-lc",- "git --paginate log -1",- ])));- assert!(!is_known_safe_command(&vec_str(&[- "bash",- "-lc",- "git -p log -1",- ])));- }-- #[test]- fn git_subcommand_patch_flags_remain_safe() {- assert!(is_known_safe_command(&vec_str(&["git", "log", "-p", "-1"])));- assert!(is_known_safe_command(&vec_str(&["git", "diff", "-p"])));- assert!(is_known_safe_command(&vec_str(&[- "git", "show", "-p", "HEAD",- ])));- assert!(is_known_safe_command(&vec_str(&[- "bash",- "-lc",- "git log -p -1",- ])));- }-- #[test]- fn git_global_override_flags_are_not_safe() {- assert!(!is_known_safe_command(&vec_str(&[- "git", "-C", ".", "status",- ])));- assert!(!is_known_safe_command(&vec_str(&["git", "-C.", "status",])));- assert!(!is_known_safe_command(&vec_str(&[- "git",- "-c",- "core.pager=cat",- "log",- "-n",- "1",- ])));- assert!(!is_known_safe_command(&vec_str(&[- "git",- "-ccore.pager=cat",- "status",- ])));-+ fn git_commands_are_not_known_safe() {for args in [- vec_str(&["git", "--config-env", "core.pager=PAGER", "show", "HEAD"]),- vec_str(&["git", "--config-env=core.pager=PAGER", "show", "HEAD"]),- vec_str(&["git", "--git-dir", ".evil-git", "diff", "HEAD~1..HEAD"]),- vec_str(&["git", "--git-dir=.evil-git", "diff", "HEAD~1..HEAD"]),- vec_str(&["git", "--work-tree", ".", "status"]),- vec_str(&["git", "--work-tree=.", "status"]),- vec_str(&["git", "--exec-path", ".git/helpers", "show", "HEAD"]),- vec_str(&["git", "--exec-path=.git/helpers", "show", "HEAD"]),- vec_str(&["git", "--namespace", "attacker", "show", "HEAD"]),- vec_str(&["git", "--namespace=attacker", "show", "HEAD"]),- vec_str(&["git", "--super-prefix", "attacker/", "show", "HEAD"]),- vec_str(&["git", "--super-prefix=attacker/", "show", "HEAD"]),+ vec_str(&["git", "status", "--short"]),+ vec_str(&["git", "log", "-p", "-1"]),+ vec_str(&["git", "diff"]),+ vec_str(&["git", "show", "HEAD"]),+ vec_str(&["git", "branch"]),+ vec_str(&["git", "branch", "--show-current"]),+ vec_str(&["git", "--version"]),+ vec_str(&["/usr/bin/git", "status"]),+ vec_str(&["bash", "-lc", "git status"]),+ vec_str(&["zsh", "-lc", "cd nested && git status"]),+ vec_str(&["bash", "-lc", "git diff | head -20"]),] {assert!(!is_known_safe_command(&args),- "expected {args:?} to require approval due to unsafe git global option",+ "Git must not be trusted from its arguments alone: {args:?}",);}-- assert!(!is_known_safe_command(&vec_str(&[- "bash",- "-lc",- "git -C .project-deps/test-fixtures status",- ])));- assert!(!is_known_safe_command(&vec_str(&[- "bash",- "-lc",- "git --git-dir=.evil-git diff HEAD~1..HEAD",- ])));}#[test]@@ -636,12 +375,12 @@ mod tests {}#[test]- fn windows_git_full_path_is_safe() {+ fn windows_git_full_path_is_not_safe() {if !cfg!(windows) {return;}- assert!(is_known_safe_command(&vec_str(&[+ assert!(!is_known_safe_command(&vec_str(&[r"C:\Program Files\Git\cmd\git.exe","status",])));@@ -651,11 +390,6 @@ mod tests {fn bash_lc_safe_examples() {assert!(is_known_safe_command(&vec_str(&["bash", "-lc", "ls"])));assert!(is_known_safe_command(&vec_str(&["bash", "-lc", "ls -1"])));- assert!(is_known_safe_command(&vec_str(&[- "bash",- "-lc",- "git status"- ])));assert!(is_known_safe_command(&vec_str(&["bash","-lc",diff --git a/codex-rs/shell-command/src/command_safety/windows_safe_commands.rs b/codex-rs/shell-command/src/command_safety/windows_safe_commands.rsindex df2025253b..f7630ee6e3 100644--- a/codex-rs/shell-command/src/command_safety/windows_safe_commands.rs+++ b/codex-rs/shell-command/src/command_safety/windows_safe_commands.rs@@ -1,4 +1,3 @@-use crate::command_safety::is_safe_command::is_safe_git_command;use crate::command_safety::powershell_parser::PowershellParseOutcome;use crate::command_safety::powershell_parser::parse_with_powershell_ast;use std::path::Path;@@ -188,7 +187,8 @@ pub(crate) fn is_safe_powershell_words(words: &[String]) -> bool {"select-object" | "select" => true,"get-item" => true,- "git" => is_safe_git_command(words),+ // Repository configuration can make even read-only Git commands execute helpers.+ "git" => false,"rg" => is_safe_ripgrep(words),@@ -225,7 +225,6 @@ fn is_safe_ripgrep(words: &[String]) -> bool {mod tests {use super::*;use crate::powershell::try_find_pwsh_executable_blocking;- use pretty_assertions::assert_eq;use std::string::ToString;/// Converts a slice of string literals into owned `String`s for the tests.@@ -242,13 +241,6 @@ mod tests {"Get-ChildItem -Path .",])));- assert!(is_safe_command_windows(&vec_str(&[- "powershell.exe",- "-NoProfile",- "-Command",- "git status",- ])));-assert!(is_safe_command_windows(&vec_str(&["powershell.exe","Get-Content",@@ -290,7 +282,7 @@ mod tests {}#[test]- fn allows_read_only_pipelines_and_git_usage() {+ fn allows_read_only_pipelines() {let Some(pwsh) = try_find_pwsh_executable_blocking() else {return;};@@ -313,12 +305,6 @@ mod tests {"Get-Content foo.rs | Select-Object -Skip 200".to_string()]));- assert!(is_safe_command_windows(&[- pwsh.clone(),- "-Command".to_string(),- "git show HEAD:foo.rs".to_string()- ]));-assert!(is_safe_command_windows(&[pwsh.clone(),"-Command".to_string(),@@ -333,82 +319,36 @@ mod tests {}#[test]- fn rejects_git_global_override_options() {- let Some(pwsh) = try_find_pwsh_executable_blocking() else {- return;- };-- let pwsh: String = pwsh.as_path().to_str().unwrap().into();- for script in [- "git -c core.pager=cat show HEAD:foo.rs",- "git --config-env core.pager=PAGER show HEAD:foo.rs",- "git --config-env=core.pager=PAGER show HEAD:foo.rs",- "git --git-dir .evil-git diff HEAD~1..HEAD",- "git --git-dir=.evil-git diff HEAD~1..HEAD",- "git --work-tree . status",- "git --work-tree=. status",- "git --exec-path .git/helpers show HEAD:foo.rs",- "git --exec-path=.git/helpers show HEAD:foo.rs",- "git --namespace attacker show HEAD:foo.rs",- "git --namespace=attacker show HEAD:foo.rs",- "git --super-prefix attacker/ show HEAD:foo.rs",- "git --super-prefix=attacker/ show HEAD:foo.rs",+ fn rejects_git_commands() {+ for args in [+ vec_str(&["git", "status", "--short"]),+ vec_str(&["git", "log", "-p", "-1"]),+ vec_str(&["git", "diff"]),+ vec_str(&["git", "show", "HEAD:foo.rs"]),+ vec_str(&["git", "branch", "--show-current"]),+ vec_str(&["git", "--version"]),] {+ assert!(!is_safe_powershell_words(&args));+ let script = args.join(" ");assert!(!is_safe_command_windows(&[- pwsh.clone(),- "-NoLogo".to_string(),+ "powershell.exe".to_string(),"-NoProfile".to_string(),"-Command".to_string(),- script.to_string(),+ script.clone(),]),- "expected {script:?} to require approval due to unsafe git global option",+ "Git must not be trusted from its arguments alone: {script:?}",);}}#[test]- fn rejects_git_subcommand_options_with_side_effects() {- let results: Vec<(&str, bool)> = [- "git diff --output codex_poc.txt",- "git diff --ext-diff HEAD",- "git log --textconv -1",- "git show --output=codex_poc.txt HEAD",- "git cat-file --filters HEAD:a.txt",- ]- .into_iter()- .map(|script| {- (- script,- is_safe_command_windows(&[- "powershell.exe".to_string(),- "-NoProfile".to_string(),- "-Command".to_string(),- script.to_string(),- ]),- )- })- .collect();-- assert_eq!(- vec![- ("git diff --output codex_poc.txt", false),- ("git diff --ext-diff HEAD", false),- ("git log --textconv -1", false),- ("git show --output=codex_poc.txt HEAD", false),- ("git cat-file --filters HEAD:a.txt", false),- ],- results- );- }-- #[test]- fn rejects_stop_parsing_git_forms() {+ fn rejects_stop_parsing_forms() {assert!(!is_safe_command_windows(&vec_str(&["powershell.exe","-NoProfile","-Command",- "git log --% HEAD --output=codex_poc.txt",+ "rg --% pattern Cargo.toml",])));}