feat(setup): install bash completions as fallback for unsupported shells

Author: BYK

src/commands/cli/setup.ts

@@ -20,8 +20,10 @@ import {
   addToPath,
   detectShell,
   getPathCommand,
+  isBashAvailable,
   isInPath,
   type ShellInfo,
+  type ShellType,
 } from "../../lib/shell.js";
 import {
   type InstallationMethod,
@@ -117,8 +119,39 @@ async function handlePathModification(
   }
 }
 
+/**
+ * Attempt to install bash completions as a fallback for unsupported shells.
+ *
+ * Many custom shells (xonsh, nushell, etc.) can load bash completions,
+ * so this is a useful fallback when the user's shell isn't directly supported.
+ */
+async function tryBashCompletionFallback(
+  shellType: ShellType,
+  homeDir: string,
+  xdgDataHome: string | undefined,
+  log: Logger
+): Promise<void> {
+  if (!isBashAvailable()) {
+    log(`Completions: Not supported for ${shellType} shell`);
+    return;
+  }
+
+  const fallback = await installCompletions("bash", homeDir, xdgDataHome);
+  if (!fallback) {
+    log(`Completions: Not supported for ${shellType} shell`);
+    return;
+  }
+
+  const action = fallback.created ? "Installed" : "Updated";
+  log(`Completions: Your shell (${shellType}) is not directly supported`);
+  log(`      ${action} bash completions as a fallback: ${fallback.path}`);
+}
+
 /**
  * Handle shell completion installation.
+ *
+ * For unsupported shells (xonsh, nushell, etc.), falls back to installing
+ * bash completions if bash is available on the system.
  */
 async function handleCompletions(
   shell: ShellInfo,
@@ -139,9 +172,15 @@ async function handleCompletions(
         `      You may need to add to .zshrc: fpath=(${completionDir} $fpath)`
       );
     }
-  } else if (shell.type !== "sh" && shell.type !== "ash") {
-    log(`Completions: Not supported for ${shell.type} shell`);
+    return;
   }
+
+  // sh/ash are minimal POSIX shells — completions aren't expected
+  if (shell.type === "sh" || shell.type === "ash") {
+    return;
+  }
+
+  await tryBashCompletionFallback(shell.type, homeDir, xdgDataHome, log);
 }
 
 /**

src/lib/shell.ts

@@ -266,3 +266,17 @@ export async function addToGitHubPath(
     return false;
   }
 }
+
+/**
+ * Check if bash is available on the system.
+ *
+ * Uses `Bun.which` to search PATH for a bash executable.
+ * Useful as a fallback for unsupported shells — many custom shells
+ * (xonsh, nushell, etc.) support bash completions.
+ *
+ * @param pathEnv - Override PATH for testing. Defaults to the process PATH.
+ */
+export function isBashAvailable(pathEnv?: string): boolean {
+  const opts = pathEnv !== undefined ? { PATH: pathEnv } : undefined;
+  return Bun.which("bash", opts) !== null;
+}

test/commands/cli/setup.test.ts

@@ -297,13 +297,36 @@ describe("sentry cli setup", () => {
     expect(combined).toContain("GITHUB_PATH");
   });
 
-  test("shows unsupported message for sh shell completions", async () => {
+  test("falls back to bash completions for unsupported shell when bash is available", async () => {
     const { context, output } = createMockContext({
       homeDir: testDir,
       execPath: join(testDir, "bin", "sentry"),
       env: {
         PATH: `/usr/bin:${join(testDir, "bin")}:/bin`,
-        SHELL: "/bin/tcsh",
+        SHELL: "/bin/xonsh",
+      },
+    });
+
+    await run(
+      app,
+      ["cli", "setup", "--no-modify-path", "--no-agent-skills"],
+      context
+    );
+
+    const combined = output.join("");
+    // bash is available on the test system, so we should get fallback completions
+    expect(combined).toContain("not directly supported");
+    expect(combined).toContain("bash completions as a fallback");
+    expect(combined).toContain("bash-completion");
+  });
+
+  test("silently skips completions for sh shell", async () => {
+    const { context, output } = createMockContext({
+      homeDir: testDir,
+      execPath: join(testDir, "bin", "sentry"),
+      env: {
+        PATH: `/usr/bin:${join(testDir, "bin")}:/bin`,
+        SHELL: "/bin/sh",
       },
     });
 
@@ -314,7 +337,8 @@ describe("sentry cli setup", () => {
     );
 
     const combined = output.join("");
-    expect(combined).toContain("Not supported for");
+    // sh/ash shells silently skip completions — no message at all
+    expect(combined).not.toContain("Completions:");
   });
 
   test("supports kebab-case flags", async () => {

test/lib/shell.test.ts

@@ -7,13 +7,14 @@
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import {
   addToGitHubPath,
   addToPath,
   detectShell,
   findExistingConfigFile,
   getConfigCandidates,
+  isBashAvailable,
 } from "../../src/lib/shell.js";
 
 describe("shell utilities", () => {
@@ -257,3 +258,23 @@ describe("shell utilities", () => {
     });
   });
 });
+
+describe("isBashAvailable", () => {
+  test("returns true when bash is in PATH", () => {
+    // Point PATH at the directory containing bash
+    const bashPath = Bun.which("bash");
+    if (!bashPath) {
+      // Skip if bash truly isn't on this system
+      return;
+    }
+    expect(isBashAvailable(dirname(bashPath))).toBe(true);
+  });
+
+  test("returns false when PATH has no bash", () => {
+    expect(isBashAvailable("/nonexistent")).toBe(false);
+  });
+
+  test("returns false when PATH is empty", () => {
+    expect(isBashAvailable("")).toBe(false);
+  });
+});