Worktrunk is a CLI for Git worktree management, designed for parallel AI agent workflows
fix(shell): install nushell wrapper to vendor-autoload dir (#2878) (#2992)
Worktrunk Botb75b3cf1a77a
diff --git a/docs/content/faq.md b/docs/content/faq.mdindex bf08cf5b3..02de93365 100644--- a/docs/content/faq.md+++ b/docs/content/faq.md@@ -120,7 +120,7 @@ Created by `wt config shell install`:- **Bash**: adds line to `~/.bashrc`- **Zsh**: adds line to `~/.zshrc` (or `$ZDOTDIR/.zshrc`)- **Fish**: creates `~/.config/fish/functions/wt.fish` and `~/.config/fish/completions/wt.fish`-- **Nushell** <span class="badge-experimental"></span>: creates `$nu.default-config-dir/vendor/autoload/wt.nu` (typically `~/.config/nushell` on Linux, `~/Library/Application Support/nushell` on macOS)+- **Nushell** <span class="badge-experimental"></span>: creates `wt.nu` in Nushell's user vendor-autoload directory — the last entry of `$nu.vendor-autoload-dirs`, under `$nu.data-dir` (typically `~/.local/share/nushell/vendor/autoload` on Linux, `~/Library/Application Support/nushell/vendor/autoload` on macOS)- **PowerShell** (Windows): creates both profile files if they don't exist:- `Documents/PowerShell/Microsoft.PowerShell_profile.ps1` (PowerShell 7+)- `Documents/WindowsPowerShell/Microsoft.PowerShell_profile.ps1` (Windows PowerShell 5.1)@@ -183,6 +183,7 @@ Use `-D` to force-delete branches with unmerged changes. Use `--no-delete-branch- `wt remove` — in addition to the target worktree, runs a background internal sweep: deletes `.git/wt/trash/` entries older than 24 hours (eventual cleanup for directories orphaned when a previous background removal was interrupted), and terminates (`SIGTERM` then `SIGKILL`) `git fsmonitor--daemon` processes whose worktree no longer exists- `wt remove` — terminates the removed worktree's `git fsmonitor--daemon` process. Git starts this per-worktree filesystem-watch daemon when `core.fsmonitor=true`; once its worktree is gone it would leak. Removal sends `git fsmonitor--daemon stop`, then resolves that daemon's PID from its IPC socket and force-terminates it (SIGTERM, then SIGKILL) if it didn't exit. The signal only ever targets the daemon whose socket resolves to the worktree being removed.- `wt config state clear` — removes all worktrunk data from `.git/` (config keys, caches, markers, hints, variables, logs, stale trash)+- `wt config shell install` — when migrating an integration to a new location, removes the worktrunk-managed file left at the old one: fish `conf.d/wt.fish` (now `functions/wt.fish`) and nushell wrappers stranded under `<config-dir>/vendor/autoload` (now `<data-dir>/vendor/autoload`)- `wt config shell uninstall` — removes shell integration from rc filesSee [What files does Worktrunk create?](#what-files-does-worktrunk-create) for details.diff --git a/skills/worktrunk/reference/faq.md b/skills/worktrunk/reference/faq.mdindex f2485a341..0ceb2c5b8 100644--- a/skills/worktrunk/reference/faq.md+++ b/skills/worktrunk/reference/faq.md@@ -113,7 +113,7 @@ Created by `wt config shell install`:- **Bash**: adds line to `~/.bashrc`- **Zsh**: adds line to `~/.zshrc` (or `$ZDOTDIR/.zshrc`)- **Fish**: creates `~/.config/fish/functions/wt.fish` and `~/.config/fish/completions/wt.fish`-- **Nushell** [experimental]: creates `$nu.default-config-dir/vendor/autoload/wt.nu` (typically `~/.config/nushell` on Linux, `~/Library/Application Support/nushell` on macOS)+- **Nushell** [experimental]: creates `wt.nu` in Nushell's user vendor-autoload directory — the last entry of `$nu.vendor-autoload-dirs`, under `$nu.data-dir` (typically `~/.local/share/nushell/vendor/autoload` on Linux, `~/Library/Application Support/nushell/vendor/autoload` on macOS)- **PowerShell** (Windows): creates both profile files if they don't exist:- `Documents/PowerShell/Microsoft.PowerShell_profile.ps1` (PowerShell 7+)- `Documents/WindowsPowerShell/Microsoft.PowerShell_profile.ps1` (Windows PowerShell 5.1)@@ -178,6 +178,7 @@ Use `-D` to force-delete branches with unmerged changes. Use `--no-delete-branch- `wt remove` — in addition to the target worktree, runs a background internal sweep: deletes `.git/wt/trash/` entries older than 24 hours (eventual cleanup for directories orphaned when a previous background removal was interrupted), and terminates (`SIGTERM` then `SIGKILL`) `git fsmonitor--daemon` processes whose worktree no longer exists- `wt remove` — terminates the removed worktree's `git fsmonitor--daemon` process. Git starts this per-worktree filesystem-watch daemon when `core.fsmonitor=true`; once its worktree is gone it would leak. Removal sends `git fsmonitor--daemon stop`, then resolves that daemon's PID from its IPC socket and force-terminates it (SIGTERM, then SIGKILL) if it didn't exit. The signal only ever targets the daemon whose socket resolves to the worktree being removed.- `wt config state clear` — removes all worktrunk data from `.git/` (config keys, caches, markers, hints, variables, logs, stale trash)+- `wt config shell install` — when migrating an integration to a new location, removes the worktrunk-managed file left at the old one: fish `conf.d/wt.fish` (now `functions/wt.fish`) and nushell wrappers stranded under `<config-dir>/vendor/autoload` (now `<data-dir>/vendor/autoload`)- `wt config shell uninstall` — removes shell integration from rc filesSee [What files does Worktrunk create?](#what-files-does-worktrunk-create) for details.diff --git a/skills/worktrunk/reference/shell-integration.md b/skills/worktrunk/reference/shell-integration.mdindex bee3bfcd3..570b83da4 100644--- a/skills/worktrunk/reference/shell-integration.md+++ b/skills/worktrunk/reference/shell-integration.md@@ -38,7 +38,7 @@ eval "$(wt config shell init zsh)"wt config shell init fish | source# nushell (experimental) — save to vendor autoload directory:-wt config shell init nu | save -f ($nu.default-config-dir | path join vendor/autoload/wt.nu)+wt config shell init nu | save -f ($nu.vendor-autoload-dirs | last | path join wt.nu)# PowerShell ($PROFILE):Invoke-Expression (& wt config shell init powershell | Out-String)diff --git a/src/cli/config.rs b/src/cli/config.rsindex d17681c8e..697c6a30c 100644--- a/src/cli/config.rs+++ b/src/cli/config.rs@@ -33,7 +33,7 @@ eval "$(wt config shell init zsh)"Nushell [experimental] — save to vendor autoload directory:```console-$ wt config shell init nu | save -f ($nu.default-config-dir | path join vendor/autoload/wt.nu)+$ wt config shell init nu | save -f ($nu.vendor-autoload-dirs | last | path join wt.nu)```"#)]Init {diff --git a/src/commands/configure_shell.rs b/src/commands/configure_shell.rsindex 627c1cdf2..d24359ead 100644--- a/src/commands/configure_shell.rs+++ b/src/commands/configure_shell.rs@@ -50,8 +50,12 @@ pub struct ScanResult {pub skipped: Vec<(Shell, PathBuf)>, // Shell + first path that was checked/// Zsh was configured but compinit is missing (completions won't work without it)pub zsh_needs_compinit: bool,- /// Legacy files that were cleaned up (e.g., fish conf.d/wt.fish -> functions/wt.fish migration)- pub legacy_cleanups: Vec<PathBuf>,+ /// Legacy/stranded files cleaned up during install, paired with the shell+ /// they belong to so the display can name the canonical replacement.+ /// Covers the fish `conf.d/wt.fish` → `functions/wt.fish` migration (#566)+ /// and the nushell `<config-dir>/vendor/autoload` → `<data-dir>/vendor/autoload`+ /// move (#2878).+ pub legacy_cleanups: Vec<(Shell, PathBuf)>,}pub struct CompletionResult {@@ -120,14 +124,25 @@ fn is_worktrunk_managed_content(content: &str, cmd: &str) -> bool {content.contains(&format!("{cmd} config shell init")) && content.contains("| source")}+/// Check if a Nushell wrapper file is worktrunk-managed.+///+/// The Nushell wrapper is a complete autoload file (not a `source` line), so it+/// carries no `config shell init` marker. Every version worktrunk has shipped+/// opens with this header comment, which a user's own `wt.nu` would not — so it+/// is a safe signal that the file is ours to remove during stranded-file+/// cleanup (issue #2878).+fn is_worktrunk_managed_nushell(content: &str) -> bool {+ content.contains("worktrunk shell integration for nushell")+}+/// Clean up legacy fish conf.d file after installing to functions/////// Previously, fish shell integration was installed to `~/.config/fish/conf.d/{cmd}.fish`./// This caused issues with Homebrew PATH setup (see issue #566). We now install to/// `functions/{cmd}.fish` instead. This function removes the legacy file if it exists.///-/// Returns the paths of files that were cleaned up.-fn cleanup_legacy_fish_conf_d(configured: &[ConfigureResult], cmd: &str) -> Vec<PathBuf> {+/// Returns the paths of files that were cleaned up, each paired with `Shell::Fish`.+fn cleanup_legacy_fish_conf_d(configured: &[ConfigureResult], cmd: &str) -> Vec<(Shell, PathBuf)> {let mut cleaned = Vec::new();// Clean up if fish was part of the install (regardless of whether it already existed)@@ -160,7 +175,7 @@ fn cleanup_legacy_fish_conf_d(configured: &[ConfigureResult], cmd: &str) -> Vec<match fs::remove_file(&legacy_path) {Ok(()) => {- cleaned.push(legacy_path);+ cleaned.push((Shell::Fish, legacy_path));}Err(e) => {// Warn but don't fail - the new integration will still work@@ -177,6 +192,59 @@ fn cleanup_legacy_fish_conf_d(configured: &[ConfigureResult], cmd: &str) -> Vec<cleaned}+/// Clean up Nushell wrapper files stranded at legacy autoload locations.+///+/// Older worktrunk installed the wrapper under `<config-dir>/vendor/autoload`,+/// which Nushell never autoloads (issue #2878). After installing to the correct+/// vendor-autoload dir (`<data-dir>/vendor/autoload`), this removes any+/// worktrunk-managed wrapper left at the other candidate paths so a stale,+/// never-loaded copy isn't left behind.+///+/// Returns the paths removed, each paired with `Shell::Nushell`.+fn cleanup_stranded_nushell(configured: &[ConfigureResult], cmd: &str) -> Vec<(Shell, PathBuf)> {+ let mut cleaned = Vec::new();++ // Only act if nushell was part of this install.+ let Some(nu_result) = configured.iter().find(|r| r.shell == Shell::Nushell) else {+ return cleaned;+ };+ // The canonical write target — never remove this one.+ let canonical = &nu_result.path;++ let Ok(candidates) = Shell::Nushell.config_paths(cmd) else {+ return cleaned;+ };++ for path in candidates {+ if &path == canonical || !path.exists() {+ continue;+ }+ // Only remove files that are clearly worktrunk's, to avoid deleting a+ // user's own `wt.nu`.+ let Ok(content) = fs::read_to_string(&path) else {+ continue;+ };+ if !is_worktrunk_managed_nushell(&content) {+ continue;+ }+ match fs::remove_file(&path) {+ Ok(()) => cleaned.push((Shell::Nushell, path)),+ Err(e) => {+ // Warn but don't fail - the new integration still works.+ eprintln!(+ "{}",+ warning_message(color_print::cformat!(+ "Failed to remove deprecated <bold>{}</>: {e}",+ format_path_for_display(&path)+ ))+ );+ }+ }+ }++ cleaned+}+pub fn handle_configure_shell(shell_filter: Option<Shell>,skip_confirmation: bool,@@ -225,7 +293,8 @@ pub fn handle_configure_shell(// If nothing needs to be changed, still clean up legacy fish conf.d files// A user might have upgraded and have both functions/wt.fish and conf.d/wt.fishif !needs_shell_changes && !needs_completion_changes {- let legacy_cleanups = cleanup_legacy_fish_conf_d(&preview.configured, &cmd);+ let mut legacy_cleanups = cleanup_legacy_fish_conf_d(&preview.configured, &cmd);+ legacy_cleanups.extend(cleanup_stranded_nushell(&preview.configured, &cmd));return Ok(ScanResult {configured: preview.configured,completion_results: completion_preview,@@ -281,8 +350,10 @@ pub fn handle_configure_shell(let zsh_needs_compinit = should_check_compinit && shell::detect_zsh_compinit() == Some(false);// Clean up legacy fish conf.d file if we just installed to functions/- // This handles migration from the old conf.d location (issue #566)- let legacy_cleanups = cleanup_legacy_fish_conf_d(&result.configured, &cmd);+ // (issue #566), plus any nushell wrapper stranded at a legacy autoload+ // location (issue #2878).+ let mut legacy_cleanups = cleanup_legacy_fish_conf_d(&result.configured, &cmd);+ legacy_cleanups.extend(cleanup_stranded_nushell(&result.configured, &cmd));Ok(ScanResult {configured: result.configured,@@ -382,7 +453,18 @@ pub fn scan_shell_configs(let allow_create = shell_filter.is_some() || in_detected_shell;if should_configure {- let path = target_path.or_else(|| paths.first());+ // Wrapper-based shells (Fish, Nushell) always write to the canonical+ // location (`paths.first()`), never to whichever candidate happens to+ // exist. For Nushell that matters: a wrapper stranded at a legacy+ // `<config-dir>/vendor/autoload` path (issue #2878) must not become+ // the write target — install writes the correct vendor-autoload path+ // and `cleanup_stranded_nushell` removes the stale copy. Eval-based+ // shells keep using the first existing config file.+ let path = if shell.is_wrapper_based() {+ paths.first()+ } else {+ target_path.or_else(|| paths.first())+ };if let Some(path) = path {match configure_shell_file(shell, path, dry_run, allow_create, cmd) {Ok(Some(result)) => results.push(result),diff --git a/src/output/shell_integration.rs b/src/output/shell_integration.rsindex f0fabac47..b735fdd3e 100644--- a/src/output/shell_integration.rs+++ b/src/output/shell_integration.rs@@ -311,16 +311,17 @@ pub fn print_shell_install_result(scan_result: &crate::commands::configure_shell}}- // Show legacy file cleanups (migration from conf.d to functions)- for legacy_path in &scan_result.legacy_cleanups {+ // Show legacy file cleanups (fish conf.d → functions, nushell config-dir →+ // data-dir vendor/autoload).+ for (shell, legacy_path) in &scan_result.legacy_cleanups {let old_path = format_path_for_display(legacy_path);- // Find the new canonical path from the configured results+ // Find the new canonical path for this shell from the configured resultslet new_path = scan_result.configured.iter()- .find(|r| r.shell == Shell::Fish)+ .find(|r| r.shell == *shell).map(|r| format_path_for_display(&r.path))- .unwrap_or_else(|| "~/.config/fish/functions/".to_string());+ .unwrap_or_default();eprintln!("{}",info_message(cformat!(diff --git a/src/shell/detection.rs b/src/shell/detection.rsindex d00f3ab9e..292150c1d 100644--- a/src/shell/detection.rs+++ b/src/shell/detection.rs@@ -943,7 +943,7 @@ mod tests {#[test]fn test_nushell_save_pattern() {// Nushell's config_line uses `save --force` (detected via "save" keyword)- let line = "if (which wt | is-not-empty) { wt config shell init nu | save --force ($nu.default-config-dir | path join vendor/autoload/wt.nu) }";+ let line = "if (which wt | is-not-empty) { wt config shell init nu | save --force ($nu.vendor-autoload-dirs | last | path join wt.nu) }";assert_detects(line, "wt", "nushell save pattern (actual config line)");}diff --git a/src/shell/mod.rs b/src/shell/mod.rsindex 73dca1f84..a850e1364 100644--- a/src/shell/mod.rs+++ b/src/shell/mod.rs@@ -160,7 +160,7 @@ impl Shell {}Self::Nushell => {format!(- "if (which {cmd} | is-not-empty) {{ {cmd} config shell init nu | save --force ($nu.default-config-dir | path join vendor/autoload/{cmd}.nu) }}",+ "if (which {cmd} | is-not-empty) {{ {cmd} config shell init nu | save --force ($nu.vendor-autoload-dirs | last | path join {cmd}.nu) }}",)}Self::PowerShell => {diff --git a/src/shell/paths.rs b/src/shell/paths.rsindex 91877b005..0cb0aa80f 100644--- a/src/shell/paths.rs+++ b/src/shell/paths.rs@@ -19,105 +19,166 @@ pub fn home_dir_required() -> Result<PathBuf, std::io::Error> {})}-/// Parse the stdout of `nu -c "echo $nu.default-config-dir"` into a path.+/// Test override pinning the Nushell vendor-autoload directory.///-/// Returns `Some(path)` if stdout contains a non-empty trimmed path, `None` otherwise.-fn parse_nu_config_output(stdout: &[u8]) -> Option<PathBuf> {- let path_str = std::str::from_utf8(stdout).ok()?;- let path = PathBuf::from(path_str.trim());+/// Set by integration tests so the install target is deterministic across+/// platforms (and independent of whether `nu` is on PATH). Mirrors the+/// `WORKTRUNK_TEST_*` overrides consulted by `Shell::is_installed`.+const TEST_NU_VENDOR_AUTOLOAD_ENV: &str = "WORKTRUNK_TEST_NU_VENDOR_AUTOLOAD_DIR";++/// The Nushell directories worktrunk resolves from `nu`, queried at most once+/// per process.+///+/// Nushell autoloads `*.nu` files from `$nu.vendor-autoload-dirs`; the last+/// entry is the user-writable one (under `$nu.data-dir`) and is worktrunk's+/// install target. `$nu.default-config-dir` is kept only to locate files+/// stranded by older worktrunk versions, which installed under+/// `<default-config-dir>/vendor/autoload` — a path Nushell never autoloads+/// (issue #2878).+#[derive(Clone, Default)]+struct NuDirs {+ /// `$nu.vendor-autoload-dirs | last`. `None` when `nu` can't be queried.+ vendor_autoload: Option<PathBuf>,+ /// `$nu.default-config-dir` (legacy install root). `None` when unavailable.+ default_config: Option<PathBuf>,+}++/// Parse a single trimmed path line from `nu` stdout.+///+/// Returns `None` for empty / whitespace-only input.+fn parse_nu_path(line: &str) -> Option<PathBuf> {+ let path = PathBuf::from(line.trim());(!path.as_os_str().is_empty()).then_some(path)}-/// Query `nu` for its default config directory, spawning `nu` at most once per process.+/// Query `nu` for the directories worktrunk cares about, spawning `nu` at most+/// once per process (memoised).///-/// Returns `Some(path)` if the `nu` binary is in PATH and reports its config dir,-/// `None` otherwise (not installed, PATH issues, timeout, etc.). The result is-/// memoised: a single `wt config shell install` resolves both the write path-/// (`nushell_config_dir`) and the installed-state candidates-/// (`nushell_config_candidates`), which would otherwise each spawn `nu` for the-/// same answer.-fn query_nu_config_dir() -> Option<PathBuf> {- static CACHE: OnceLock<Option<PathBuf>> = OnceLock::new();+/// Returns [`NuDirs::default`] (all `None`) when `nu` is not in PATH or the+/// query fails. A single `wt config shell install` resolves both the write+/// target (`completion_path`) and the installed-state candidates+/// (`config_paths`), which would otherwise each spawn `nu` for the same answer.+fn nu_dirs() -> NuDirs {+ static CACHE: OnceLock<NuDirs> = OnceLock::new();CACHE.get_or_init(|| {- let output = crate::shell_exec::Cmd::new("nu")- .args(["-c", "echo $nu.default-config-dir"])+ // Test override: skip spawning `nu` for deterministic, offline tests.+ if let Some(dir) = std::env::var_os(TEST_NU_VENDOR_AUTOLOAD_ENV) {+ return NuDirs {+ vendor_autoload: parse_nu_path(&dir.to_string_lossy()),+ default_config: None,+ };+ }++ let Some(output) = crate::shell_exec::Cmd::new("nu")+ .args([+ "-c",+ "print ($nu.vendor-autoload-dirs | last); print $nu.default-config-dir",+ ]).run().ok()- .filter(|o| o.status.success())?;- parse_nu_config_output(&output.stdout)+ .filter(|o| o.status.success())+ else {+ return NuDirs::default();+ };++ let stdout = String::from_utf8_lossy(&output.stdout);+ let mut lines = stdout.lines();+ NuDirs {+ vendor_autoload: lines.next().and_then(parse_nu_path),+ default_config: lines.next().and_then(parse_nu_path),+ }}).clone()}-/// Resolve the nushell config directory from a queried path or platform defaults.+/// Fallback for Nushell's `$nu.data-dir` when `nu` can't be queried.///-/// If `queried` is `Some`, uses that directly. Otherwise falls back to etcetera's-/// platform config dir, then `home/.config`.-fn resolve_nushell_config_dir(home: &std::path::Path, queried: Option<PathBuf>) -> PathBuf {- queried.unwrap_or_else(|| {- choose_base_strategy()- .map(|s| s.config_dir())- .unwrap_or_else(|_| home.join(".config"))- .join("nushell")- })+/// Mirrors `nu_path::data_dir`: `XDG_DATA_HOME` (when absolute) wins on every+/// platform, otherwise `dirs::data_dir()` (`~/Library/Application Support` on+/// macOS, `%APPDATA%` on Windows, `~/.local/share` on Linux). Nushell appends+/// `nushell`.+fn nushell_data_dir_fallback(home: &std::path::Path) -> PathBuf {+ if let Ok(xdg) = std::env::var("XDG_DATA_HOME") {+ let path = PathBuf::from(xdg);+ if path.is_absolute() {+ return path.join("nushell");+ }+ }+ dirs::data_dir()+ .unwrap_or_else(|| home.join(".local").join("share"))+ .join("nushell")}-/// Get Nushell's default config directory (single best path for writing).+/// The Nushell vendor-autoload directory worktrunk writes its wrapper to.///-/// Used by `completion_path()` to determine where to write completions.-/// Queries `nu` for `$nu.default-config-dir` to handle platform-specific paths-/// — on macOS without `XDG_CONFIG_HOME` set, Nushell defaults to-/// `~/Library/Application Support/nushell`, otherwise it follows-/// `$XDG_CONFIG_HOME/nushell`.-/// Falls back to etcetera's `config_dir` (which uses XDG on every Unix-/// platform, so `~/.config/nushell` by default) if the nu command fails.-fn nushell_config_dir(home: &std::path::Path) -> PathBuf {- resolve_nushell_config_dir(home, query_nu_config_dir())+/// Prefers the path `nu` reports (`$nu.vendor-autoload-dirs | last`); otherwise+/// reconstructs `<data-dir>/vendor/autoload`.+fn nushell_vendor_autoload_dir(+ home: &std::path::Path,+ queried: Option<&std::path::Path>,+) -> PathBuf {+ match queried {+ Some(dir) => dir.to_path_buf(),+ None => nushell_data_dir_fallback(home)+ .join("vendor")+ .join("autoload"),+ }}-/// Get candidate nushell config directories for checking if integration is installed.+/// Legacy `<config-dir>/vendor/autoload` directories where older worktrunk+/// versions wrongly installed the Nushell wrapper (issue #2878).///-/// Returns multiple paths to check because:-/// - Installation might use the path from `nu -c "echo $nu.default-config-dir"`-/// - Runtime detection might fail the `nu` command (PATH issues, timeout, etc.)-/// - We need to find the config file regardless of which path was used-///-/// Returns paths in priority order: queried path first, then fallbacks.-/// When the `nu` query succeeds, `first()` is the queried path — the same path-/// `nushell_config_dir()` writes to. (Their fallbacks differ when the query-/// fails: `nushell_config_dir()` prefers the platform config dir, this prefers-/// `$XDG_CONFIG_HOME`/`~/.config`.)-fn nushell_config_candidates(home: &std::path::Path) -> Vec<PathBuf> {- let mut candidates = vec![];-- // Best path: query nu directly (same source of truth as nushell_config_dir)- if let Some(queried) = query_nu_config_dir() {- candidates.push(queried);+/// Returned so install/uninstall can find and remove files stranded there.+/// Mirrors the candidate set the buggy code wrote to: the queried+/// `$nu.default-config-dir`, then `$XDG_CONFIG_HOME`, `~/.config`, and+/// etcetera's base config dir — each under `nushell/vendor/autoload`.+fn legacy_nushell_autoload_dirs(+ home: &std::path::Path,+ default_config: Option<&std::path::Path>,+) -> Vec<PathBuf> {+ let mut dirs: Vec<PathBuf> = Vec::new();+ if let Some(dir) = default_config {+ dirs.push(dir.to_path_buf());}-- // Fallbacks for when nu query fails at runtime but succeeded during install:-- // XDG_CONFIG_HOME/nushell if setif let Ok(xdg_config) = std::env::var("XDG_CONFIG_HOME") {- candidates.push(PathBuf::from(xdg_config).join("nushell"));+ dirs.push(PathBuf::from(xdg_config).join("nushell"));}-- // ~/.config/nushell (XDG default)- candidates.push(home.join(".config").join("nushell"));-- // Platform config dir via etcetera. `choose_base_strategy` uses the XDG- // strategy on every Unix platform (including macOS), so this resolves to- // `$XDG_CONFIG_HOME/nushell` (default `~/.config/nushell`) on Linux and- // macOS, and `%APPDATA%\nushell` on Windows.+ dirs.push(home.join(".config").join("nushell"));if let Ok(strategy) = choose_base_strategy() {- candidates.push(strategy.config_dir().join("nushell"));+ dirs.push(strategy.config_dir().join("nushell"));}+ dirs.into_iter()+ .map(|d| d.join("vendor").join("autoload"))+ .collect()+}- // Deduplicate while preserving priority order (queried path first)+/// Nushell autoload directories to check for an installed wrapper, in priority+/// order.+///+/// The first entry is the canonical write target (the current vendor-autoload+/// dir); the rest are the data-dir fallback and the legacy config-dir locations+/// kept so install/uninstall can clean up stranded files.+fn nushell_autoload_candidates(home: &std::path::Path) -> Vec<PathBuf> {+ let dirs = nu_dirs();+ let mut candidates = vec![nushell_vendor_autoload_dir(+ home,+ dirs.vendor_autoload.as_deref(),+ )];+ // New-style fallback, in case `nu` was queryable at install time but not now.+ candidates.push(+ nushell_data_dir_fallback(home)+ .join("vendor")+ .join("autoload"),+ );+ candidates.extend(legacy_nushell_autoload_dirs(+ home,+ dirs.default_config.as_deref(),+ ));++ // Deduplicate while preserving priority order (write target first).let mut seen = std::collections::HashSet::new();candidates.retain(|p| seen.insert(p.clone()));-candidates}@@ -179,18 +240,14 @@ pub fn config_paths(shell: super::Shell, cmd: &str) -> Result<Vec<PathBuf>, std:]}super::Shell::Nushell => {- // Nushell vendor autoload directory - check multiple candidate locations because:- // - Installation might use the path from `nu -c "echo $nu.default-config-dir"`- // - Runtime detection might fail the `nu` command (PATH issues, timeout, etc.)- // - We need to find the config file regardless of which path was used during install- nushell_config_candidates(&home)+ // Nushell autoloads `*.nu` from `$nu.vendor-autoload-dirs`; the last+ // entry (under `$nu.data-dir`) is the write target. Earlier entries+ // are fallbacks plus the legacy `<config-dir>/vendor/autoload`+ // locations older worktrunk wrote to (never autoloaded — issue+ // #2878), kept so install/uninstall can clean them up.+ nushell_autoload_candidates(&home).into_iter()- .map(|config_dir| {- config_dir- .join("vendor")- .join("autoload")- .join(format!("{}.nu", cmd))- })+ .map(|autoload_dir| autoload_dir.join(format!("{}.nu", cmd))).collect()}super::Shell::PowerShell => powershell_profile_paths(&home),@@ -250,12 +307,10 @@ pub fn completion_path(shell: super::Shell, cmd: &str) -> Result<PathBuf, std::i.join(format!("{}.fish", cmd))}super::Shell::Nushell => {- // Nushell completions are defined inline in the init script- // Return a path in the vendor autoload directory (same as config)- let config_dir = nushell_config_dir(&home);- config_dir- .join("vendor")- .join("autoload")+ // Nushell completions are defined inline in the init script.+ // Return the canonical vendor-autoload path (same as config).+ let dirs = nu_dirs();+ nushell_vendor_autoload_dir(&home, dirs.vendor_autoload.as_deref()).join(format!("{}.nu", cmd))}super::Shell::PowerShell => {@@ -272,102 +327,91 @@ mod tests {use super::*;#[test]- fn test_parse_nu_config_output() {+ fn test_parse_nu_path() {assert_eq!(- parse_nu_config_output(b"/home/user/.config/nushell\n"),- Some(PathBuf::from("/home/user/.config/nushell"))+ parse_nu_path("/home/user/.local/share/nushell/vendor/autoload\n"),+ Some(PathBuf::from(+ "/home/user/.local/share/nushell/vendor/autoload"+ )));- // Trims whitespace- assert_eq!(- parse_nu_config_output(b" /home/user/.config/nushell \n"),- Some(PathBuf::from("/home/user/.config/nushell"))- );- // Empty / whitespace-only / invalid UTF-8- assert_eq!(parse_nu_config_output(b""), None);- assert_eq!(parse_nu_config_output(b" \n"), None);- assert_eq!(parse_nu_config_output(&[0xFF, 0xFE]), None);+ // Trims surrounding whitespace+ assert_eq!(parse_nu_path(" /a/b "), Some(PathBuf::from("/a/b")));+ // Empty / whitespace-only+ assert_eq!(parse_nu_path(""), None);+ assert_eq!(parse_nu_path(" \n"), None);}#[test]- fn test_nushell_config_candidates_includes_xdg_and_defaults() {+ fn test_nushell_vendor_autoload_dir_prefers_queried() {let home = PathBuf::from("/home/user");-- let candidates = nushell_config_candidates(&home);-- // Should include default XDG path- assert!(- candidates- .iter()- .any(|p| p == &home.join(".config").join("nushell")),- "Should include ~/.config/nushell in candidates"+ let queried = PathBuf::from("/opt/nu/vendor/autoload");+ assert_eq!(+ nushell_vendor_autoload_dir(&home, Some(&queried)),+ queried,+ "the path nu reports should be used verbatim");+ }- // Should include the platform config dir from etcetera- if let Ok(strategy) = choose_base_strategy() {- let platform_dir = strategy.config_dir().join("nushell");- assert!(- candidates.iter().any(|p| p == &platform_dir),- "Should include platform config dir {platform_dir:?} in candidates"- );- }-- // All candidates should be nushell config dirs+ #[test]+ fn test_nushell_vendor_autoload_dir_fallback_under_data_dir() {+ let home = PathBuf::from("/home/user");+ let dir = nushell_vendor_autoload_dir(&home, None);+ // Fallback must land under `<data-dir>/nushell/vendor/autoload`, never+ // under the *config* dir (the bug this fixes).assert!(- candidates.iter().all(|p| p.ends_with("nushell")),- "All candidates should end with 'nushell'"+ dir.ends_with("nushell/vendor/autoload"),+ "fallback should be under <data>/nushell/vendor/autoload: {dir:?}");}#[test]- fn test_nushell_config_candidates_always_has_fallback() {+ fn test_legacy_nushell_autoload_dirs_are_config_rooted() {let home = PathBuf::from("/home/user");- let candidates = nushell_config_candidates(&home);+ let default_config = PathBuf::from("/home/user/.config/nushell");+ let dirs = legacy_nushell_autoload_dirs(&home, Some(&default_config));- // Even without `nu` in PATH, we should get at least one fallback+ // Includes the queried default-config-dir location...assert!(- !candidates.is_empty(),- "Should return at least 1 candidate path, got: {candidates:?}"+ dirs.contains(&default_config.join("vendor").join("autoload")),+ "should include the queried default-config-dir: {dirs:?}");-- // On macOS/Windows, should have at least 2 (XDG default + platform path)- #[cfg(any(target_os = "macos", windows))]+ // ...and the XDG default ~/.config/nushell location.+ assert!(+ dirs.contains(&home.join(".config/nushell/vendor/autoload")),+ "should include ~/.config/nushell: {dirs:?}"+ );+ // Every legacy dir is a vendor/autoload dir.assert!(- candidates.len() >= 2,- "Should have at least 2 candidates on this platform, got: {candidates:?}"+ dirs.iter().all(|p| p.ends_with("vendor/autoload")),+ "all legacy dirs should end with vendor/autoload: {dirs:?}");}#[test]- fn test_nushell_config_candidates_no_duplicates() {+ fn test_nushell_autoload_candidates_write_target_first_and_unique() {let home = PathBuf::from("/home/user");- let candidates = nushell_config_candidates(&home);+ let candidates = nushell_autoload_candidates(&home);+ assert!(!candidates.is_empty(), "must return at least one candidate");+ // The write target (first entry) is a vendor/autoload directory.+ assert!(+ candidates[0].ends_with("vendor/autoload"),+ "write target should be a vendor/autoload dir: {:?}",+ candidates[0]+ );+ // No duplicates.let unique: std::collections::HashSet<_> = candidates.iter().collect();assert_eq!(candidates.len(),unique.len(),- "Candidates should not contain duplicates: {candidates:?}"+ "candidates must not contain duplicates: {candidates:?}");- }-- #[test]- fn test_resolve_nushell_config_dir_with_queried_path() {- let home = PathBuf::from("/home/user");- let queried = PathBuf::from("/custom/nushell");- assert_eq!(- resolve_nushell_config_dir(&home, Some(queried.clone())),- queried- );- }-- #[test]- fn test_resolve_nushell_config_dir_without_queried_path() {- let home = PathBuf::from("/home/user");- let result = resolve_nushell_config_dir(&home, None);- // Should fall back to a platform config dir ending in "nushell"+ // The legacy ~/.config location is always present for cleanup.assert!(- result.ends_with("nushell"),- "Fallback should end with 'nushell': {result:?}"+ candidates+ .iter()+ .any(|p| p == &home.join(".config/nushell/vendor/autoload")),+ "legacy ~/.config/nushell location must be a candidate: {candidates:?}");}}diff --git a/src/shell/snapshots/worktrunk__shell__tests__config_line_nu.snap b/src/shell/snapshots/worktrunk__shell__tests__config_line_nu.snapindex 4f4bd0242..bb228cb79 100644--- a/src/shell/snapshots/worktrunk__shell__tests__config_line_nu.snap+++ b/src/shell/snapshots/worktrunk__shell__tests__config_line_nu.snap@@ -2,4 +2,4 @@source: src/shell/mod.rsexpression: "Shell::Nushell.config_line(\"wt\")"----if (which wt | is-not-empty) { wt config shell init nu | save --force ($nu.default-config-dir | path join vendor/autoload/wt.nu) }+if (which wt | is-not-empty) { wt config shell init nu | save --force ($nu.vendor-autoload-dirs | last | path join wt.nu) }diff --git a/src/shell/snapshots/worktrunk__shell__tests__config_line_nu_custom.snap b/src/shell/snapshots/worktrunk__shell__tests__config_line_nu_custom.snapindex b3e281bc3..d807d0ca4 100644--- a/src/shell/snapshots/worktrunk__shell__tests__config_line_nu_custom.snap+++ b/src/shell/snapshots/worktrunk__shell__tests__config_line_nu_custom.snap@@ -2,4 +2,4 @@source: src/shell/mod.rsexpression: "Shell::Nushell.config_line(\"git-wt\")"----if (which git-wt | is-not-empty) { git-wt config shell init nu | save --force ($nu.default-config-dir | path join vendor/autoload/git-wt.nu) }+if (which git-wt | is-not-empty) { git-wt config shell init nu | save --force ($nu.vendor-autoload-dirs | last | path join git-wt.nu) }diff --git a/tests/common/mod.rs b/tests/common/mod.rsindex 3adc17fa0..5edfeda73 100644--- a/tests/common/mod.rs+++ b/tests/common/mod.rs@@ -145,6 +145,25 @@ pub fn temp_home() -> TempDir {TempDir::new().unwrap()}+/// Canonicalize a `temp_home` for use as a base when building paths that+/// production code will compare against the exported HOME.+///+/// `set_temp_home_env` exports HOME via `dunce::canonicalize`, so paths the+/// command later prints (e.g. the nushell vendor-autoload dir) only tilde-+/// shorten in `format_path_for_display` when they share that canonical prefix.+/// Two platform pitfalls make a bare `temp_home.path()` wrong:+///+/// - **macOS**: the temp dir lives under `/var`, a symlink to `/private/var`.+/// Canonicalizing resolves it to match the exported HOME, so the printed path+/// shortens to `~/...` instead of the full temp path.+/// - **Windows**: `std::fs::canonicalize` returns a `\\?\` verbatim path, where+/// the forward slashes in a later `.join("a/b/c")` are treated as literal+/// filename characters rather than separators — breaking both the file write+/// and `.exists()`. `dunce::canonicalize` returns an ordinary path.+pub fn canonical_temp_home(temp_home: &TempDir) -> std::path::PathBuf {+ dunce::canonicalize(temp_home.path()).unwrap()+}+/// Repo with remote tracking set up.////// Builds on the `repo` fixture, adding a "remote" for the default branch.@@ -556,6 +575,11 @@ pub fn add_standard_env_redactions(settings: &mut insta::Settings) {settings.add_redaction(".env.PWD", "[PWD]");// Mock commands directory (temp path for mock gh/glab binaries)settings.add_redaction(".env.MOCK_CONFIG_DIR", "[MOCK_CONFIG_DIR]");+ // Nushell vendor-autoload override (temp path pinned by shell-integration tests)+ settings.add_redaction(+ ".env.WORKTRUNK_TEST_NU_VENDOR_AUTOLOAD_DIR",+ "[TEST_NU_VENDOR_AUTOLOAD]",+ );// OpenCode config directory (platform-independent override for tests)settings.add_redaction(".env.OPENCODE_CONFIG_DIR", "[TEST_OPENCODE_CONFIG]");// `wt config show --full` tests inject WORKTRUNK_TEST_LATEST_VERSION = thediff --git a/tests/integration_tests/config_show.rs b/tests/integration_tests/config_show.rsindex 597a9ff1b..cc394c85a 100644--- a/tests/integration_tests/config_show.rs+++ b/tests/integration_tests/config_show.rs@@ -1,6 +1,7 @@use crate::common::{- TestRepo, repo, set_temp_home_env, set_xdg_config_path, setup_home_snapshot_settings,- setup_snapshot_settings, setup_snapshot_settings_with_home, temp_home, wt_command,+ TestRepo, canonical_temp_home, repo, set_temp_home_env, set_xdg_config_path,+ setup_home_snapshot_settings, setup_snapshot_settings, setup_snapshot_settings_with_home,+ temp_home, wt_command,};use insta_cmd::assert_cmd_snapshot;use rstest::rstest;@@ -948,8 +949,10 @@ fn test_config_show_nushell_outdated_wrapper(mut repo: TestRepo, temp_home: Tempfs::create_dir_all(&global_config_dir).unwrap();fs::write(global_config_dir.join("config.toml"), "").unwrap();- // Create nushell vendor/autoload directory with an outdated wt.nu- let autoload = temp_home.path().join(".config/nushell/vendor/autoload");+ // Create the nushell vendor-autoload directory with an outdated wt.nu.+ // Pin the dir via the test override so the path is deterministic across+ // platforms (and independent of whether `nu` is installed).+ let autoload = canonical_temp_home(&temp_home).join(".local/share/nushell/vendor/autoload");fs::create_dir_all(&autoload).unwrap();fs::write(autoload.join("wt.nu"),@@ -965,6 +968,7 @@ fn test_config_show_nushell_outdated_wrapper(mut repo: TestRepo, temp_home: Tempcmd.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("WORKTRUNK_TEST_NU_VENDOR_AUTOLOAD_DIR", &autoload);assert_cmd_snapshot!(cmd);});diff --git a/tests/integration_tests/configure_shell.rs b/tests/integration_tests/configure_shell.rsindex a4a236939..c95f2277b 100644--- a/tests/integration_tests/configure_shell.rs+++ b/tests/integration_tests/configure_shell.rs@@ -1,6 +1,6 @@use crate::common::{- TestRepo, repo, set_temp_home_env, set_xdg_config_path, setup_home_snapshot_settings,- temp_home, wt_command,+ TestRepo, canonical_temp_home, repo, set_temp_home_env, set_xdg_config_path,+ setup_home_snapshot_settings, temp_home, wt_command,};use insta_cmd::assert_cmd_snapshot;use rstest::rstest;@@ -867,6 +867,13 @@ fn test_uninstall_shell(repo: TestRepo, temp_home: TempDir) {repo.configure_wt_cmd(&mut cmd);set_temp_home_env(&mut cmd, temp_home.path());cmd.env("SHELL", "/bin/zsh");+ // Pin the nushell vendor-autoload dir so the "not found" path is+ // deterministic across platforms and independent of whether `nu` is on+ // the runner's PATH.+ cmd.env(+ "WORKTRUNK_TEST_NU_VENDOR_AUTOLOAD_DIR",+ canonical_temp_home(&temp_home).join(".local/share/nushell/vendor/autoload"),+ );cmd.arg("config").arg("shell").arg("uninstall")@@ -882,7 +889,7 @@ fn test_uninstall_shell(repo: TestRepo, temp_home: TempDir) {[32m✓[39m [32mRemoved shell extension & completions for [1mzsh[22m @ [1m~/.zshrc[22m[39m[2m↳[22m [2mNo [4mbash[24m shell extension & completions in ~/.bashrc[22m[2m↳[22m [2mNo [4mfish[24m shell extension in ~/.config/fish/functions/wt.fish[22m- [2m↳[22m [2mNo [4mnu[24m shell extension & completions in ~/.config/nushell/vendor/autoload/wt.nu[22m+ [2m↳[22m [2mNo [4mnu[24m shell extension & completions in ~/.local/share/nushell/vendor/autoload/wt.nu[22m[2m↳[22m [2mNo [4mfish[24m completions in ~/.config/fish/completions/wt.fish[22m[32m✓[39m [32mRemoved integration from 1 shell[39m@@ -924,6 +931,13 @@ fn test_uninstall_shell_multiple(repo: TestRepo, temp_home: TempDir) {repo.configure_wt_cmd(&mut cmd);set_temp_home_env(&mut cmd, temp_home.path());cmd.env("SHELL", "/bin/zsh");+ // Pin the nushell vendor-autoload dir so the "not found" path is+ // deterministic across platforms and independent of whether `nu` is on+ // the runner's PATH.+ cmd.env(+ "WORKTRUNK_TEST_NU_VENDOR_AUTOLOAD_DIR",+ canonical_temp_home(&temp_home).join(".local/share/nushell/vendor/autoload"),+ );cmd.arg("config").arg("shell").arg("uninstall")@@ -939,7 +953,7 @@ fn test_uninstall_shell_multiple(repo: TestRepo, temp_home: TempDir) {[32m✓[39m [32mRemoved shell extension & completions for [1mbash[22m @ [1m~/.bashrc[22m[39m[32m✓[39m [32mRemoved shell extension & completions for [1mzsh[22m @ [1m~/.zshrc[22m[39m[2m↳[22m [2mNo [4mfish[24m shell extension in ~/.config/fish/functions/wt.fish[22m- [2m↳[22m [2mNo [4mnu[24m shell extension & completions in ~/.config/nushell/vendor/autoload/wt.nu[22m+ [2m↳[22m [2mNo [4mnu[24m shell extension & completions in ~/.local/share/nushell/vendor/autoload/wt.nu[22m[2m↳[22m [2mNo [4mfish[24m completions in ~/.config/fish/completions/wt.fish[22m[32m✓[39m [32mRemoved integration from 2 shells[39m@@ -1663,10 +1677,15 @@ fn test_uninstall_shell_dry_run_multiple(repo: TestRepo, temp_home: TempDir) {/// `shell extension & completions`.#[rstest]fn test_uninstall_shell_dry_run_nushell(repo: TestRepo, temp_home: TempDir) {+ let autoload = temp_home+ .path()+ .join(".local/share/nushell/vendor/autoload");+// Install nushell integration first so dry-run uninstall finds something.let mut install_cmd = wt_command();repo.configure_wt_cmd(&mut install_cmd);set_temp_home_env(&mut install_cmd, temp_home.path());+ install_cmd.env("WORKTRUNK_TEST_NU_VENDOR_AUTOLOAD_DIR", &autoload);install_cmd.env("SHELL", "/bin/nu");install_cmd.args(["config", "shell", "install", "nu", "--yes"])@@ -1681,6 +1700,7 @@ fn test_uninstall_shell_dry_run_nushell(repo: TestRepo, temp_home: TempDir) {let mut cmd = wt_command();repo.configure_wt_cmd(&mut cmd);set_temp_home_env(&mut cmd, temp_home.path());+ cmd.env("WORKTRUNK_TEST_NU_VENDOR_AUTOLOAD_DIR", &autoload);cmd.env("SHELL", "/bin/nu");cmd.args(["config", "shell", "uninstall", "nu", "--dry-run"]).current_dir(repo.root_path());@@ -1850,16 +1870,20 @@ mod pty_tests {/// Test installing nushell shell integration///-/// Runs `install nu --yes` and verifies the wrapper file was created.-/// This covers the nushell-specific wrapper generation path in configure_shell.-///-/// set_temp_home_env sets XDG_CONFIG_HOME to home/.config, and the `nu` binary-/// isn't available in tests, so nushell_config_dir falls back to XDG_CONFIG_HOME/nushell.+/// Runs `install nu --yes` and verifies the wrapper file was created in the+/// vendor-autoload directory (issue #2878). Pins that directory via+/// `WORKTRUNK_TEST_NU_VENDOR_AUTOLOAD_DIR` so the target is deterministic on+/// every platform (and doesn't depend on `nu` being installed).#[rstest]fn test_configure_shell_nushell(repo: TestRepo, temp_home: TempDir) {+ let home = canonical_temp_home(&temp_home);+ let autoload = home.join(".local/share/nushell/vendor/autoload");+ let nu_config = autoload.join("wt.nu");+let mut cmd = wt_command();repo.configure_wt_cmd(&mut cmd);set_temp_home_env(&mut cmd, temp_home.path());+ cmd.env("WORKTRUNK_TEST_NU_VENDOR_AUTOLOAD_DIR", &autoload);cmd.env("SHELL", "/bin/nu");cmd.arg("config").arg("shell")@@ -1882,18 +1906,9 @@ fn test_configure_shell_nushell(repo: TestRepo, temp_home: TempDir) {stderr);- // set_temp_home_env sets XDG_CONFIG_HOME → home/.config, so the nushell- // vendor autoload path is deterministic (nu binary not available in tests).- let home = std::fs::canonicalize(temp_home.path()).unwrap();- let nu_config = home- .join(".config")- .join("nushell")- .join("vendor")- .join("autoload")- .join("wt.nu");assert!(nu_config.exists(),- "wt.nu should be created at {:?}",+ "wt.nu should be created in the vendor-autoload dir at {:?}",nu_config);@@ -1911,18 +1926,15 @@ fn test_configure_shell_nushell(repo: TestRepo, temp_home: TempDir) {/// This covers the nushell-specific uninstall block in configure_shell.#[rstest]fn test_uninstall_shell_nushell(repo: TestRepo, temp_home: TempDir) {- let home = std::fs::canonicalize(temp_home.path()).unwrap();- let nu_config = home- .join(".config")- .join("nushell")- .join("vendor")- .join("autoload")- .join("wt.nu");+ let home = canonical_temp_home(&temp_home);+ let autoload = home.join(".local/share/nushell/vendor/autoload");+ let nu_config = autoload.join("wt.nu");// First install to create the wrapper filelet mut install_cmd = wt_command();repo.configure_wt_cmd(&mut install_cmd);set_temp_home_env(&mut install_cmd, temp_home.path());+ install_cmd.env("WORKTRUNK_TEST_NU_VENDOR_AUTOLOAD_DIR", &autoload);install_cmd.env("SHELL", "/bin/nu");install_cmd.args(["config", "shell", "install", "nu", "--yes"])@@ -1944,6 +1956,7 @@ fn test_uninstall_shell_nushell(repo: TestRepo, temp_home: TempDir) {let mut cmd = wt_command();repo.configure_wt_cmd(&mut cmd);set_temp_home_env(&mut cmd, temp_home.path());+ cmd.env("WORKTRUNK_TEST_NU_VENDOR_AUTOLOAD_DIR", &autoload);cmd.env("SHELL", "/bin/nu");cmd.args(["config", "shell", "uninstall", "nu", "--yes"]).current_dir(repo.root_path());@@ -1970,20 +1983,22 @@ fn test_uninstall_shell_nushell(repo: TestRepo, temp_home: TempDir) {);}-/// Test that nushell uninstall cleans up config files at all candidate locations.-///-/// Exercises the fix where uninstall iterates all nushell config candidates,-/// not just the first. Simulates the scenario where the file was installed at-/// a location that is no longer the primary candidate (e.g., `nu` reported-/// a different path during install than what we'd pick now).+/// Test that nushell uninstall cleans up the wrapper at every candidate+/// location — the canonical vendor-autoload dir and the legacy+/// `<config-dir>/vendor/autoload` paths older worktrunk stranded files at+/// (issue #2878). `config_paths(Nushell)` returns all of them and uninstall+/// iterates the full list.#[rstest]fn test_uninstall_nushell_cleans_all_candidate_locations(repo: TestRepo, temp_home: TempDir) {- let home = std::fs::canonicalize(temp_home.path()).unwrap();+ let home = canonical_temp_home(&temp_home);+ let autoload = home.join(".local/share/nushell/vendor/autoload");+ let canonical = autoload.join("wt.nu");- // Install nushell integration normally (goes to XDG_CONFIG_HOME/nushell)+ // Install nushell integration to the canonical vendor-autoload dir.let mut install_cmd = wt_command();repo.configure_wt_cmd(&mut install_cmd);set_temp_home_env(&mut install_cmd, temp_home.path());+ install_cmd.env("WORKTRUNK_TEST_NU_VENDOR_AUTOLOAD_DIR", &autoload);install_cmd.env("SHELL", "/bin/nu");install_cmd.args(["config", "shell", "install", "nu", "--yes"])@@ -1995,38 +2010,21 @@ fn test_uninstall_nushell_cleans_all_candidate_locations(repo: TestRepo, temp_ho"Install should succeed:\nstderr: {}",String::from_utf8_lossy(&install_output.stderr));+ assert!(canonical.exists(), "Canonical config should exist");++ // Simulate a wrapper stranded by an older worktrunk at the legacy+ // config-dir location (set_temp_home_env points XDG_CONFIG_HOME at+ // ~/.config, so that's a legacy candidate).+ let legacy_dir = home.join(".config/nushell/vendor/autoload");+ fs::create_dir_all(&legacy_dir).unwrap();+ let legacy_config = legacy_dir.join("wt.nu");+ fs::copy(&canonical, &legacy_config).unwrap();- let primary_config = home- .join(".config")- .join("nushell")- .join("vendor")- .join("autoload")- .join("wt.nu");- assert!(primary_config.exists(), "Primary config should exist");-- // Copy the config to a secondary candidate location (~/.config is the XDG default,- // but also manually create one at a different path to simulate install at a- // non-primary location). Use a custom XDG_CONFIG_HOME to make a second candidate- // be the primary during uninstall.- let secondary_dir = home- .join("custom-config")- .join("nushell")- .join("vendor")- .join("autoload");- fs::create_dir_all(&secondary_dir).unwrap();- let secondary_config = secondary_dir.join("wt.nu");- fs::copy(&primary_config, &secondary_config).unwrap();-- // Uninstall with XDG_CONFIG_HOME pointing to the custom location.- // The custom path becomes the first candidate, but the original at ~/.config/nushell- // should also be cleaned up since uninstall checks all candidates.+ // Uninstall should remove the wrapper at both the canonical and legacy paths.let mut cmd = wt_command();repo.configure_wt_cmd(&mut cmd);- // Override XDG_CONFIG_HOME to point to custom dir, making it the primary candidate- cmd.env("HOME", &home);- cmd.env("USERPROFILE", &home);- cmd.env("XDG_CONFIG_HOME", home.join("custom-config"));- cmd.env("APPDATA", home.join("custom-config"));+ set_temp_home_env(&mut cmd, temp_home.path());+ cmd.env("WORKTRUNK_TEST_NU_VENDOR_AUTOLOAD_DIR", &autoload);cmd.env("SHELL", "/bin/nu");cmd.args(["config", "shell", "uninstall", "nu", "--yes"]).current_dir(repo.root_path());@@ -2040,12 +2038,12 @@ fn test_uninstall_nushell_cleans_all_candidate_locations(repo: TestRepo, temp_ho// Both locations should be cleaned upassert!(- !primary_config.exists(),- "Primary config at ~/.config/nushell should be deleted: {primary_config:?}"+ !canonical.exists(),+ "Canonical wrapper should be deleted: {canonical:?}");assert!(- !secondary_config.exists(),- "Secondary config at custom XDG path should be deleted: {secondary_config:?}"+ !legacy_config.exists(),+ "Stranded legacy wrapper should be deleted: {legacy_config:?}");}@@ -2114,11 +2112,15 @@ fn test_nushell_auto_detection_creates_vendor_autoload(repo: TestRepo, temp_home// Don't create vendor/autoload - the whole point is that it doesn't exist yet// but nushell IS detected on the system+ let home = canonical_temp_home(&temp_home);+ let autoload = home.join(".local/share/nushell/vendor/autoload");+let mut cmd = wt_command();repo.configure_wt_cmd(&mut cmd);set_temp_home_env(&mut cmd, temp_home.path());// Force nushell detection via test env var (parallels WORKTRUNK_TEST_POWERSHELL_ENV)cmd.env("WORKTRUNK_TEST_NUSHELL_ENV", "1");+ cmd.env("WORKTRUNK_TEST_NU_VENDOR_AUTOLOAD_DIR", &autoload);cmd.env("SHELL", "/bin/zsh");cmd.arg("config").arg("shell")@@ -2146,14 +2148,8 @@ fn test_nushell_auto_detection_creates_vendor_autoload(repo: TestRepo, temp_homestderr);- // Verify the nushell wrapper was created with vendor/autoload/ directory- let home = std::fs::canonicalize(temp_home.path()).unwrap();- let nu_config = home- .join(".config")- .join("nushell")- .join("vendor")- .join("autoload")- .join("wt.nu");+ // Verify the nushell wrapper was created in the vendor-autoload directory+ let nu_config = autoload.join("wt.nu");assert!(nu_config.exists(),"wt.nu should be created at {:?}",@@ -2176,10 +2172,15 @@ fn test_nushell_auto_detection_creates_vendor_autoload(repo: TestRepo, temp_homefn test_config_show_detects_nushell_integration(mut repo: TestRepo, temp_home: TempDir) {repo.setup_mock_ci_tools_unauthenticated();+ let autoload = temp_home+ .path()+ .join(".local/share/nushell/vendor/autoload");+// Install nushell integrationlet mut install_cmd = wt_command();repo.configure_wt_cmd(&mut install_cmd);set_temp_home_env(&mut install_cmd, temp_home.path());+ install_cmd.env("WORKTRUNK_TEST_NU_VENDOR_AUTOLOAD_DIR", &autoload);install_cmd.env("SHELL", "/bin/nu");install_cmd.args(["config", "shell", "install", "nu", "--yes"])@@ -2196,6 +2197,7 @@ fn test_config_show_detects_nushell_integration(mut repo: TestRepo, temp_home: Trepo.configure_wt_cmd(&mut cmd);repo.configure_mock_commands(&mut cmd);set_temp_home_env(&mut cmd, temp_home.path());+ cmd.env("WORKTRUNK_TEST_NU_VENDOR_AUTOLOAD_DIR", &autoload);cmd.env("SHELL", "/bin/nu");cmd.args(["config", "show"]).current_dir(repo.root_path());@@ -2206,3 +2208,156 @@ fn test_config_show_detects_nushell_integration(mut repo: TestRepo, temp_home: T"config show should detect nushell integration:\n{stdout}");}++/// Installing nushell removes a wrapper stranded by older worktrunk at the+/// legacy `<config-dir>/vendor/autoload` location (issue #2878), and writes the+/// wrapper to the canonical vendor-autoload dir instead. Cross-platform: the+/// target dir is pinned via the test override so it doesn't depend on `nu`.+#[rstest]+fn test_nushell_install_cleans_stranded_legacy(repo: TestRepo, temp_home: TempDir) {+ let home = canonical_temp_home(&temp_home);+ let autoload = home.join(".local/share/nushell/vendor/autoload");+ let canonical = autoload.join("wt.nu");++ // A wrapper stranded by an older worktrunk at the legacy config-dir location+ // (set_temp_home_env points XDG_CONFIG_HOME at ~/.config). The worktrunk+ // header marks it as ours to remove.+ let legacy_dir = home.join(".config/nushell/vendor/autoload");+ fs::create_dir_all(&legacy_dir).unwrap();+ let legacy = legacy_dir.join("wt.nu");+ fs::write(+ &legacy,+ "# worktrunk shell integration for nushell\ndef --wrapped wt [...args] { command wt-old ...$args }\n",+ )+ .unwrap();++ let mut cmd = wt_command();+ repo.configure_wt_cmd(&mut cmd);+ set_temp_home_env(&mut cmd, temp_home.path());+ cmd.env("WORKTRUNK_TEST_NU_VENDOR_AUTOLOAD_DIR", &autoload);+ cmd.env("SHELL", "/bin/nu");+ cmd.args(["config", "shell", "install", "nu", "--yes"])+ .current_dir(repo.root_path());++ let output = cmd.output().expect("Failed to execute install");+ assert!(+ output.status.success(),+ "Install should succeed:\nstderr: {}",+ String::from_utf8_lossy(&output.stderr)+ );++ // Wrapper written to the canonical vendor-autoload dir...+ assert!(+ canonical.exists(),+ "wrapper should be written to the vendor-autoload dir: {canonical:?}"+ );+ // ...and the stranded legacy copy removed.+ assert!(+ !legacy.exists(),+ "stranded legacy wrapper should be removed: {legacy:?}"+ );++ // The cleanup is surfaced to the user.+ let stderr = String::from_utf8_lossy(&output.stderr);+ assert!(+ stderr.contains("deprecated"),+ "install should report the stranded-file cleanup:\n{stderr}"+ );+}++/// Data safety: install must NOT delete a `wt.nu` at a legacy location that+/// isn't worktrunk-managed (no worktrunk header) — it could be the user's own+/// file. Only files carrying the worktrunk header are cleaned up (issue #2878).+#[rstest]+fn test_nushell_install_keeps_unmanaged_legacy_file(repo: TestRepo, temp_home: TempDir) {+ let home = canonical_temp_home(&temp_home);+ let autoload = home.join(".local/share/nushell/vendor/autoload");++ // A user-authored wt.nu at the legacy config-dir location — no worktrunk+ // header, so it must be left untouched.+ let legacy_dir = home.join(".config/nushell/vendor/autoload");+ fs::create_dir_all(&legacy_dir).unwrap();+ let legacy = legacy_dir.join("wt.nu");+ let user_content = "# my own wt helper\ndef wt [] { echo hi }\n";+ fs::write(&legacy, user_content).unwrap();++ let mut cmd = wt_command();+ repo.configure_wt_cmd(&mut cmd);+ set_temp_home_env(&mut cmd, temp_home.path());+ cmd.env("WORKTRUNK_TEST_NU_VENDOR_AUTOLOAD_DIR", &autoload);+ cmd.env("SHELL", "/bin/nu");+ cmd.args(["config", "shell", "install", "nu", "--yes"])+ .current_dir(repo.root_path());++ let output = cmd.output().expect("Failed to execute install");+ assert!(+ output.status.success(),+ "Install should succeed:\nstderr: {}",+ String::from_utf8_lossy(&output.stderr)+ );++ // Canonical wrapper written, user's legacy file preserved verbatim.+ assert!(autoload.join("wt.nu").exists(), "canonical wrapper missing");+ assert!(+ legacy.exists(),+ "unmanaged legacy wt.nu must be preserved: {legacy:?}"+ );+ assert_eq!(+ fs::read_to_string(&legacy).unwrap(),+ user_content,+ "unmanaged legacy file must be left unchanged"+ );+}++/// End-to-end guard for issue #2878 using the real `nu` binary (no override):+/// after `install nu`, the wrapper worktrunk wrote must live inside one of the+/// directories `nu` actually autoloads (`$nu.vendor-autoload-dirs`). This fails+/// against the old `<config-dir>/vendor/autoload` behavior — that path is in+/// neither autoload list — and passes once the write path follows+/// `$nu.vendor-autoload-dirs`.+///+/// Gated on `shell-integration-tests` (CI installs `nu` on non-Windows runners).+#[cfg(all(unix, feature = "shell-integration-tests"))]+#[rstest]+fn test_nushell_install_target_is_a_vendor_autoload_dir(repo: TestRepo, temp_home: TempDir) {+ let home = canonical_temp_home(&temp_home);++ let mut cmd = wt_command();+ repo.configure_wt_cmd(&mut cmd);+ set_temp_home_env(&mut cmd, temp_home.path());+ cmd.env("SHELL", "/bin/nu");+ cmd.args(["config", "shell", "install", "nu", "--yes"])+ .current_dir(repo.root_path());+ let output = cmd.output().expect("Failed to execute install");+ assert!(+ output.status.success(),+ "Install should succeed:\nstderr: {}",+ String::from_utf8_lossy(&output.stderr)+ );++ // Ask the same `nu` (HOME isolated to temp_home) where it autoloads vendor+ // files, then confirm worktrunk's wrapper landed in one of those dirs.+ let listing = std::process::Command::new("nu")+ .args(["-c", "$nu.vendor-autoload-dirs | str join (char newline)"])+ .env("HOME", &home)+ .env("XDG_CONFIG_HOME", home.join(".config"))+ .output()+ .expect("nu must be on PATH (installed by .github/actions/test-setup)");+ assert!(+ listing.status.success(),+ "querying nu vendor-autoload-dirs failed:\nstderr: {}",+ String::from_utf8_lossy(&listing.stderr)+ );+ let dirs = String::from_utf8(listing.stdout).unwrap();++ let installed_in_autoload = dirs+ .lines()+ .map(str::trim)+ .filter(|l| !l.is_empty())+ .any(|d| std::path::Path::new(d).join("wt.nu").exists());+ assert!(+ installed_in_autoload,+ "worktrunk must install wt.nu into one of nu's vendor-autoload dirs (issue #2878).\n\+ vendor-autoload-dirs:\n{dirs}"+ );+}diff --git a/tests/snapshots/integration__integration_tests__config_show__config_show_nushell_outdated_wrapper.snap b/tests/snapshots/integration__integration_tests__config_show__config_show_nushell_outdated_wrapper.snapindex c4cf0124d..aa3d0f07b 100644--- a/tests/snapshots/integration__integration_tests__config_show__config_show_nushell_outdated_wrapper.snap+++ b/tests/snapshots/integration__integration_tests__config_show__config_show_nushell_outdated_wrapper.snap@@ -29,7 +29,6 @@ info:OPENCODE_CONFIG_DIR: "[TEST_OPENCODE_CONFIG]"PATH: "[PATH]"PSModulePath: ""- RUST_LOG: warnSHELL: ""TERM: alacrittyUSERPROFILE: "[TEST_HOME]"@@ -44,6 +43,7 @@ info:WORKTRUNK_TEST_FISH_INSTALLED: "0"WORKTRUNK_TEST_GEMINI_INSTALLED: "0"WORKTRUNK_TEST_NUSHELL_ENV: "0"+ WORKTRUNK_TEST_NU_VENDOR_AUTOLOAD_DIR: "[TEST_NU_VENDOR_AUTOLOAD]"WORKTRUNK_TEST_OPENCODE_INSTALLED: "0"WORKTRUNK_TEST_POWERSHELL_ENV: "0"WORKTRUNK_TEST_POWERSHELL_INSTALLED: "0"@@ -65,7 +65,7 @@ exit_code: 0[33m▲[39m [33mShell integration not active[39m[107m [0m Invoked as: [1m[PROJECT_ROOT]/target/[BUILD_MODE]/wt[22m-[33m▲[39m [33m[1mnu[22m: Outdated shell extension @ [1m~/.config/nushell/vendor/autoload/wt.nu[22m[39m+[33m▲[39m [33m[1mnu[22m: Outdated shell extension @ [1m~/.local/share/nushell/vendor/autoload/wt.nu[22m[39m[2m↳[22m [2mTo update, run [4mwt config shell install nu[24m[22m[36mOTHER[39m