Worktrunk is a CLI for Git worktree management, designed for parallel AI agent workflows
fix(shell): detect the current shell from the process tree, not $SHELL (#3455)
Maximilian Roosa6972e4be04f
diff --git a/plugins/worktrunk/skills/worktrunk/reference/shell-integration.md b/plugins/worktrunk/skills/worktrunk/reference/shell-integration.mdindex 570b83da4..b7039915e 100644--- a/plugins/worktrunk/skills/worktrunk/reference/shell-integration.md+++ b/plugins/worktrunk/skills/worktrunk/reference/shell-integration.md@@ -60,16 +60,22 @@ When shell integration isn't working, `wt switch` shows warnings explaining why.### "shell integration not installed"-**Meaning**: The shell config file doesn't have the `eval "$(wt config shell init ...)"` line.+**Meaning**: The current shell's config file doesn't have the+`eval "$(wt config shell init ...)"` line. The current shell is detected from+the process tree (falling back to `$SHELL`), so this refers to the shell wt+was actually invoked from, not necessarily the login shell.**Fix**: Run `wt config shell install` or add the line manually.-### "shell requires restart"+### "shell integration installed but not active"-**Meaning**: Shell integration is configured, but the current shell session was-started before installation. The shell function isn't loaded yet.+**Meaning**: Shell integration is configured for the current shell, but the+shell function isn't loaded in this session — usually because the session was+started before installation.-**Fix**: Start a new terminal or run `source ~/.bashrc` (or equivalent).+**Fix**: Start a new terminal or run `source ~/.bashrc` (or equivalent). If+the message persists after a restart, `wt config show` reports the detected+shell, `$SHELL`, and per-shell integration status.### "ran ./path/to/wt; shell integration wraps wt"diff --git a/skills/worktrunk/reference/shell-integration.md b/skills/worktrunk/reference/shell-integration.mdindex 570b83da4..b7039915e 100644--- a/skills/worktrunk/reference/shell-integration.md+++ b/skills/worktrunk/reference/shell-integration.md@@ -60,16 +60,22 @@ When shell integration isn't working, `wt switch` shows warnings explaining why.### "shell integration not installed"-**Meaning**: The shell config file doesn't have the `eval "$(wt config shell init ...)"` line.+**Meaning**: The current shell's config file doesn't have the+`eval "$(wt config shell init ...)"` line. The current shell is detected from+the process tree (falling back to `$SHELL`), so this refers to the shell wt+was actually invoked from, not necessarily the login shell.**Fix**: Run `wt config shell install` or add the line manually.-### "shell requires restart"+### "shell integration installed but not active"-**Meaning**: Shell integration is configured, but the current shell session was-started before installation. The shell function isn't loaded yet.+**Meaning**: Shell integration is configured for the current shell, but the+shell function isn't loaded in this session — usually because the session was+started before installation.-**Fix**: Start a new terminal or run `source ~/.bashrc` (or equivalent).+**Fix**: Start a new terminal or run `source ~/.bashrc` (or equivalent). If+the message persists after a restart, `wt config show` reports the detected+shell, `$SHELL`, and per-shell integration status.### "ran ./path/to/wt; shell integration wraps wt"diff --git a/src/commands/config/show.rs b/src/commands/config/show.rsindex 9c9637052..34514e78d 100644--- a/src/commands/config/show.rs+++ b/src/commands/config/show.rs@@ -1200,11 +1200,22 @@ fn render_shell_status(out: &mut String) -> anyhow::Result<()> {}}+ // Show the shell actually running wt — the process tree names the+ // interactive shell even when $SHELL points at a different login shell+ let ancestor = worktrunk::shell::ancestor_shell();+ if let Some(ancestor) = ancestor {+ debug_lines.push(cformat!(+ "Detected shell: <bold>{}</> (process tree)",+ ancestor.name+ ));+ }// Show $SHELL to help diagnose rc file sourcing issueslet shell_env = std::env::var("SHELL").ok().filter(|s| !s.is_empty());if let Some(shell_env) = &shell_env {debug_lines.push(cformat!("$SHELL: <bold>{shell_env}</>"));- } else if let Some(detected) = worktrunk::shell::current_shell() {+ } else if ancestor.is_none()+ && let Some(detected) = worktrunk::shell::current_shell()+ {debug_lines.push(cformat!("Detected shell: <bold>{detected}</> (via PSModulePath)"));diff --git a/src/commands/configure_shell.rs b/src/commands/configure_shell.rsindex d00a1e659..266362ffe 100644--- a/src/commands/configure_shell.rs+++ b/src/commands/configure_shell.rs@@ -333,11 +333,13 @@ pub fn handle_configure_shell(//// We check when:// - User explicitly runs `install zsh` (they clearly want zsh integration)- // - User runs `install` (all shells) AND their $SHELL is zsh (they use zsh daily)+ // - User runs `install` (all shells) AND their current shell (process+ // tree, falling back to $SHELL) is zsh (they use zsh daily)//// We skip if:- // - User runs `install` but their $SHELL is bash/fish (they may be configuring- // zsh for occasional use; don't nag about their non-primary shell)+ // - User runs `install` but their current shell is bash/fish (they may be+ // configuring zsh for occasional use; don't nag about their non-primary+ // shell)// - Zsh was already configured (AlreadyExists) - they've seen this beforelet zsh_was_configured = result.configureddiff --git a/src/output/shell_integration.rs b/src/output/shell_integration.rsindex 567dd740e..1b164ba3f 100644--- a/src/output/shell_integration.rs+++ b/src/output/shell_integration.rs@@ -9,7 +9,7 @@//! | Condition | Warning | Hint |//! |-----------|---------|------|//! | Not installed | `Worktree for X @ path, but cannot change directory — shell integration not installed` | `To enable automatic cd, run wt config shell install` |-//! | Needs restart | `Worktree for X @ path, but cannot change directory — shell requires restart` | `Restart shell to activate shell integration` |+//! | Installed, not active | `Worktree for X @ path, but cannot change directory — shell integration installed but not active` | `A shell restart usually activates shell integration; if it doesn't, ask an agent to debug with the docs @ https://worktrunk.dev/llms.txt` |//! | Explicit path | `Worktree for X @ path, but cannot change directory — ran ./wt; shell integration wraps wt` | `To change directory, run wt switch X` |//! | Git subcommand | `Worktree for X @ path, but cannot change directory — ran git wt; running through git prevents cd` | `For automatic cd, invoke directly (with the -): git-wt` |//!@@ -41,8 +41,8 @@//! |-----------|--------|//! | Git subcommand | Return early (warning already shown) |//! | Unsupported shell | Hint: `Shell integration not yet supported for <shell>` |-//! | $SHELL not set | Hint: `To enable automatic cd, run wt config shell install` |-//! | Current shell already installed | Hint: `Restart shell to activate shell integration` |+//! | No shell detected | Hint: `To enable automatic cd, run wt config shell install` |+//! | Current shell already installed | Hint: `A shell restart usually activates shell integration; …` |//! | `skip-shell-integration-prompt` / Non-TTY | Hint: `To enable automatic cd, run wt config shell install` |//! | TTY | Prompt: `Install shell integration? [y/N/?]` |//!@@ -53,7 +53,7 @@//! | Reason | Meaning |//! |--------|---------|//! | `shell integration not installed` | Shell config doesn't have the `eval` line |-//! | `shell requires restart` | Shell config has `eval` line but wrapper not active |+//! | `shell integration installed but not active` | Shell config has `eval` line but wrapper not active |//! | `ran X; shell integration wraps Y` | Invoked with explicit path (e.g., `./target/debug/wt`) |//!//! Note: The git subcommand case (`ran git wt; ...`) is handled separately via [`crate::is_git_subcommand`].@@ -64,7 +64,7 @@ use color_print::cformat;use worktrunk::config::{UserConfig, require_config_path};use worktrunk::git::Repository;use worktrunk::path::format_path_for_display;-use worktrunk::shell::{Shell, current_shell, current_shell_name, extract_filename_from_path};+use worktrunk::shell::{Shell, current_shell, current_shell_name};use worktrunk::styling::{eprintln, format_bash_with_gutter, hint_message, info_message, success_message, warning_message,};@@ -109,16 +109,26 @@ pub(crate) fn print_shell_integration_hint(repo: &Repository) {let _ = repo.mark_hint_shown(SHELL_INTEGRATION_HINT);}-/// Hint when shell integration is installed but shell needs restart.+/// Hint shown right after installing: the wrapper cannot be active yet, so+/// the restart advice is unconditional.pub(crate) fn shell_restart_hint() -> &'static str {"Restart shell to activate shell integration"}+/// Hint when integration is installed for the current shell but the wrapper+/// didn't intercept this invocation. Hedged: shell detection can still be+/// wrong (non-interactive contexts, exotic nesting), so restart is presented+/// as the likely fix with an escape hatch, not a certainty. The escape hatch+/// points at the LLM docs index, which any agent can fetch — unlike the+/// `/worktrunk` skill, which only plugin users have.+pub(crate) fn shell_inactive_hint() -> String {+ cformat!(+ "A shell restart usually activates shell integration; if it doesn't, ask an agent to debug with the docs @ <underline>https://worktrunk.dev/llms.txt</>"+ )+}+/// Shell integration hint for unknown/unsupported shell.-fn shell_integration_unsupported_shell(shell_path: &str) -> String {- // Extract shell name from path, handling both Unix and Windows paths- // e.g., "/bin/tcsh" -> "tcsh", "C:\...\tcsh.exe" -> "tcsh"- let shell_name = extract_filename_from_path(shell_path).unwrap_or(shell_path);+fn shell_integration_unsupported_shell(shell_name: &str) -> String {format!("Shell integration not yet supported for {shell_name} (supports bash, zsh, fish, nu, PowerShell)")@@ -150,10 +160,10 @@ pub(crate) fn should_show_explicit_path_hint() -> bool {/// Returns a reason string explaining why shell integration isn't working./// See the module documentation for the complete spec of warning messages.///-/// Checks specifically if the CURRENT shell (detected via $SHELL or PSModulePath-/// fallback) has integration configured, not just any shell. This prevents misleading-/// "shell requires restart" messages when e.g. bash has integration but the user is-/// running fish.+/// Checks specifically if the CURRENT shell (detected via the process tree,+/// falling back to $SHELL / PSModulePath) has integration configured, not just+/// any shell. This prevents misleading "restart" advice when e.g. bash has+/// integration but the user is running fish.pub(crate) fn compute_shell_warning_reason() -> String {// Check if the CURRENT shell has integration configured, not just ANY shelllet is_configured = current_shell()@@ -204,7 +214,7 @@ fn compute_shell_warning_reason_inner(cformat!("ran <bold>{invoked_name}</>; shell integration wraps <bold>{wraps}</>")}} else {- "shell requires restart".to_string()+ "shell integration installed but not active".to_string()}} else {"shell integration not installed".to_string()@@ -363,19 +373,19 @@ pub fn print_shell_install_result(scan_result: &crate::commands::configure_shell);}- // Restart hint for current shell+ // Restart hint for current shell. Compare Shell values, not display+ // names — the detected name can be "pwsh" or "zsh-5.9", which would+ // never equal the canonical "powershell"/"zsh" strings.if shells_configured_count > 0 {- let current_shell = current_shell_name();-- let current_shell_result = current_shell.as_ref().and_then(|shell_name| {+ let current_shell_configured = current_shell().is_some_and(|shell| {scan_result.configured.iter().filter(|r| !matches!(r.action, ConfigAction::AlreadyExists))- .find(|r| r.shell.to_string().eq_ignore_ascii_case(shell_name))+ .any(|r| r.shell == shell)});- if current_shell_result.is_some() {+ if current_shell_configured {eprintln!("{}", hint_message(shell_restart_hint()));}}@@ -405,18 +415,17 @@ pub fn prompt_shell_integration(let is_tty = std::io::stdin().is_terminal() && std::io::stderr().is_terminal();- // Check the current shell (via $SHELL or PSModulePath fallback)- // Only prompt if current shell is supported (so they benefit immediately)- let shell_env = std::env::var("SHELL").ok();+ // Check the current shell (via the process tree, falling back to $SHELL /+ // PSModulePath). Only prompt if it's supported (so they benefit immediately).if current_shell().is_none() {- match &shell_env {- Some(path) => {+ match current_shell_name() {+ Some(name) => {eprintln!("{}",- hint_message(shell_integration_unsupported_shell(path))+ hint_message(shell_integration_unsupported_shell(&name)));}- // $SHELL not set: could be Windows PowerShell, or unusual Unix setup+ // No shell detected: could be Windows PowerShell, or unusual Unix setup// Point them to manual installation (and count it as a shown install hint)None => print_shell_integration_hint(repo),}@@ -444,8 +453,8 @@ pub fn prompt_shell_integration(if current_shell_installed {// Shell integration is configured but not active for this invocationif !crate::was_invoked_with_explicit_path() {- // Invoked via PATH but wrapper isn't active - needs shell restart- eprintln!("{}", hint_message(shell_restart_hint()));+ // Invoked via PATH but wrapper isn't active — a restart usually fixes it+ eprintln!("{}", hint_message(shell_inactive_hint()));}// For explicit paths: no hint needed - handle_switch_output() warning already explainsreturn Ok(false);@@ -584,15 +593,11 @@ pub fn print_shell_uninstall_result(scan_result: &UninstallScanResult, explicit_)));- // Hint about restarting shell (only if current shell was affected)- let current_shell = current_shell_name();-- let current_shell_affected = current_shell.as_ref().is_some_and(|shell_name| {- scan_result- .results- .iter()- .any(|r| r.shell.to_string().eq_ignore_ascii_case(shell_name))- });+ // Hint about restarting shell (only if current shell was affected).+ // Compare Shell values, not display names — the detected name can be+ // "pwsh" or "zsh-5.9", which would never equal "powershell"/"zsh".+ let current_shell_affected =+ current_shell().is_some_and(|shell| scan_result.results.iter().any(|r| r.shell == shell));if current_shell_affected {eprintln!("{}", hint_message("Restart shell to complete uninstall"));@@ -647,9 +652,9 @@ mod tests {let reason = compute_shell_warning_reason_inner(true, true, "/usr/local/bin/git-wt", "wt");assert_snapshot!(reason, @"ran [1mgit-wt[22m; shell integration wraps [1mwt[22m");- // Shell integration configured + NOT explicit path -> "shell requires restart"+ // Shell integration configured + NOT explicit path -> installed but not activelet reason = compute_shell_warning_reason_inner(true, false, "wt", "wt");- assert_eq!(reason, "shell requires restart");+ assert_eq!(reason, "shell integration installed but not active");}#[test]diff --git a/src/shell/detection.rs b/src/shell/detection.rsindex 9cea3dac5..02d018b83 100644--- a/src/shell/detection.rs+++ b/src/shell/detection.rs@@ -77,7 +77,7 @@ use super::paths::{home_dir_required, powershell_profile_paths};/// detection is needed.////// **When binary is run directly (wrapper not active):**-/// - If detection finds integration → "restart the shell to activate"+/// - If detection finds integration → "installed but not active" (restart hint)/// - If detection misses (false negative) → "shell integration not installed"////// **When wrapper is active:** No warnings shown regardless of detection.diff --git a/src/shell/mod.rs b/src/shell/mod.rsindex 9a6f54b40..14a28b8e1 100644--- a/src/shell/mod.rs+++ b/src/shell/mod.rs@@ -20,7 +20,8 @@ pub use detection::{};pub use paths::{completion_path, config_paths, legacy_fish_conf_d_path};pub use utils::{- current_shell, current_shell_name, detect_zsh_compinit, extract_filename_from_path,+ AncestorShell, ancestor_shell, current_shell, current_shell_name, detect_zsh_compinit,+ extract_filename_from_path,};/// Supported shells@@ -179,7 +180,8 @@ impl Shell {/// Check if this shell has integration configured.////// Used for accurate warning messages that need to know about the user's- /// current shell specifically (e.g., "shell requires restart" vs "not installed").+ /// current shell specifically (e.g., "installed but not active" vs "not+ /// installed").pub fn is_shell_configured(&self, cmd: &str) -> Result<bool, std::io::Error> {let config_paths = self.config_paths(cmd)?;diff --git a/src/shell/utils.rs b/src/shell/utils.rsindex 5ddf3305b..69e36980e 100644--- a/src/shell/utils.rs+++ b/src/shell/utils.rs@@ -32,63 +32,80 @@ pub fn extract_filename_from_path(path: &str) -> Option<&str> {/// Determine Shell variant from a shell name (without path or extension).///-/// Handles versioned/prefixed binaries like `zsh-5.9` or `bash5`-/// by checking if the name starts with a known shell.+/// Handles versioned binaries like `zsh-5.9` or `bash5` by accepting a known+/// shell name followed by a non-alphabetic character. The boundary check+/// keeps unrelated commands that merely start with a shell name (`fishd`,+/// `bashtop`, `numactl`) from matching — important now that names also come+/// from the process-tree walk, not just `$SHELL`.pub fn shell_from_name(shell_name: &str) -> Option<Shell> {// Try exact match firstif let Ok(shell) = shell_name.parse() {return Some(shell);}- // Handle versioned/prefixed binaries (e.g., "zsh-5.9", "bash5")- // Check if shell name starts with a known shelllet name_lower = shell_name.to_lowercase();- if name_lower.starts_with("zsh") {- Some(Shell::Zsh)- } else if name_lower.starts_with("bash") {- Some(Shell::Bash)- } else if name_lower.starts_with("fish") {- Some(Shell::Fish)- } else if name_lower.starts_with("nu") {- Some(Shell::Nushell)- } else if name_lower.starts_with("pwsh") || name_lower.starts_with("powershell") {- Some(Shell::PowerShell)- } else {- None+ // "nushell" precedes "nu" so its remainder isn't rejected as alphabetic.+ for (prefix, shell) in [+ ("powershell", Shell::PowerShell),+ ("pwsh", Shell::PowerShell),+ ("nushell", Shell::Nushell),+ ("nu", Shell::Nushell),+ ("bash", Shell::Bash),+ ("zsh", Shell::Zsh),+ ("fish", Shell::Fish),+ ] {+ if name_matches_shell(&name_lower, prefix) {+ return Some(shell);+ }}+ None}-/// Read `$SHELL` and extract the executable name (e.g. `/usr/bin/zsh` -> "zsh").+/// Display name of the current shell.///-/// Returns `None` when `$SHELL` is unset or has no extractable filename.+/// Prefers the process-tree walk (the shell wt is actually running under,+/// possibly an unsupported one like "tcsh"); falls back to the `$SHELL`+/// basename. Returns `None` when neither source names a shell.pub fn current_shell_name() -> Option<String> {+ if let Some(ancestor) = ancestor_shell() {+ return Some(ancestor.name.clone());+ }+ shell_name_from_env()+}++/// Read `$SHELL` and extract the executable name (e.g. `/usr/bin/zsh` -> "zsh").+fn shell_name_from_env() -> Option<String> {let shell_path = std::env::var("SHELL").ok()?;extract_filename_from_path(&shell_path).map(String::from)}-/// Detect the current shell from the environment.-///-/// Uses two strategies:-/// 1. `$SHELL` environment variable (Unix standard, also set by Git Bash on Windows)-/// 2. `PSModulePath` environment variable (indicates PowerShell on all platforms)+/// Detect the shell wt is running under.///-/// Returns `None` if neither heuristic matches a known shell.-///-/// Works on both Unix and Windows:-/// - Unix: `/usr/bin/bash` -> Bash-/// - Windows Git Bash: `C:\Program Files\Git\usr\bin\bash.exe` -> Bash-/// - Windows PowerShell: `PSModulePath` set -> PowerShell+/// Uses three strategies, most reliable first:+/// 1. Process-tree walk: the nearest enclosing shell process. `$SHELL` names+/// the *login* shell, which is wrong whenever the interactive shell+/// differs (bash launched from zsh, a terminal profile running fish), so+/// the process tree is consulted first. A known-but-unsupported enclosing+/// shell (e.g. tcsh) returns `None` here — falling back to `$SHELL` would+/// reintroduce the wrong-shell answer; `current_shell_name()` still names+/// it for messages.+/// 2. `$SHELL` environment variable (Unix standard, also set by Git Bash on+/// Windows), when the walk finds no shell (unsupported platform, wt+/// spawned outside any shell).+/// 3. `PSModulePath` environment variable (indicates PowerShell on all+/// platforms). On Windows this has some false positives (PSModulePath can+/// be set system-wide), but for diagnostic purposes that's acceptable — a+/// slightly less accurate message is better than "shell integration not+/// installed" when it IS installed.pub fn current_shell() -> Option<Shell> {- // Primary: $SHELL (Unix standard, also set by Git Bash on Windows)- if let Some(name) = current_shell_name() {+ if let Some(ancestor) = ancestor_shell() {+ return ancestor.shell;+ }++ if let Some(name) = shell_name_from_env() {return shell_from_name(&name);}- // Fallback: PSModulePath indicates PowerShell (set on all platforms when- // running inside PowerShell). On Windows this has some false positives- // (PSModulePath can be set system-wide), but for diagnostic purposes- // that's acceptable — a slightly less accurate message is better than- // "shell integration not installed" when it IS installed.if std::env::var_os("PSModulePath").is_some() {return Some(Shell::PowerShell);}@@ -96,6 +113,196 @@ pub fn current_shell() -> Option<Shell> {None}+/// Nearest enclosing shell process, found by walking up the process tree.+#[derive(Debug, Clone)]+pub struct AncestorShell {+ /// Process name as observed, login-shell `-` prefix stripped (e.g.+ /// "zsh", "tcsh").+ pub name: String,+ /// The parsed shell; `None` for a known-but-unsupported shell.+ pub shell: Option<Shell>,+}++/// Plain POSIX script interpreters: virtually never the interactive shell on+/// modern systems, so the walk treats them as plumbing (Makefiles, `sh -c`+/// wrappers) and keeps walking toward the real shell.+const TRANSPARENT_INTERPRETERS: &[&str] = &["sh", "dash", "ash", "busybox"];++/// Known interactive shells wt has no integration for. One of these stops the+/// walk — it IS the enclosing shell — but reports `shell: None` rather than+/// letting a supported shell further up the tree (or `$SHELL`) claim the+/// session.+const UNSUPPORTED_SHELLS: &[&str] = &[+ "tcsh", "csh", "ksh", "mksh", "oksh", "loksh", "yash", "elvish", "xonsh", "oil", "osh",+];++/// True when `name` is `prefix` optionally followed by a version-ish suffix:+/// "zsh" matches "zsh", "zsh-5.9", "zsh5" — but not "zshx" ("fishd",+/// "bashtop", and "numactl" must not read as shells).+///+/// The dash boundary is deliberately permissive so versioned binaries keep+/// matching (`zsh-5.9`, `pwsh-preview`); the cost is that a dashed tool name+/// starting with a shell name (`bash-language-server`, or its 15-char+/// `/proc` comm truncation `bash-language-s`) also classifies as that shell.+/// Acceptable: such tools don't sit in wt's interactive ancestor chain.+fn name_matches_shell(name: &str, prefix: &str) -> bool {+ name.strip_prefix(prefix)+ .is_some_and(|rest| !rest.chars().next().is_some_and(|c| c.is_ascii_alphabetic()))+}++/// Nearest enclosing shell process, cached for the invocation.+///+/// Walks up from wt's parent, passing through non-shell ancestors (`git` for+/// `git wt`, `sudo`, script runners) until it finds a known shell. Implemented+/// for Linux (`/proc/<pid>/stat`) and macOS (a `ps` snapshot); elsewhere+/// (Windows, BSDs) returns `None` and callers fall back to `$SHELL` /+/// `PSModulePath` — Git Bash sets `$SHELL` itself, so Windows loses little.+///+/// `WORKTRUNK_TEST_PARENT_SHELL` overrides the walk for tests: empty means "no+/// shell ancestor found" (integration tests run wt under a test harness whose+/// real ancestry would nondeterministically include the developer's or CI+/// runner's shell); a process name simulates finding that ancestor.+pub fn ancestor_shell() -> Option<&'static AncestorShell> {+ static ANCESTOR: std::sync::OnceLock<Option<AncestorShell>> = std::sync::OnceLock::new();+ ANCESTOR.get_or_init(detect_ancestor_shell).as_ref()+}++fn detect_ancestor_shell() -> Option<AncestorShell> {+ if let Some(value) = std::env::var_os("WORKTRUNK_TEST_PARENT_SHELL") {+ let name = value.to_str()?.trim();+ if name.is_empty() {+ return None;+ }+ return ancestor_from_name(name);+ }++ #[cfg(unix)]+ {+ walk_ancestors(std::os::unix::process::parent_id(), process_name_and_ppid)+ }+ #[cfg(not(unix))]+ {+ None+ }+}++/// Walk up the process tree from `pid`, looking each ancestor up in+/// `lookup`, until a shell stops the walk. Bounded: deep enough for wrappers+/// (git, sudo, script runners), small enough that a cycle or exotic tree+/// can't stall the warning path. An unreadable hop ends the walk — without a+/// parent pid there is nothing to continue from — and callers fall back to+/// `$SHELL`.+#[cfg(unix)]+fn walk_ancestors(+ mut pid: u32,+ lookup: impl Fn(u32) -> Option<(String, u32)>,+) -> Option<AncestorShell> {+ for _ in 0..16 {+ if pid <= 1 {+ return None;+ }+ let (name, ppid) = lookup(pid)?;+ tracing::debug!(pid, ppid, name, "shell ancestry hop");+ if let Some(found) = ancestor_from_name(&name) {+ return Some(found);+ }+ if ppid == pid {+ return None;+ }+ pid = ppid;+ }+ None+}++/// Classify a process name, returning the walk's result if it's a stop:+/// a supported or known-unsupported shell stops the walk; transparent+/// interpreters and non-shells return `None` (keep walking).+fn ancestor_from_name(name: &str) -> Option<AncestorShell> {+ // Login shells report argv[0] with a leading dash ("-zsh").+ let name = name.strip_prefix('-').unwrap_or(name);+ let lower = name.to_ascii_lowercase();+ if TRANSPARENT_INTERPRETERS.contains(&lower.as_str()) {+ return None;+ }+ let shell = if UNSUPPORTED_SHELLS+ .iter()+ .any(|s| name_matches_shell(&lower, s))+ {+ None+ } else {+ Some(shell_from_name(&lower)?)+ };+ Some(AncestorShell {+ name: name.to_string(),+ shell,+ })+}++/// Read (process name, parent pid) for `pid` from the OS process table.+///+/// `/proc/<pid>/stat` is `pid (comm) state ppid …`; comm may itself contain+/// spaces or parens, so parse from the last `)`.+#[cfg(target_os = "linux")]+fn process_name_and_ppid(pid: u32) -> Option<(String, u32)> {+ let stat = std::fs::read_to_string(format!("/proc/{pid}/stat")).ok()?;+ let open = stat.find('(')?;+ let close = stat.rfind(')')?;+ let name = stat.get(open + 1..close)?.to_string();+ // After ")": state, then ppid.+ let ppid = stat+ .get(close + 1..)?+ .split_whitespace()+ .nth(1)?+ .parse()+ .ok()?;+ Some((name, ppid))+}++/// Read (process name, parent pid) for `pid` from a one-shot `ps` snapshot.+///+/// macOS has no `/proc`, and the kernel's per-process `p_comm` carries the+/// executable image's name rather than the invoked name — `/bin/sh` re-execs+/// bash (via `/var/select/sh`), so an sh script's `p_comm` reads "bash" and+/// the sh-transparency rule would never fire. `ps`'s `comm` column preserves+/// argv\[0\] ("sh", "-zsh", "/bin/zsh"), which is the invoked identity the+/// classifier needs. One snapshot (a few ms, cold warning paths only) serves+/// the whole walk.+#[cfg(target_os = "macos")]+fn process_name_and_ppid(pid: u32) -> Option<(String, u32)> {+ static TABLE: std::sync::OnceLock<std::collections::HashMap<u32, (String, u32)>> =+ std::sync::OnceLock::new();+ TABLE.get_or_init(ps_snapshot).get(&pid).cloned()+}++/// Build the pid → (name, parent pid) table from one `ps` invocation.+#[cfg(target_os = "macos")]+fn ps_snapshot() -> std::collections::HashMap<u32, (String, u32)> {+ let Ok(output) = crate::shell_exec::Cmd::new("ps")+ .args(["-Ao", "pid=,ppid=,comm="])+ .run()+ else {+ return std::collections::HashMap::new();+ };+ String::from_utf8_lossy(&output.stdout)+ .lines()+ .filter_map(|line| {+ let mut fields = line.split_whitespace();+ let pid: u32 = fields.next()?.parse().ok()?;+ let ppid: u32 = fields.next()?.parse().ok()?;+ // comm is the remainder — argv[0] may be a path and may+ // contain spaces; keep the basename.+ let comm = fields.collect::<Vec<_>>().join(" ");+ let name = extract_filename_from_path(&comm)?.to_string();+ Some((pid, (name, ppid)))+ })+ .collect()+}++#[cfg(all(unix, not(any(target_os = "linux", target_os = "macos"))))]+fn process_name_and_ppid(_pid: u32) -> Option<(String, u32)> {+ None+}+/// Leading flags for the interactive zsh compinit probe.////// `+m` (disable job control) is load-bearing — see the call site and issue@@ -291,7 +498,126 @@ mod tests {#[case::pwsh_preview("pwsh-preview", Some(Shell::PowerShell))]#[case::unknown("tcsh", None)]#[case::unknown_csh("csh", None)]+ // Names that merely start with a shell name must not match — the+ // process-tree walk feeds arbitrary ancestor names through here.+ #[case::fish_daemon("fishd", None)]+ #[case::bashtop("bashtop", None)]+ #[case::numactl("numactl", None)]fn test_shell_from_name(#[case] name: &str, #[case] expected: Option<Shell>) {assert_eq!(shell_from_name(name), expected);}++ /// The walk stops at the nearest shell: supported shells parse, known+ /// unsupported shells stop the walk with `shell: None`, and plumbing+ /// (script interpreters, non-shells) is transparent.+ #[rstest]+ #[case::zsh("zsh", Some(Some(Shell::Zsh)))]+ #[case::login_zsh("-zsh", Some(Some(Shell::Zsh)))]+ #[case::login_bash("-bash", Some(Some(Shell::Bash)))]+ #[case::nix_versioned("zsh-5.9", Some(Some(Shell::Zsh)))]+ #[case::tcsh("tcsh", Some(None))]+ #[case::ksh("ksh", Some(None))]+ #[case::ksh93("ksh93", Some(None))]+ #[case::sh_transparent("sh", None)]+ #[case::dash_transparent("dash", None)]+ #[case::git_transparent("git", None)]+ #[case::terminal_transparent("iTerm2", None)]+ fn test_ancestor_from_name(#[case] name: &str, #[case] expected: Option<Option<Shell>>) {+ let result = ancestor_from_name(name);+ assert_eq!(result.as_ref().map(|a| a.shell), expected, "name: {name}");+ if let Some(ancestor) = result {+ assert!(+ !ancestor.name.starts_with('-'),+ "login-shell dash must be stripped: {}",+ ancestor.name+ );+ }+ }++ /// The ancestry walk stops at the nearest shell, passes through wrappers+ /// and transparent interpreters, and terminates on init, cycles,+ /// unreadable hops, and depth exhaustion.+ #[cfg(unix)]+ #[test]+ fn test_walk_ancestors() {+ use std::collections::HashMap;++ // wt's parent chain: sh (transparent) ← git (wrapper) ← -zsh (login)+ let table: HashMap<u32, (String, u32)> = HashMap::from([+ (10, ("sh".to_string(), 9)),+ (9, ("git".to_string(), 8)),+ (8, ("-zsh".to_string(), 1)),+ ]);+ let found = walk_ancestors(10, |pid| table.get(&pid).cloned())+ .expect("finds zsh through sh and git");+ assert_eq!(found.shell, Some(Shell::Zsh));+ assert_eq!(found.name, "zsh");++ // An unsupported shell stops the walk even with a supported shell+ // above it — the nearest enclosing shell owns the session.+ let table: HashMap<u32, (String, u32)> =+ HashMap::from([(10, ("tcsh".to_string(), 8)), (8, ("zsh".to_string(), 1))]);+ let found = walk_ancestors(10, |pid| table.get(&pid).cloned()).unwrap();+ assert_eq!(found.shell, None);+ assert_eq!(found.name, "tcsh");++ // Terminations, each with no result: starting at init, a ppid+ // cycle, an unreadable hop, and a >16-deep non-shell chain.+ assert!(walk_ancestors(1, |_| unreachable!("init is never looked up")).is_none());+ assert!(walk_ancestors(10, |pid| Some(("looper".to_string(), pid))).is_none());+ assert!(walk_ancestors(10, |_| None).is_none());+ assert!(walk_ancestors(u32::MAX, |pid| Some(("wrapper".to_string(), pid - 1))).is_none());+ }++ /// The OS probe reads real entries: our own pid resolves to a non-empty+ /// name and our actual parent pid.+ #[cfg(any(target_os = "linux", target_os = "macos"))]+ #[test]+ fn test_process_name_and_ppid_self() {+ let (name, ppid) = process_name_and_ppid(std::process::id())+ .expect("own pid must be readable from the process table");+ assert!(!name.is_empty());+ assert_eq!(ppid, std::os::unix::process::parent_id());+ }++ /// The sh-transparency rule depends on the OS probe reporting the+ /// *invoked* name for `sh` processes. On macOS the kernel's `p_comm`+ /// reports the image name instead — `/bin/sh` re-execs bash, so `p_comm`+ /// reads "bash" — which is why the probe there uses `ps`'s+ /// argv\[0\]-derived comm. Pin that with a real child: a live `sh` must+ /// probe as "sh", never as its implementation ("bash"/"dash").+ #[cfg(any(target_os = "linux", target_os = "macos"))]+ #[test]+ fn test_probe_reports_invoked_name_for_sh() {+ // Compound command so sh doesn't exec-replace itself with `sleep`.+ let mut child = Command::new("/bin/sh")+ .args(["-c", "sleep 30; true"])+ .stdout(Stdio::null())+ .spawn()+ .expect("spawn sh");++ // The probe can briefly race the child's exec; poll until it settles.+ // (macOS: ps_snapshot() directly — process_name_and_ppid's cached+ // table may predate the child.)+ let probe = |pid: u32| -> Option<(String, u32)> {+ #[cfg(target_os = "macos")]+ return ps_snapshot().get(&pid).cloned();+ #[cfg(target_os = "linux")]+ return process_name_and_ppid(pid);+ };+ let mut last = None;+ for _ in 0..40 {+ last = probe(child.id());+ if last.as_ref().is_some_and(|(name, _)| name == "sh") {+ break;+ }+ std::thread::sleep(Duration::from_millis(50));+ }+ let _ = child.kill();+ let _ = child.wait();++ let (name, ppid) = last.expect("child sh must be visible to the probe");+ assert_eq!(name, "sh", "probe must report the invoked name");+ assert_eq!(ppid, std::process::id());+ }}diff --git a/src/testing/mod.rs b/src/testing/mod.rsindex 35f84e869..8dcf92f71 100644--- a/src/testing/mod.rs+++ b/src/testing/mod.rs@@ -272,6 +272,13 @@ pub const STATIC_TEST_ENV_VARS: &[(&str, &str)] = &[("WORKTRUNK_TEST_FISH_INSTALLED", "0"),("WORKTRUNK_TEST_NUSHELL_ENV", "0"),("WORKTRUNK_TEST_POWERSHELL_INSTALLED", "0"),+ // Disable the process-tree shell walk (see `shell::ancestor_shell`): the+ // real ancestry of a spawned test wt is the test harness → nextest →+ // cargo → the developer's or CI runner's shell, which would leak into+ // shell-detection results nondeterministically. Empty = "no shell+ // ancestor found", so tests drive detection via SHELL. Tests exercising+ // the walk set a shell name instead.+ ("WORKTRUNK_TEST_PARENT_SHELL", ""),// Disable PowerShell auto-detection (PSModulePath / SHELL signal).// Iteration is unconditional (matches the other shells); this var only// controls `allow_create` via `should_auto_configure_powershell()` so wediff --git a/tests/integration_tests/config_show.rs b/tests/integration_tests/config_show.rsindex 002a2d63e..b24b714a5 100644--- a/tests/integration_tests/config_show.rs+++ b/tests/integration_tests/config_show.rs@@ -2848,6 +2848,69 @@ fn test_config_show_powershell_detected_via_psmodulepath(mut repo: TestRepo, tem});}+/// The process-tree shell wins over $SHELL in the diagnostics: with zsh as+/// the detected ancestor and bash as the login shell, config show surfaces+/// "Detected shell: zsh (process tree)" next to $SHELL, and the verify hint+/// targets zsh.+#[rstest]+fn test_config_show_detected_shell_via_process_tree(mut repo: TestRepo, temp_home: TempDir) {+ repo.setup_mock_ci_tools_unauthenticated();++ // .zshrc has integration for the shell the process tree detects+ fs::write(+ temp_home.path().join(".zshrc"),+ r#"if command -v wt >/dev/null 2>&1; then eval "$(command wt config shell init zsh)"; fi+"#,+ )+ .unwrap();++ let settings = setup_snapshot_settings_with_home(&repo, &temp_home);+ settings.bind(|| {+ let mut cmd = wt_command();+ repo.configure_wt_cmd(&mut cmd);+ repo.configure_mock_commands(&mut cmd);+ cmd.arg("config").arg("show").current_dir(repo.root_path());+ set_temp_home_env(&mut cmd, temp_home.path());+ set_xdg_config_path(&mut cmd, temp_home.path());+ // Login shell differs from the process-tree ancestor. The override+ // must come after configure_wt_cmd, which pins it to "".+ cmd.env("SHELL", "/bin/bash");+ cmd.env("WORKTRUNK_TEST_PARENT_SHELL", "zsh");+ cmd.env("WORKTRUNK_TEST_COMPINIT_CONFIGURED", "1");++ assert_cmd_snapshot!(cmd);+ });+}++/// Without the test override, the real process-tree walk runs. Its result+/// depends on the environment (dev shell, CI runner), so this asserts only+/// that the walk completes and config show still renders — exercising the+/// production walk end-to-end rather than the override shortcut.+#[rstest]+fn test_config_show_runs_real_ancestry_walk(mut repo: TestRepo, temp_home: TempDir) {+ repo.setup_mock_ci_tools_unauthenticated();++ let mut cmd = wt_command();+ repo.configure_wt_cmd(&mut cmd);+ repo.configure_mock_commands(&mut cmd);+ cmd.arg("config").arg("show").current_dir(repo.root_path());+ set_temp_home_env(&mut cmd, temp_home.path());+ set_xdg_config_path(&mut cmd, temp_home.path());+ cmd.env_remove("WORKTRUNK_TEST_PARENT_SHELL");++ let output = cmd.output().unwrap();+ assert!(+ output.status.success(),+ "config show should succeed with the real walk: {}",+ String::from_utf8_lossy(&output.stderr)+ );+ let stdout = String::from_utf8_lossy(&output.stdout);+ assert!(+ stdout.contains("Shell integration"),+ "shell section should render: {stdout}"+ );+}+/// Test that deprecated [commit-generation] section shows warning and creates migration file#[rstest]fn test_deprecated_commit_generation_section_shows_warning(repo: TestRepo, temp_home: TempDir) {diff --git a/tests/integration_tests/configure_shell.rs b/tests/integration_tests/configure_shell.rsindex 4912a3076..f35628011 100644--- a/tests/integration_tests/configure_shell.rs+++ b/tests/integration_tests/configure_shell.rs@@ -1755,6 +1755,11 @@ mod pty_tests {cmd.env("WORKTRUNK_TEST_FISH_INSTALLED", "0");cmd.env("WORKTRUNK_TEST_POWERSHELL_INSTALLED", "0");cmd.env("WORKTRUNK_TEST_NUSHELL_ENV", "0");+ // Disable the process-tree shell walk so detection keys on SHELL:+ // the real ancestry here is the test harness and whatever shell runs+ // it (zsh on a dev box, bash on CI), which would flip the zsh-only+ // compinit/restart output between environments.+ cmd.env("WORKTRUNK_TEST_PARENT_SHELL", "");cmd.env("SHELL", "/bin/zsh");// Skip the compinit probe and force the advisory to appear. The probe spawns// `zsh -ic` which triggers global zshrc configs that can produce "insecure@@ -1876,6 +1881,9 @@ mod pty_tests {cmd.env("WORKTRUNK_TEST_FISH_INSTALLED", "0");cmd.env("WORKTRUNK_TEST_POWERSHELL_INSTALLED", "0");cmd.env("WORKTRUNK_TEST_NUSHELL_ENV", "0");+ // Disable the process-tree shell walk so detection keys on SHELL+ // (see exec_install_in_pty).+ cmd.env("WORKTRUNK_TEST_PARENT_SHELL", "");cmd.env("SHELL", "/bin/zsh");let (output, exit_code) = exec_cmd_in_pty_prompted(cmd, &["n\n"], "[y/N");diff --git a/tests/integration_tests/shell_integration_prompt.rs b/tests/integration_tests/shell_integration_prompt.rsindex 000cd9072..e98621d5e 100644--- a/tests/integration_tests/shell_integration_prompt.rs+++ b/tests/integration_tests/shell_integration_prompt.rs@@ -202,6 +202,105 @@ fn test_switch_no_shell_env_shows_hint(repo: TestRepo) {);}+///+/// $SHELL names the login shell (zsh, with integration installed), but the+/// process tree says wt is really running under fish. Restart advice would be+/// wrong — restarting fish activates nothing — so the warning must take the+/// not-installed shape for the shell actually in use.+#[cfg(unix)]+#[rstest]+fn test_login_shell_mismatch_uses_process_tree_shell(repo: TestRepo) {+ use std::os::unix::process::CommandExt;+ use std::process::Stdio;++ repo.configure_shell_integration(); // writes the zsh eval line to ~/.zshrc++ let mut cmd = repo.wt_command();+ cmd.env("SHELL", "/bin/zsh");+ cmd.env("WORKTRUNK_TEST_PARENT_SHELL", "fish");+ cmd.arg0("wt"); // PATH-style invocation, not the explicit-path warning++ let output = cmd+ .args(["switch", "--create", "feature"])+ .stdin(Stdio::piped())+ .output()+ .unwrap();++ assert!(output.status.success(), "Switch should succeed");+ let stderr = String::from_utf8_lossy(&output.stderr);+ assert!(+ stderr.contains("shell integration not installed"),+ "The actual shell (fish) has no integration: {stderr}"+ );+ assert!(+ !stderr.contains("restart"),+ "Restart advice targets the wrong shell here: {stderr}"+ );+}++///+/// The process tree names a supported shell whose integration IS installed;+/// $SHELL points at a different, unconfigured shell. The process tree wins:+/// the warning takes the installed-but-not-active shape with the hedged+/// restart hint.+#[cfg(unix)]+#[rstest]+fn test_process_tree_shell_configured_shows_restart_hint(repo: TestRepo) {+ use std::os::unix::process::CommandExt;+ use std::process::Stdio;++ repo.configure_shell_integration(); // writes the zsh eval line to ~/.zshrc++ let mut cmd = repo.wt_command();+ cmd.env("SHELL", "/bin/bash"); // login shell without integration+ cmd.env("WORKTRUNK_TEST_PARENT_SHELL", "zsh");+ cmd.arg0("wt");++ let output = cmd+ .args(["switch", "--create", "feature"])+ .stdin(Stdio::piped())+ .output()+ .unwrap();++ assert!(output.status.success(), "Switch should succeed");+ let stderr = String::from_utf8_lossy(&output.stderr);+ assert!(+ stderr.contains("shell integration installed but not active"),+ "zsh (from the process tree) has integration: {stderr}"+ );+ assert!(+ stderr.contains("A shell restart usually activates shell integration"),+ "Should show the hedged restart hint: {stderr}"+ );+}++///+/// The process tree names a known-but-unsupported shell (tcsh); $SHELL points+/// at a supported one. The unsupported-shell hint must name the shell actually+/// in use rather than trusting $SHELL.+#[cfg(unix)]+#[rstest]+fn test_process_tree_unsupported_shell_overrides_shell_env(repo: TestRepo) {+ use std::process::Stdio;++ let mut cmd = repo.wt_command();+ cmd.env("SHELL", "/bin/zsh");+ cmd.env("WORKTRUNK_TEST_PARENT_SHELL", "tcsh");++ let output = cmd+ .args(["switch", "--create", "feature"])+ .stdin(Stdio::piped())+ .output()+ .unwrap();++ assert!(output.status.success(), "Switch should succeed");+ let stderr = String::from_utf8_lossy(&output.stderr);+ assert!(+ stderr.contains("not yet supported for tcsh"),+ "Should name the shell from the process tree: {stderr}"+ );+}+// PTY-based tests for interactive scenarios#[cfg(all(unix, feature = "shell-integration-tests"))]mod pty_tests {diff --git a/tests/snapshots/integration__integration_tests__config_show__config_show_detected_shell_via_process_tree.snap b/tests/snapshots/integration__integration_tests__config_show__config_show_detected_shell_via_process_tree.snapnew file mode 100644index 000000000..205e62a7c--- /dev/null+++ b/tests/snapshots/integration__integration_tests__config_show__config_show_detected_shell_via_process_tree.snap@@ -0,0 +1,73 @@+---+source: tests/integration_tests/config_show.rs+info:+ program: wt+ args:+ - config+ - show+ env:+ APPDATA: "[TEST_CONFIG_HOME]"+ CLAUDE_CONFIG_DIR: "[TEST_CLAUDE_CONFIG]"+ CLICOLOR_FORCE: "1"+ COLUMNS: "500"+ GIT_AUTHOR_DATE: "2025-01-01T00:00:00Z"+ GIT_COMMITTER_DATE: "2025-01-01T00:00:00Z"+ GIT_CONFIG_GLOBAL: "[TEST_GIT_CONFIG]"+ GIT_CONFIG_SYSTEM: /dev/null+ GIT_TERMINAL_PROMPT: "0"+ HOME: "[TEST_HOME]"+ LANG: C+ LC_ALL: C+ LLVM_PROFILE_FILE: "[LLVM_PROFILE_FILE]"+ MOCK_CONFIG_DIR: "[MOCK_CONFIG_DIR]"+ OPENCODE_CONFIG_DIR: "[TEST_OPENCODE_CONFIG]"+ PATH: "[PATH]"+ SHELL: /bin/bash+ TERM: alacritty+ USERPROFILE: "[TEST_HOME]"+ WORKTRUNK_APPROVALS_PATH: "[TEST_APPROVALS]"+ WORKTRUNK_CONFIG_PATH: "[TEST_CONFIG]"+ WORKTRUNK_SYSTEM_CONFIG_PATH: "[TEST_SYSTEM_CONFIG]"+ WORKTRUNK_TEST_BASH_INSTALLED: "0"+ WORKTRUNK_TEST_CLAUDE_INSTALLED: "0"+ WORKTRUNK_TEST_CODEX_INSTALLED: "0"+ WORKTRUNK_TEST_COMPINIT_CONFIGURED: "1"+ WORKTRUNK_TEST_DELAYED_STREAM_MS: "-1"+ WORKTRUNK_TEST_EPOCH: "1735776000"+ WORKTRUNK_TEST_FISH_INSTALLED: "0"+ WORKTRUNK_TEST_GEMINI_INSTALLED: "0"+ WORKTRUNK_TEST_NUSHELL_ENV: "0"+ WORKTRUNK_TEST_OPENCODE_INSTALLED: "0"+ WORKTRUNK_TEST_PARENT_SHELL: zsh+ WORKTRUNK_TEST_POWERSHELL_ENV: "0"+ WORKTRUNK_TEST_POWERSHELL_INSTALLED: "0"+ WORKTRUNK_TEST_SKIP_URL_HEALTH_CHECK: "1"+ WORKTRUNK_TEST_ZSH_INSTALLED: "0"+ XDG_CONFIG_HOME: "[TEST_CONFIG_HOME]"+---+success: true+exit_code: 0+----- stdout -----+[36mUSER CONFIG[39m @ ~/.config/worktrunk/config.toml+[2m↳[22m [2mNot found; to create one, run [4mwt config create[24m[22m++[36mPROJECT CONFIG[39m @ _REPO_/.config/wt.toml+[2m○[22m Identifier: [1m../origin[22m+[2m↳[22m [2mNot found[22m++[36mSHELL INTEGRATION[39m+[33m▲[39m [33mShell integration not active[39m+[107m [0m Invoked as: [1m[PROJECT_ROOT]/target/[BUILD_MODE]/wt[22m+[107m [0m Detected shell: [1mzsh[22m (process tree)+[107m [0m $SHELL: [1m/bin/bash[22m++[2m○[22m [1mzsh[22m: Already configured shell extension & completions @ ~/.zshrc:1+[107m [0m [2m[0m[2m[35mif[0m[2m [0m[2m[34mcommand[0m[2m [0m[2m[36m-v[0m[2m wt [0m[2m[36m>[0m[2m/dev/null [0m[2m[33m2[0m[2m>&1; [0m[2m[35mthen[0m[2m [0m[2m[34meval[0m[2m [0m[2m[32m"$([0m[2m[34mcommand[0m[2m wt config shell init zsh)"[0m[2m; [0m[2m[35mfi[0m+[2m↳[22m [2mTo verify wrapper loaded: [4mtype wt[24m[22m++[36mOTHER[39m+[2m○[22m wt: [1m[VERSION][22m+[2m○[22m git: [1m[VERSION][22m+[2m○[22m Hyperlinks: [1minactive[22m++----- stderr -----