fix(shell): bound PATH repair fallbacks

apps/desktop/src/fixPath.ts

@@ -1,15 +1,10 @@
-import { readPathFromLoginShell } from "@t3tools/shared/shell";
+import { defaultShellCandidates, resolvePathFromLoginShells } from "@t3tools/shared/shell";
 
 export function fixPath(): void {
-  if (process.platform !== "darwin") return;
+  if (process.platform !== "darwin" && process.platform !== "linux") return;
 
-  try {
-    const shell = process.env.SHELL ?? "/bin/zsh";
-    const result = readPathFromLoginShell(shell);
-    if (result) {
-      process.env.PATH = result;
-    }
-  } catch {
-    // Keep inherited PATH if shell lookup fails.
+  const result = resolvePathFromLoginShells(defaultShellCandidates());
+  if (result) {
+    process.env.PATH = result;
   }
 }

apps/server/src/os-jank.ts

@@ -1,18 +1,15 @@
 import * as OS from "node:os";
 import { Effect, Path } from "effect";
-import { readPathFromLoginShell } from "@t3tools/shared/shell";
+import { defaultShellCandidates, resolvePathFromLoginShells } from "@t3tools/shared/shell";
 
 export function fixPath(): void {
-  if (process.platform !== "darwin") return;
+  if (process.platform !== "darwin" && process.platform !== "linux") return;
 
-  try {
-    const shell = process.env.SHELL ?? "/bin/zsh";
-    const result = readPathFromLoginShell(shell);
-    if (result) {
-      process.env.PATH = result;
-    }
-  } catch {
-    // Silently ignore — keep default PATH
+  const shells = defaultShellCandidates();
+
+  const resolvedPath = resolvePathFromLoginShells(shells);
+  if (resolvedPath) {
+    process.env.PATH = resolvedPath;
   }
 }
 

packages/shared/src/shell.test.ts

@@ -1,6 +1,11 @@
 import { describe, expect, it, vi } from "vitest";
 
-import { extractPathFromShellOutput, readPathFromLoginShell } from "./shell";
+import {
+  defaultShellCandidates,
+  extractPathFromShellOutput,
+  readPathFromLoginShell,
+  resolvePathFromLoginShells,
+} from "./shell";
 
 describe("extractPathFromShellOutput", () => {
   it("extracts the path between capture markers", () => {
@@ -54,4 +59,111 @@ describe("readPathFromLoginShell", () => {
     expect(args?.[1]).toContain("__T3CODE_PATH_END__");
     expect(options).toEqual({ encoding: "utf8", timeout: 5000 });
   });
+
+  it("falls back to non-interactive login mode when interactive login fails", () => {
+    const execFile = vi.fn<
+      (
+        file: string,
+        args: ReadonlyArray<string>,
+        options: { encoding: "utf8"; timeout: number },
+      ) => string
+    >((_, args) => {
+      if (args[0] === "-ilc") {
+        throw new Error("interactive login unsupported");
+      }
+      return "__T3CODE_PATH_START__\n/a:/b\n__T3CODE_PATH_END__\n";
+    });
+
+    expect(readPathFromLoginShell("/bin/sh", execFile)).toBe("/a:/b");
+    expect(execFile).toHaveBeenCalledTimes(2);
+    expect(execFile.mock.calls[0]?.[1]?.[0]).toBe("-ilc");
+    expect(execFile.mock.calls[1]?.[1]?.[0]).toBe("-lc");
+  });
+
+  describe("resolvePathFromLoginShells", () => {
+    it("returns the first resolved PATH from the provided shells", () => {
+      const execFile = vi.fn<
+        (
+          file: string,
+          args: ReadonlyArray<string>,
+          options: { encoding: "utf8"; timeout: number },
+        ) => string
+      >((file) => {
+        if (file === "/bin/zsh") {
+          throw new Error("zsh unavailable");
+        }
+        return "__T3CODE_PATH_START__\n/a:/b\n__T3CODE_PATH_END__\n";
+      });
+
+      const result = resolvePathFromLoginShells(["/bin/zsh", "/bin/bash"], execFile);
+      expect(result).toBe("/a:/b");
+      expect(execFile).toHaveBeenCalledTimes(2);
+    });
+
+    it("returns undefined when all shells fail to resolve PATH", () => {
+      const execFile = vi.fn<
+        (
+          file: string,
+          args: ReadonlyArray<string>,
+          options: { encoding: "utf8"; timeout: number },
+        ) => string
+      >(() => {
+        throw new Error("no shells available");
+      });
+
+      const result = resolvePathFromLoginShells(["/bin/zsh", "/bin/bash"], execFile);
+      expect(result).toBeUndefined();
+      expect(execFile).toHaveBeenCalledTimes(2);
+    });
+  });
+});
+
+describe("defaultShellCandidates", () => {
+  it("limits Linux candidates to the configured shell and POSIX fallback", () => {
+    const originalShell = process.env.SHELL;
+    process.env.SHELL = "/bin/bash";
+
+    try {
+      expect(defaultShellCandidates("linux")).toEqual(["/bin/bash", "/bin/sh"]);
+    } finally {
+      process.env.SHELL = originalShell;
+    }
+  });
+
+  it("dedupes repeated Linux shell candidates", () => {
+    const originalShell = process.env.SHELL;
+    process.env.SHELL = "/bin/sh";
+
+    try {
+      expect(defaultShellCandidates("linux")).toEqual(["/bin/sh"]);
+    } finally {
+      process.env.SHELL = originalShell;
+    }
+  });
+
+  it("limits macOS candidates to a small bounded fallback set", () => {
+    const originalShell = process.env.SHELL;
+    process.env.SHELL = "/opt/homebrew/bin/fish";
+
+    try {
+      expect(defaultShellCandidates("darwin")).toEqual([
+        "/opt/homebrew/bin/fish",
+        "/bin/zsh",
+        "/bin/bash",
+      ]);
+    } finally {
+      process.env.SHELL = originalShell;
+    }
+  });
+
+  it("dedupes repeated macOS shell candidates", () => {
+    const originalShell = process.env.SHELL;
+    process.env.SHELL = "/bin/zsh";
+
+    try {
+      expect(defaultShellCandidates("darwin")).toEqual(["/bin/zsh", "/bin/bash"]);
+    } finally {
+      process.env.SHELL = originalShell;
+    }
+  });
 });

packages/shared/src/shell.ts

@@ -14,6 +14,11 @@ type ExecFileSyncLike = (
   options: { encoding: "utf8"; timeout: number },
 ) => string;
 
+const LOGIN_SHELL_ARG_SETS = [
+  ["-ilc", PATH_CAPTURE_COMMAND],
+  ["-lc", PATH_CAPTURE_COMMAND],
+] as const;
+
 export function extractPathFromShellOutput(output: string): string | null {
   const startIndex = output.indexOf(PATH_CAPTURE_START);
   if (startIndex === -1) return null;
@@ -30,9 +35,80 @@ export function readPathFromLoginShell(
   shell: string,
   execFile: ExecFileSyncLike = execFileSync,
 ): string | undefined {
-  const output = execFile(shell, ["-ilc", PATH_CAPTURE_COMMAND], {
-    encoding: "utf8",
-    timeout: 5000,
-  });
-  return extractPathFromShellOutput(output) ?? undefined;
+  for (const args of LOGIN_SHELL_ARG_SETS) {
+    try {
+      const output = execFile(shell, args, {
+        encoding: "utf8",
+        timeout: 5000,
+      });
+      const resolvedPath = extractPathFromShellOutput(output) ?? undefined;
+      if (resolvedPath) {
+        return resolvedPath;
+      }
+    } catch {
+      // Try the next shell invocation mode.
+    }
+  }
+
+  return undefined;
+}
+
+function uniqueShellCandidates(candidates: ReadonlyArray<string | undefined>): string[] {
+  const unique = new Set<string>();
+
+  for (const candidate of candidates) {
+    if (typeof candidate !== "string") continue;
+    const normalized = candidate.trim();
+    if (normalized.length === 0 || unique.has(normalized)) continue;
+    unique.add(normalized);
+  }
+
+  return [...unique];
+}
+
+export function defaultShellCandidates(platform = process.platform): string[] {
+  if (platform === "linux") {
+    return uniqueShellCandidates([process.env.SHELL, "/bin/sh"]);
+  }
+
+  if (platform === "darwin") {
+    return uniqueShellCandidates([process.env.SHELL, "/bin/zsh", "/bin/bash"]);
+  }
+
+  return uniqueShellCandidates([
+    process.env.SHELL,
+    "/bin/zsh",
+    "/usr/bin/zsh",
+    "/bin/bash",
+    "/usr/bin/bash",
+  ]);
+}
+
+type ShellPathResolveErrorReporter = (shell: string, error: unknown) => void;
+
+const defaultShellPathErrorReporter: ShellPathResolveErrorReporter | undefined =
+  process.env.T3CODE_DEBUG_SHELL_PATH === "1"
+    ? (shell, error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`[shell] PATH resolution failed for ${shell}: ${message}`);
+      }
+    : undefined;
+
+export function resolvePathFromLoginShells(
+  shells: ReadonlyArray<string>,
+  execFile: ExecFileSyncLike = execFileSync,
+  onError: ShellPathResolveErrorReporter | undefined = defaultShellPathErrorReporter,
+): string | undefined {
+  for (const shell of shells) {
+    try {
+      const result = readPathFromLoginShell(shell, execFile);
+      if (result) {
+        return result;
+      }
+    } catch (error) {
+      onError?.(shell, error);
+      // Try next shell candidate.
+    }
+  }
+  return undefined;
 }