wave-agent-sdk 0.19.5 → 0.19.6

package/src/utils/shellResolver.ts

@@ -1,19 +1,170 @@
 import fs from "fs";
+import path from "path";
+import { execFileSync } from "child_process";
 
 export const WINDOWS_GIT_BASH_PATHS = [
   "C:\\Program Files\\Git\\bin\\bash.exe",
   "C:\\Program Files (x86)\\Git\\bin\\bash.exe",
 ];
 
-export function resolveShellPath(): string | undefined {
-  if (process.platform !== "win32") {
-    return undefined;
+// Common git.exe locations (checked before falling back to `where.exe`).
+const WINDOWS_GIT_EXE_PATHS = [
+  "C:\\Program Files\\Git\\cmd\\git.exe",
+  "C:\\Program Files (x86)\\Git\\cmd\\git.exe",
+];
+
+// Common directories where bash/zsh may live, used as fallback after PATH lookup.
+const FIXED_SHELL_DIRS = [
+  "/bin",
+  "/usr/bin",
+  "/usr/local/bin",
+  "/opt/homebrew/bin",
+];
+
+function isExecutable(shellPath: string): boolean {
+  try {
+    fs.accessSync(shellPath, fs.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Resolve a command name (e.g. "bash") to an absolute path by searching $PATH. */
+function which(command: string): string | undefined {
+  const pathEnv = process.env.PATH;
+  if (!pathEnv) return undefined;
+  for (const dir of pathEnv.split(":")) {
+    if (!dir) continue;
+    const candidate = path.join(dir, command);
+    if (isExecutable(candidate)) {
+      return candidate;
+    }
+  }
+  return undefined;
+}
+
+function isSupportedShell(shellPath: string): boolean {
+  return shellPath.includes("bash") || shellPath.includes("zsh");
+}
+
+/**
+ * Locate the `git` executable on Windows, then infer bash.exe from it.
+ * Checks common Git for Windows install locations first, then falls back
+ * to `where.exe git` (aligned with Claude Code's findExecutable('git')).
+ * Returns the inferred bash.exe path, or undefined if not found.
+ */
+function inferGitBashFromGit(): string | undefined {
+  // 1. Common git.exe locations
+  let gitExe: string | undefined;
+  for (const candidate of WINDOWS_GIT_EXE_PATHS) {
+    if (fs.existsSync(candidate)) {
+      gitExe = candidate;
+      break;
+    }
+  }
+
+  // 2. Fallback: where.exe git
+  if (!gitExe) {
+    try {
+      const result = execFileSync("where", ["git"], {
+        stdio: "pipe",
+        encoding: "utf8",
+        timeout: 3000,
+      }).trim();
+      // where.exe may return multiple lines; take the first non-empty one.
+      gitExe = result.split(/\r?\n/).find((line) => line.trim()) || undefined;
+    } catch {
+      gitExe = undefined;
+    }
+  }
+
+  if (!gitExe) return undefined;
+
+  // git.exe is at <install>/cmd/git.exe → bash.exe is at <install>/bin/bash.exe
+  // join treats git.exe as a segment, so ".." cancels it (→ cmd dir),
+  // the second ".." cancels cmd (→ <install>), then bin/bash.exe.
+  const bashPath = path.win32.join(gitExe, "..", "..", "bin", "bash.exe");
+  if (fs.existsSync(bashPath)) {
+    return bashPath;
   }
+  return undefined;
+}
 
-  if (process.env.GIT_BASH_PATH) {
-    return process.env.GIT_BASH_PATH;
+/**
+ * Resolve a bash or zsh binary on macOS/Linux.
+ *
+ * Priority (aligned with Claude Code's findSuitableShell):
+ *   1. WAVE_SHELL env var (only if it points to an executable bash/zsh)
+ *   2. $SHELL (only if it is bash/zsh)
+ *   3. `which bash` / `which zsh` discovered on $PATH
+ *   4. Common fixed locations (/bin, /usr/bin, /usr/local/bin, /opt/homebrew/bin)
+ *
+ * When $SHELL is bash, bash is preferred; otherwise zsh is preferred. This
+ * matters because /bin/sh may be dash (Debian/Ubuntu) or POSIX-mode bash
+ * (macOS), neither of which supports bashisms like process substitution
+ * `<()`, causing `eval '<()...'` to fail at parse time.
+ */
+function resolveUnixShell(): string | undefined {
+  // 1. WAVE_SHELL env override
+  const waveShell = process.env.WAVE_SHELL;
+  if (waveShell && isSupportedShell(waveShell) && isExecutable(waveShell)) {
+    return waveShell;
   }
 
+  // 2. $SHELL (only bash/zsh)
+  const envShell = process.env.SHELL;
+  const isEnvShellSupported = !!envShell && isSupportedShell(envShell);
+  const preferBash = envShell?.includes("bash") ?? false;
+
+  // 3. Locate via PATH
+  const bashPath = which("bash");
+  const zshPath = which("zsh");
+
+  // 4. Fixed common locations, ordered by user preference
+  const shellOrder = preferBash ? ["bash", "zsh"] : ["zsh", "bash"];
+  const candidates = shellOrder.flatMap((shell) =>
+    FIXED_SHELL_DIRS.map((dir) => `${dir}/${shell}`),
+  );
+
+  // Discovered PATH paths: preferred type first, the other as fallback
+  if (preferBash) {
+    if (bashPath) candidates.unshift(bashPath);
+    if (zshPath) candidates.push(zshPath);
+  } else {
+    if (zshPath) candidates.unshift(zshPath);
+    if (bashPath) candidates.push(bashPath);
+  }
+
+  // Always prioritize $SHELL if it is a supported, executable shell
+  if (isEnvShellSupported && envShell && isExecutable(envShell)) {
+    candidates.unshift(envShell);
+  }
+
+  return candidates.find((candidate) => isExecutable(candidate));
+}
+
+/**
+ * Resolve the Git Bash path on Windows.
+ *
+ * Priority (aligned with Claude Code's findGitBashPath):
+ *   1. WAVE_GIT_BASH_PATH env var
+ *   2. Infer from `git` executable location (<git dir>/../../bin/bash.exe)
+ *   3. Common install paths (C:\Program Files\Git\bin\bash.exe, etc.)
+ */
+function resolveWindowsShell(): string | undefined {
+  // 1. Env var override
+  if (process.env.WAVE_GIT_BASH_PATH) {
+    return process.env.WAVE_GIT_BASH_PATH;
+  }
+
+  // 2. Infer from git executable location
+  const inferred = inferGitBashFromGit();
+  if (inferred) {
+    return inferred;
+  }
+
+  // 4. Common install paths
   const paths = [
     ...WINDOWS_GIT_BASH_PATHS,
     process.env.LOCALAPPDATA
@@ -21,11 +172,19 @@ export function resolveShellPath(): string | undefined {
       : null,
   ].filter(Boolean) as string[];
 
-  for (const path of paths) {
-    if (fs.existsSync(path)) {
-      return path;
+  for (const p of paths) {
+    if (fs.existsSync(p)) {
+      return p;
     }
   }
 
   return undefined;
 }
+
+export function resolveShellPath(): string | undefined {
+  if (process.platform === "win32") {
+    return resolveWindowsShell();
+  }
+
+  return resolveUnixShell();
+}

package/src/utils/worktreeSession.ts

@@ -1,9 +1,11 @@
 /**
- * Module-level worktree session state tracking.
- * Analogous to Claude Code's currentWorktreeSession in worktree.ts.
+ * Worktree session state tracking.
  *
- * Tracks whether the current session entered a worktree via EnterWorktree tool,
- * so ExitWorktree can validate scope and restore the original CWD.
+ * The session state is stored per-agent in each session's DI container (see the
+ * "WorktreeSession" container slot registered in containerSetup.ts and accessed via
+ * AIManager.getWorktreeSession()/setWorktreeSession()). This keeps worktree state
+ * isolated per session in stdio multi-agent mode — a process-level singleton would
+ * leak state across concurrent sessions (see specs/047-worktree.md FR-042).
  */
 
 export interface WorktreeSession {
@@ -22,15 +24,3 @@ export interface WorktreeSession {
   /** The HEAD commit of the original branch at worktree creation time */
   originalHeadCommit?: string;
 }
-
-let currentWorktreeSession: WorktreeSession | null = null;
-
-export function getCurrentWorktreeSession(): WorktreeSession | null {
-  return currentWorktreeSession;
-}
-
-export function setCurrentWorktreeSession(
-  session: WorktreeSession | null,
-): void {
-  currentWorktreeSession = session;
-}