Lightweight coding agent that runs in your terminal
Rust
Resolve model-provided shells by type (#39607)
pakrym-oai186b449bc218
diff --git a/codex-rs/core/src/session/session.rs b/codex-rs/core/src/session/session.rsindex 1d999d63af..c934599a68 100644--- a/codex-rs/core/src/session/session.rs+++ b/codex-rs/core/src/session/session.rs@@ -1130,13 +1130,19 @@ impl Session {"zsh fork feature enabled, but no packaged zsh fork is available for this install")})?;- let zsh_path = zsh_path.to_path_buf();- shell::get_shell(shell::ShellType::Zsh, Some(&zsh_path)).ok_or_else(|| {- anyhow::anyhow!(- "zsh fork feature enabled, but packaged zsh fork `{}` is not usable",- zsh_path.display()- )- })?+ if zsh_path.is_file() {+ shell::Shell {+ shell_type: shell::ShellType::Zsh,+ shell_path: zsh_path.clone(),+ }+ } else {+ shell::get_shell(shell::ShellType::Zsh).ok_or_else(|| {+ anyhow::anyhow!(+ "zsh fork feature enabled, but packaged zsh fork `{}` is not usable",+ zsh_path.display()+ )+ })?+ }} else {shell::default_user_shell()};diff --git a/codex-rs/core/src/shell.rs b/codex-rs/core/src/shell.rsindex ccd1ea20d2..37a35bfe3f 100644--- a/codex-rs/core/src/shell.rs+++ b/codex-rs/core/src/shell.rs@@ -85,8 +85,8 @@ pub fn get_shell_by_model_provided_path(shell_path: &PathBuf) -> Shell {codex_shell_command::shell_detect::get_shell_by_model_provided_path(shell_path).into()}-pub fn get_shell(shell_type: ShellType, path: Option<&PathBuf>) -> Option<Shell> {- codex_shell_command::shell_detect::get_shell(shell_type, path).map(Into::into)+pub fn get_shell(shell_type: ShellType) -> Option<Shell> {+ codex_shell_command::shell_detect::get_shell(shell_type).map(Into::into)}pub fn default_user_shell() -> Shell {diff --git a/codex-rs/core/src/shell_snapshot.rs b/codex-rs/core/src/shell_snapshot.rsindex baeb2b69f4..b0782e5c5a 100644--- a/codex-rs/core/src/shell_snapshot.rs+++ b/codex-rs/core/src/shell_snapshot.rs@@ -206,8 +206,8 @@ async fn write_shell_snapshot(if shell_type == ShellType::PowerShell || shell_type == ShellType::Cmd {bail!("Shell snapshot not supported yet for {shell_type:?}");}- let shell = get_shell(shell_type, /*path*/ None)- .with_context(|| format!("No available shell for {shell_type:?}"))?;+ let shell =+ get_shell(shell_type).with_context(|| format!("No available shell for {shell_type:?}"))?;let raw_snapshot = capture_snapshot(&shell, cwd).await?;let snapshot = strip_snapshot_preamble(&raw_snapshot)?;diff --git a/codex-rs/core/src/shell_tests.rs b/codex-rs/core/src/shell_tests.rsindex dea4a4f689..0963ef8364 100644--- a/codex-rs/core/src/shell_tests.rs+++ b/codex-rs/core/src/shell_tests.rs@@ -5,7 +5,7 @@ use std::process::Command;#[test]#[cfg(target_os = "macos")]fn detects_zsh() {- let zsh_shell = get_shell(ShellType::Zsh, /*path*/ None).unwrap();+ let zsh_shell = get_shell(ShellType::Zsh).unwrap();let shell_path = zsh_shell.shell_path;@@ -24,7 +24,7 @@ fn fish_fallback_to_zsh() {#[test]fn detects_bash() {- let bash_shell = get_shell(ShellType::Bash, /*path*/ None).unwrap();+ let bash_shell = get_shell(ShellType::Bash).unwrap();let shell_path = bash_shell.shell_path;assert!(@@ -35,7 +35,7 @@ fn detects_bash() {#[test]fn detects_sh() {- let sh_shell = get_shell(ShellType::Sh, /*path*/ None).unwrap();+ let sh_shell = get_shell(ShellType::Sh).unwrap();let shell_path = sh_shell.shell_path;assert!(shell_path.file_name().and_then(|name| name.to_str()) == Some("sh"),@@ -48,12 +48,12 @@ fn can_run_on_shell_test() {let cmd = "echo \"Works\"";if cfg!(windows) {assert!(shell_works(- get_shell(ShellType::PowerShell, /*path*/ None),+ get_shell(ShellType::PowerShell),"Out-String 'Works'",/*required*/ true,));assert!(shell_works(- get_shell(ShellType::Cmd, /*path*/ None),+ get_shell(ShellType::Cmd),cmd,/*required*/ true,));@@ -69,17 +69,17 @@ fn can_run_on_shell_test() {/*required*/ true));assert!(shell_works(- get_shell(ShellType::Zsh, /*path*/ None),+ get_shell(ShellType::Zsh),cmd,/*required*/ false));assert!(shell_works(- get_shell(ShellType::Bash, /*path*/ None),+ get_shell(ShellType::Bash),cmd,/*required*/ true));assert!(shell_works(- get_shell(ShellType::Sh, /*path*/ None),+ get_shell(ShellType::Sh),cmd,/*required*/ true));@@ -181,7 +181,7 @@ fn finds_powershell() {return;}- let powershell_shell = get_shell(ShellType::PowerShell, /*path*/ None).unwrap();+ let powershell_shell = get_shell(ShellType::PowerShell).unwrap();let shell_path = powershell_shell.shell_path;assert!(shell_path.ends_with("pwsh.exe") || shell_path.ends_with("powershell.exe"));diff --git a/codex-rs/core/src/tools/handlers/unified_exec_tests.rs b/codex-rs/core/src/tools/handlers/unified_exec_tests.rsindex eee95fd43a..775d78cc1f 100644--- a/codex-rs/core/src/tools/handlers/unified_exec_tests.rs+++ b/codex-rs/core/src/tools/handlers/unified_exec_tests.rs@@ -1,6 +1,7 @@use super::*;use crate::shell::ShellType;use crate::shell::default_user_shell;+use crate::shell::get_shell;use codex_exec_server::Environment;use codex_tools::UnifiedExecShellMode;use codex_tools::ZshForkConfig;@@ -95,7 +96,7 @@ fn test_get_command_respects_explicit_bash_shell() -> anyhow::Result<()> {}#[test]-fn test_get_command_respects_explicit_powershell_shell() -> anyhow::Result<()> {+fn test_get_command_resolves_powershell_by_type() -> anyhow::Result<()> {let temp_dir = tempfile::tempdir()?;let powershell_path = temp_dir.path().join(if cfg!(windows) {"powershell.exe"@@ -123,10 +124,13 @@ fn test_get_command_respects_explicit_powershell_shell() -> anyhow::Result<()> {/*allow_login_shell*/ true,).map_err(anyhow::Error::msg)?;- let command = resolved.command;-- assert_eq!(command[2], "echo hello");- assert_eq!(resolved.shell_type, ShellType::PowerShell);+ let expected_shell = get_shell(ShellType::PowerShell)+ .unwrap_or_else(|| codex_shell_command::shell_detect::ultimate_fallback_shell().into());+ assert_eq!(+ resolved.command,+ expected_shell.derive_exec_args("echo hello", /*use_login_shell*/ true)+ );+ assert_eq!(resolved.shell_type, expected_shell.shell_type);Ok(())}diff --git a/codex-rs/core/tests/suite/executable_identity.rs b/codex-rs/core/tests/suite/executable_identity.rsdeleted file mode 100644index 77f87d6e3a..0000000000--- a/codex-rs/core/tests/suite/executable_identity.rs+++ /dev/null@@ -1,349 +0,0 @@-use anyhow::Result;-use codex_config::Constrained;-use codex_core::TurnInputRequest;-use codex_features::Feature;-use codex_protocol::config_types::ApprovalsReviewer;-use codex_protocol::models::PermissionProfile;-use codex_protocol::protocol::AskForApproval;-use codex_protocol::protocol::EventMsg;-use codex_protocol::protocol::Op;-use codex_protocol::protocol::ReviewDecision;-use codex_protocol::protocol::ThreadSettingsOverrides;-use codex_protocol::user_input::UserInput;-use core_test_support::responses::ev_assistant_message;-use core_test_support::responses::ev_completed;-use core_test_support::responses::ev_function_call;-use core_test_support::responses::ev_response_created;-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_remote;-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::json;-use std::fs;-#[cfg(unix)]-use std::os::unix::fs::PermissionsExt;-use test_case::test_case;--#[derive(Clone, Copy)]-enum ShellAttack {- ExactShellName,- ExactShellNameWithAllowedInnerCommand,- ExactShellNameWithForbiddenInnerCommand,- DangerousCommandOnRequest,- DangerousCommandNever,- ApprovedCustomShell,- SessionApprovalDoesNotTrustDifferentShell,- SpoofedShellExtension,-}--#[test_case(ShellAttack::ExactShellName; "workspace shell requires approval")]-#[test_case(ShellAttack::ExactShellNameWithAllowedInnerCommand; "inner allow does not trust workspace shell")]-#[test_case(ShellAttack::ExactShellNameWithForbiddenInnerCommand; "inner forbidden rule still rejects workspace shell")]-#[test_case(ShellAttack::DangerousCommandOnRequest; "dangerous inner command requires approval")]-#[test_case(ShellAttack::DangerousCommandNever; "dangerous inner command is forbidden without approval")]-#[test_case(ShellAttack::ApprovedCustomShell; "approved custom shell still runs")]-#[test_case(ShellAttack::SessionApprovalDoesNotTrustDifferentShell; "session approval does not trust a different shell")]-#[test_case(ShellAttack::SpoofedShellExtension; "workspace shell with an extra extension requires approval")]-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]-async fn model_provided_shell_cannot_inherit_inner_command_trust(- attack: ShellAttack,-) -> Result<()> {- skip_if_remote!(- Ok(()),- "remote executors already replace requested shell paths with their reported shell"- );-- let approval_policy = match attack {- ShellAttack::DangerousCommandOnRequest => AskForApproval::OnRequest,- ShellAttack::DangerousCommandNever => AskForApproval::Never,- ShellAttack::ExactShellName- | ShellAttack::ExactShellNameWithAllowedInnerCommand- | ShellAttack::ExactShellNameWithForbiddenInnerCommand- | ShellAttack::ApprovedCustomShell- | ShellAttack::SessionApprovalDoesNotTrustDifferentShell- | ShellAttack::SpoofedShellExtension => AskForApproval::UnlessTrusted,- };- let server = start_mock_server().await;- let mut builder = test_codex().with_config(move |config| {- config.use_experimental_unified_exec_tool = true;- config- .features- .enable(Feature::UnifiedExec)- .expect("enable unified exec");- config.permissions.approval_policy = Constrained::allow_any(approval_policy);- config.approvals_reviewer = ApprovalsReviewer::User;- let inner_command_rule = match attack {- ShellAttack::ExactShellNameWithAllowedInnerCommand => {- Some("prefix_rule(pattern=[\"echo\"], decision=\"allow\")\n")- }- ShellAttack::ExactShellNameWithForbiddenInnerCommand => {- if cfg!(windows) {- Some(- r#"prefix_rule(pattern=["Remove-Item", "C:\\important"], decision="forbidden")"#,- )- } else {- Some("prefix_rule(pattern=[\"rm\"], decision=\"forbidden\")\n")- }- }- ShellAttack::ExactShellName- | ShellAttack::DangerousCommandOnRequest- | ShellAttack::DangerousCommandNever- | ShellAttack::ApprovedCustomShell- | ShellAttack::SessionApprovalDoesNotTrustDifferentShell- | ShellAttack::SpoofedShellExtension => None,- };- if let Some(inner_command_rule) = inner_command_rule {- let policy_path = config.codex_home.join("rules/default.rules");- fs::create_dir_all(policy_path.parent().expect("rules directory"))- .expect("create rules directory");- fs::write(policy_path, inner_command_rule).expect("write execution policy rule");- }- });- #[cfg(windows)]- if matches!(- attack,- ShellAttack::ExactShellNameWithForbiddenInnerCommand | ShellAttack::ApprovedCustomShell- ) {- let system_root = std::env::var_os("SystemRoot").expect("Windows SystemRoot");- let configured_shell = std::path::Path::new(&system_root)- .join("System32")- .join("WindowsPowerShell")- .join("v1.0")- .join("powershell.exe");- builder = builder.with_user_shell(codex_core::shell::get_shell_by_model_provided_path(- &configured_shell,- ));- }- let test = builder.build_with_auto_env(&server).await?;- let shell_name = match attack {- ShellAttack::ExactShellNameWithForbiddenInnerCommand | ShellAttack::ApprovedCustomShell- if cfg!(windows) =>- {- "pwsh.exe"- }- ShellAttack::ExactShellName- | ShellAttack::ExactShellNameWithAllowedInnerCommand- | ShellAttack::ExactShellNameWithForbiddenInnerCommand- | ShellAttack::DangerousCommandOnRequest- | ShellAttack::DangerousCommandNever- | ShellAttack::ApprovedCustomShell- | ShellAttack::SessionApprovalDoesNotTrustDifferentShell => {- if cfg!(windows) {- "powershell.exe"- } else {- "bash"- }- }- ShellAttack::SpoofedShellExtension => {- if cfg!(windows) {- "powershell.evil"- } else {- "bash.evil"- }- }- };- let shell = test.workspace_path(shell_name);- let marker = test.workspace_path("attacker-executed");- #[cfg(unix)]- {- fs::write(&shell, "#!/bin/sh\nprintf ran > attacker-executed\n")?;- fs::set_permissions(&shell, fs::Permissions::from_mode(0o755))?;- }- #[cfg(windows)]- {- let test_executable = std::env::current_exe()?;- fs::hard_link(&test_executable, &shell)- .or_else(|_| fs::copy(&test_executable, &shell).map(|_| ()))?;- fs::write(- shell.with_file_name(".codex-executable-identity-fixture"),- b"fake shell",- )?;- }- let other_shell = if matches!(- attack,- ShellAttack::SessionApprovalDoesNotTrustDifferentShell- ) {- let other_shell = test.workspace_path("another").join(shell_name);- fs::create_dir_all(other_shell.parent().expect("alternate shell directory"))?;- fs::copy(&shell, &other_shell)?;- #[cfg(windows)]- fs::write(- other_shell.with_file_name(".codex-executable-identity-fixture"),- b"fake shell",- )?;- Some(other_shell)- } else {- None- };- let call_id = "untrusted-shell-path";- let other_call_id = "different-untrusted-shell-path";- let command = match attack {- ShellAttack::ExactShellName if cfg!(windows) => "Write-Output $env:USERNAME",- ShellAttack::DangerousCommandOnRequest | ShellAttack::DangerousCommandNever => {- if cfg!(windows) {- "Remove-Item important -Force"- } else {- "rm -rf important"- }- }- ShellAttack::ExactShellNameWithForbiddenInnerCommand => {- if cfg!(windows) {- r"echo shell-safe && Remove-Item C:\important"- } else {- "echo shell-safe; rm important"- }- }- ShellAttack::ExactShellName- | ShellAttack::ExactShellNameWithAllowedInnerCommand- | ShellAttack::ApprovedCustomShell- | ShellAttack::SessionApprovalDoesNotTrustDifferentShell- | ShellAttack::SpoofedShellExtension => "echo shell-safe",- };-- mount_sse_once(- &server,- sse(vec![- ev_response_created("resp-untrusted-shell-1"),- ev_function_call(- call_id,- "exec_command",- &json!({ "cmd": command, "shell": shell }).to_string(),- ),- ev_completed("resp-untrusted-shell-1"),- ]),- )- .await;- if let Some(other_shell) = other_shell.as_ref() {- mount_sse_once(- &server,- sse(vec![- ev_response_created("resp-different-untrusted-shell"),- ev_function_call(- other_call_id,- "exec_command",- &json!({ "cmd": command, "shell": other_shell }).to_string(),- ),- ev_completed("resp-different-untrusted-shell"),- ]),- )- .await;- }- let completed = mount_sse_once(- &server,- sse(vec![- ev_assistant_message("msg-untrusted-shell", "done"),- ev_completed("resp-untrusted-shell-2"),- ]),- )- .await;-- let (sandbox_policy, permission_profile) =- turn_permission_fields(PermissionProfile::Disabled, test.config.cwd.as_path());- test.codex- .start_or_steer_turn(- TurnInputRequest::user_input(vec![UserInput::Text {- text: "inspect the repository".to_string(),- text_elements: Vec::new(),- }])- .with_thread_settings(ThreadSettingsOverrides {- approval_policy: Some(approval_policy),- approvals_reviewer: Some(ApprovalsReviewer::User),- sandbox_policy: Some(sandbox_policy),- permission_profile,- ..Default::default()- }),- )- .await?;-- let event = wait_for_event(&test.codex, |event| {- matches!(- event,- EventMsg::ExecApprovalRequest(_) | EventMsg::TurnComplete(_)- )- })- .await;- if matches!(- attack,- ShellAttack::ExactShellNameWithForbiddenInnerCommand | ShellAttack::DangerousCommandNever- ) {- assert!(matches!(event, EventMsg::TurnComplete(_)));- let output = completed- .single_request()- .function_call_output_text(call_id)- .expect("forbidden command output");- assert!(- output.contains("rejected"),- "the forbidden command should be rejected: {output}"- );- #[cfg(windows)]- if matches!(attack, ShellAttack::ExactShellNameWithForbiddenInnerCommand) {- assert!(- output.contains("Remove-Item"),- "the forbidden PowerShell command should remain visible to policy: {output}"- );- }- } else {- let EventMsg::ExecApprovalRequest(approval) = event else {- panic!("workspace shell bypassed approval");- };- assert_eq!(approval.call_id, call_id);- assert!(!marker.exists(), "the shell ran before approval");-- test.codex- .submit(Op::ExecApproval {- id: approval.effective_approval_id(),- turn_id: None,- decision: match attack {- ShellAttack::ApprovedCustomShell => ReviewDecision::Approved,- ShellAttack::SessionApprovalDoesNotTrustDifferentShell => {- ReviewDecision::ApprovedForSession- }- _ => ReviewDecision::denied("untrusted shell"),- },- })- .await?;- if other_shell.is_some() {- let event = wait_for_event(&test.codex, |event| {- matches!(- event,- EventMsg::ExecApprovalRequest(_) | EventMsg::TurnComplete(_)- )- })- .await;- let EventMsg::ExecApprovalRequest(approval) = event else {- panic!("a different workspace shell reused the first shell's session approval");- };- assert_eq!(approval.call_id, other_call_id);- assert!(- marker.exists(),- "the session-approved shell should have run"- );- test.codex- .submit(Op::ExecApproval {- id: approval.effective_approval_id(),- turn_id: None,- decision: ReviewDecision::denied("different untrusted shell"),- })- .await?;- }- wait_for_event(&test.codex, |event| {- matches!(event, EventMsg::TurnComplete(_))- })- .await;- }-- assert_eq!(- marker.exists(),- matches!(- attack,- ShellAttack::ApprovedCustomShell- | ShellAttack::SessionApprovalDoesNotTrustDifferentShell- ),- "only an explicitly approved custom shell should run"- );- Ok(())-}diff --git a/codex-rs/core/tests/suite/mod.rs b/codex-rs/core/tests/suite/mod.rsindex ee7a971fd9..ac6014729e 100644--- a/codex-rs/core/tests/suite/mod.rs+++ b/codex-rs/core/tests/suite/mod.rs@@ -16,21 +16,6 @@ use ctor::ctor;#[ctor]pub static CODEX_ALIASES_TEMP_DIR: Option<TestBinaryDispatchGuard> = {configure_test_binary_dispatch("codex-core-tests", |exe_name, argv1| {- #[cfg(windows)]- if exe_name.eq_ignore_ascii_case("powershell.exe")- || exe_name.eq_ignore_ascii_case("powershell.evil")- || exe_name.eq_ignore_ascii_case("pwsh.exe")- {- let executable = std::env::current_exe().expect("locate fake PowerShell executable");- if executable- .with_file_name(".codex-executable-identity-fixture")- .is_file()- {- let marker = executable.with_file_name("attacker-executed");- std::fs::write(marker, b"ran").expect("record fake PowerShell execution");- std::process::exit(0);- }- }if argv1 == Some(CODEX_CORE_APPLY_PATCH_ARG1) {return TestBinaryDispatchMode::DispatchArg0Only;}@@ -77,7 +62,6 @@ mod cyber_exec_policy;mod deprecation_notice;mod exec;mod exec_policy;-mod executable_identity;#[cfg(not(target_os = "windows"))]mod extension_sandbox;mod external_auth;diff --git a/codex-rs/core/tests/suite/network_approval.rs b/codex-rs/core/tests/suite/network_approval.rsindex 03f4a8b650..6db81300d4 100644--- a/codex-rs/core/tests/suite/network_approval.rs+++ b/codex-rs/core/tests/suite/network_approval.rs@@ -3,6 +3,8 @@ use anyhow::Result;use codex_config::types::ApprovalsReviewer;use codex_core::TurnInputRequest;use codex_core::config::Constrained;+use codex_core::shell::ShellType;+use codex_core::shell::get_shell;use codex_exec_server::CreateDirectoryOptions;use codex_exec_server::LOCAL_ENVIRONMENT_ID;use codex_exec_server::REMOTE_ENVIRONMENT_ID;@@ -96,6 +98,9 @@ async fn guardian_network_approval_preserves_action_and_outcome_routing() -> Res.context("expected network command")?.to_string();let second_command = first_command.clone();+ let expected_command = get_shell(ShellType::Sh)+ .context("expected local sh")?+ .derive_exec_args(&first_command, /*use_login_shell*/ false);let denial = "The destination is outside the approved test boundary.";let responses = mount_sse_sequence(&server,@@ -178,7 +183,7 @@ async fn guardian_network_approval_preserves_action_and_outcome_routing() -> Res"tool": "network_access","trigger": {"callId": first_call_id,- "command": ["/bin/sh", "-c", first_command],+ "command": expected_command,"cwd": test.config.cwd,"sandboxPermissions": "use_default","toolName": "exec_command",@@ -1869,12 +1874,18 @@ async fn remote_guardian_network_decisions_are_scoped_to_each_request_and_enviro.await.context("remote session approval should bypass another network prompt")?;+ let local_shell = get_shell(ShellType::Sh).context("expected local sh")?;let mut expected_actions = Vec::with_capacity(cases.len());for (call_id, command, environment, _, _) in &cases {let cwd = environment.cwd.to_abs_path().with_context(|| format!("resolve the environment cwd for {call_id}"))?;+ let command = if environment.environment_id == LOCAL_ENVIRONMENT_ID {+ local_shell.derive_exec_args(command, /*use_login_shell*/ false)+ } else {+ vec!["/bin/sh".to_string(), "-c".to_string(), command.clone()]+ };expected_actions.push(json!({"host": NETWORK_TEST_HOST,"port": 80,@@ -1883,7 +1894,7 @@ async fn remote_guardian_network_decisions_are_scoped_to_each_request_and_enviro"tool": "network_access","trigger": {"callId": call_id,- "command": ["/bin/sh", "-c", command],+ "command": command,"cwd": cwd,"sandboxPermissions": "use_default","toolName": "exec_command",diff --git a/codex-rs/shell-command/src/shell_detect.rs b/codex-rs/shell-command/src/shell_detect.rsindex 69a66f0563..2545bf09b0 100644--- a/codex-rs/shell-command/src/shell_detect.rs+++ b/codex-rs/shell-command/src/shell_detect.rs@@ -134,14 +134,9 @@ fn file_exists(path: &std::path::Path) -> Option<PathBuf> {fn get_shell_path(shell_type: ShellType,- provided_path: Option<&PathBuf>,binary_name: &str,fallback_paths: &[&str],) -> Option<PathBuf> {- if let Some(path) = provided_path.and_then(|path| file_exists(path)) {- return Some(path);- }-let default_shell_path = get_user_shell_path();if let Some(default_shell_path) = default_shell_path&& detect_shell_type(&default_shell_path) == Some(shell_type)@@ -165,8 +160,8 @@ fn get_shell_path(const ZSH_FALLBACK_PATHS: &[&str] = &["/bin/zsh"];-fn get_zsh_shell(path: Option<&PathBuf>) -> Option<DetectedShell> {- let shell_path = get_shell_path(ShellType::Zsh, path, "zsh", ZSH_FALLBACK_PATHS);+fn get_zsh_shell() -> Option<DetectedShell> {+ let shell_path = get_shell_path(ShellType::Zsh, "zsh", ZSH_FALLBACK_PATHS);shell_path.map(|shell_path| DetectedShell {shell_type: ShellType::Zsh,@@ -176,8 +171,8 @@ fn get_zsh_shell(path: Option<&PathBuf>) -> Option<DetectedShell> {const BASH_FALLBACK_PATHS: &[&str] = &["/bin/bash", "/usr/bin/bash"];-fn get_bash_shell(path: Option<&PathBuf>) -> Option<DetectedShell> {- let shell_path = get_shell_path(ShellType::Bash, path, "bash", BASH_FALLBACK_PATHS);+fn get_bash_shell() -> Option<DetectedShell> {+ let shell_path = get_shell_path(ShellType::Bash, "bash", BASH_FALLBACK_PATHS);shell_path.map(|shell_path| DetectedShell {shell_type: ShellType::Bash,@@ -187,8 +182,8 @@ fn get_bash_shell(path: Option<&PathBuf>) -> Option<DetectedShell> {const SH_FALLBACK_PATHS: &[&str] = &["/bin/sh"];-fn get_sh_shell(path: Option<&PathBuf>) -> Option<DetectedShell> {- let shell_path = get_shell_path(ShellType::Sh, path, "sh", SH_FALLBACK_PATHS);+fn get_sh_shell() -> Option<DetectedShell> {+ let shell_path = get_shell_path(ShellType::Sh, "sh", SH_FALLBACK_PATHS);shell_path.map(|shell_path| DetectedShell {shell_type: ShellType::Sh,@@ -212,12 +207,11 @@ const POWERSHELL_FALLBACK_PATHS: &[&str] =#[cfg(not(windows))]const POWERSHELL_FALLBACK_PATHS: &[&str] = &[];-fn get_powershell_shell(path: Option<&PathBuf>) -> Option<DetectedShell> {- let shell_path = get_shell_path(ShellType::PowerShell, path, "pwsh", PWSH_FALLBACK_PATHS)- .or_else(|| {+fn get_powershell_shell() -> Option<DetectedShell> {+ let shell_path =+ get_shell_path(ShellType::PowerShell, "pwsh", PWSH_FALLBACK_PATHS).or_else(|| {get_shell_path(ShellType::PowerShell,- path,"powershell",POWERSHELL_FALLBACK_PATHS,)@@ -229,8 +223,8 @@ fn get_powershell_shell(path: Option<&PathBuf>) -> Option<DetectedShell> {})}-fn get_cmd_shell(path: Option<&PathBuf>) -> Option<DetectedShell> {- let shell_path = get_shell_path(ShellType::Cmd, path, "cmd", &[]);+fn get_cmd_shell() -> Option<DetectedShell> {+ let shell_path = get_shell_path(ShellType::Cmd, "cmd", &[]);shell_path.map(|shell_path| DetectedShell {shell_type: ShellType::Cmd,@@ -252,19 +246,20 @@ pub fn ultimate_fallback_shell() -> DetectedShell {}}+/// Uses the model-provided path only to select a shell type, then discovers its executable.pub fn get_shell_by_model_provided_path(shell_path: &PathBuf) -> DetectedShell {detect_shell_type(shell_path)- .and_then(|shell_type| get_shell(shell_type, Some(shell_path)))+ .and_then(get_shell).unwrap_or_else(ultimate_fallback_shell)}-pub fn get_shell(shell_type: ShellType, path: Option<&PathBuf>) -> Option<DetectedShell> {+pub fn get_shell(shell_type: ShellType) -> Option<DetectedShell> {match shell_type {- ShellType::Zsh => get_zsh_shell(path),- ShellType::Bash => get_bash_shell(path),- ShellType::PowerShell => get_powershell_shell(path),- ShellType::Sh => get_sh_shell(path),- ShellType::Cmd => get_cmd_shell(path),+ ShellType::Zsh => get_zsh_shell(),+ ShellType::Bash => get_bash_shell(),+ ShellType::PowerShell => get_powershell_shell(),+ ShellType::Sh => get_sh_shell(),+ ShellType::Cmd => get_cmd_shell(),}}@@ -274,20 +269,20 @@ pub fn default_user_shell() -> DetectedShell {pub fn default_user_shell_from_path(user_shell_path: Option<PathBuf>) -> DetectedShell {if cfg!(windows) {- get_shell(ShellType::PowerShell, /*path*/ None).unwrap_or_else(ultimate_fallback_shell)+ get_shell(ShellType::PowerShell).unwrap_or_else(ultimate_fallback_shell)} else {let user_default_shell = user_shell_path.and_then(|shell| detect_shell_type(&shell))- .and_then(|shell_type| get_shell(shell_type, /*path*/ None));+ .and_then(get_shell);let shell_with_fallback = if cfg!(target_os = "macos") {user_default_shell- .or_else(|| get_shell(ShellType::Zsh, /*path*/ None))- .or_else(|| get_shell(ShellType::Bash, /*path*/ None))+ .or_else(|| get_shell(ShellType::Zsh))+ .or_else(|| get_shell(ShellType::Bash))} else {user_default_shell- .or_else(|| get_shell(ShellType::Bash, /*path*/ None))- .or_else(|| get_shell(ShellType::Zsh, /*path*/ None))+ .or_else(|| get_shell(ShellType::Bash))+ .or_else(|| get_shell(ShellType::Zsh))};shell_with_fallback.unwrap_or_else(ultimate_fallback_shell)