bosun 0.36.2 → 0.36.3

package/autofix.mjs

@@ -688,6 +688,7 @@ function detectChangedFiles(repoRoot) {
       cwd: repoRoot,
       encoding: "utf8",
       timeout: 10_000,
+      stdio: ["pipe", "pipe", "pipe"],
     });
     return output
       .split(/\r?\n/)
@@ -708,6 +709,7 @@ function getChangeSummary(repoRoot, files) {
       cwd: repoRoot,
       encoding: "utf8",
       timeout: 10_000,
+      stdio: ["pipe", "pipe", "pipe"],
     });
     return diff.trim() || files.join(", ");
   } catch {

package/codex-shell.mjs

@@ -177,6 +177,7 @@ function sanitizeAndTruncatePrompt(text) {
   return truncated + `\n\n[...prompt truncated — ${removedBytes} bytes removed to stay within API limits]`;
 }
 const REPO_ROOT = resolveRepoRoot();
+const DEFAULT_WORKING_DIRECTORY = REPO_ROOT;
 
 // ── State ────────────────────────────────────────────────────────────────────
 
@@ -187,6 +188,7 @@ let activeThreadId = null; // Thread ID for resume
 let activeTurn = null; // Whether a turn is in-flight
 let turnCount = 0; // Number of turns in this thread
 let currentSessionId = null; // Active session identifier
+let activeWorkingDirectory = DEFAULT_WORKING_DIRECTORY; // Session/thread cwd
 let threadNeedsPriming = false; // True when a fresh thread needs the system prompt on next turn
 let codexRuntimeCaps = {
   hasSteeringApi: false,
@@ -200,6 +202,20 @@ function timestamp() {
   return new Date().toISOString();
 }
 
+function normalizeWorkingDirectory(input) {
+  const raw = String(input || "").trim();
+  if (!raw) return null;
+  try {
+    return resolve(raw);
+  } catch {
+    return null;
+  }
+}
+
+function getWorkingDirectory() {
+  return normalizeWorkingDirectory(activeWorkingDirectory) || DEFAULT_WORKING_DIRECTORY;
+}
+
 function resolveCodexTransport() {
   const raw = String(process.env.CODEX_TRANSPORT || "auto")
     .trim()
@@ -250,13 +266,17 @@ async function loadState() {
     activeThreadId = data.threadId || null;
     turnCount = data.turnCount || 0;
     currentSessionId = data.currentSessionId || null;
+    activeWorkingDirectory =
+      normalizeWorkingDirectory(data.workingDirectory) ||
+      DEFAULT_WORKING_DIRECTORY;
     console.log(
-      `[codex-shell] loaded state: threadId=${activeThreadId}, turns=${turnCount}, session=${currentSessionId}`,
+      `[codex-shell] loaded state: threadId=${activeThreadId}, turns=${turnCount}, session=${currentSessionId}, cwd=${getWorkingDirectory()}`,
     );
   } catch {
     activeThreadId = null;
     turnCount = 0;
     currentSessionId = null;
+    activeWorkingDirectory = DEFAULT_WORKING_DIRECTORY;
   }
 }
 
@@ -270,6 +290,7 @@ async function saveState() {
           threadId: activeThreadId,
           turnCount,
           currentSessionId,
+          workingDirectory: getWorkingDirectory(),
           updatedAt: timestamp(),
         },
         null,
@@ -311,6 +332,7 @@ async function saveCurrentSession() {
   await saveSessionData(currentSessionId, {
     threadId: activeThreadId,
     turnCount,
+    workingDirectory: getWorkingDirectory(),
     createdAt: (await loadSessionData(currentSessionId))?.createdAt || timestamp(),
     lastActiveAt: timestamp(),
   });
@@ -325,12 +347,16 @@ async function loadSession(sessionId) {
     turnCount = data.turnCount || 0;
     activeThread = null; // will be re-created/resumed via getThread()
     currentSessionId = sessionId;
-    console.log(`[codex-shell] loaded session ${sessionId}: threadId=${activeThreadId}, turns=${turnCount}`);
+    activeWorkingDirectory =
+      normalizeWorkingDirectory(data.workingDirectory) ||
+      DEFAULT_WORKING_DIRECTORY;
+    console.log(`[codex-shell] loaded session ${sessionId}: threadId=${activeThreadId}, turns=${turnCount}, cwd=${getWorkingDirectory()}`);
   } else {
     activeThread = null;
     activeThreadId = null;
     turnCount = 0;
     currentSessionId = sessionId;
+    activeWorkingDirectory = DEFAULT_WORKING_DIRECTORY;
     console.log(`[codex-shell] created new session ${sessionId}`);
   }
   await saveState();
@@ -366,9 +392,8 @@ Key files:
   AGENTS.md — Repo guide for agents
 `;
 
-const THREAD_OPTIONS = {
+const THREAD_BASE_OPTIONS = {
   sandboxMode: process.env.CODEX_SANDBOX || "workspace-write",
-  workingDirectory: REPO_ROOT,
   skipGitRepoCheck: true,
   webSearchMode: "live",
   approvalPolicy: "never",
@@ -377,6 +402,13 @@ const THREAD_OPTIONS = {
   // codex-config.mjs ensureFeatureFlags() handles this during setup.
 };
 
+function buildThreadOptions() {
+  return {
+    ...THREAD_BASE_OPTIONS,
+    workingDirectory: getWorkingDirectory(),
+  };
+}
+
 /**
  * Get or create a thread.
  * Uses fresh-thread mode by default to avoid context bloat.
@@ -384,6 +416,7 @@ const THREAD_OPTIONS = {
  */
 async function getThread() {
   if (activeThread) return activeThread;
+  const threadOptions = buildThreadOptions();
 
   const { env: resolvedEnv } = resolveCodexProfileRuntime(process.env);
   Object.assign(process.env, resolvedEnv);
@@ -391,8 +424,21 @@ async function getThread() {
   if (!codexInstance) {
     const Cls = await loadCodexSdk();
     if (!Cls) throw new Error("Codex SDK not available");
-    // Pass feature overrides via --config so they apply even if config.toml
-    // hasn't been patched by codex-config.mjs yet.
+
+    // Inject stream resilience settings via --config overrides so they apply
+    // even if config.toml hasn't been patched by codex-config.mjs yet.
+    // This is the most reliable path for Azure/Foundry deployments where
+    // dropped SSE streams ("response.failed") are the dominant failure mode.
+    const providerName = resolvedEnv.OPENAI_BASE_URL?.toLowerCase().includes(".openai.azure.com")
+      ? "azure"
+      : "openai";
+    const STREAM_IDLE_TIMEOUT_MS = 3_600_000; // 60 min — matches Azure max stream lifetime
+    const streamProviderOverrides = {
+      stream_idle_timeout_ms: STREAM_IDLE_TIMEOUT_MS,
+      stream_max_retries: 15,
+      request_max_retries: 6,
+    };
+
     codexInstance = new Cls({
       config: {
         features: {
@@ -402,8 +448,13 @@ async function getThread() {
           undo: true,
           steer: true,
         },
+        model_providers: {
+          [providerName]: streamProviderOverrides,
+        },
       },
     });
+
+    console.log(`[codex-shell] created Codex instance (provider=${providerName}, stream_idle_timeout=${STREAM_IDLE_TIMEOUT_MS}ms, stream_max_retries=${streamProviderOverrides.stream_max_retries})`);
   }
 
   const transport = resolveCodexTransport();
@@ -414,7 +465,7 @@ async function getThread() {
       try {
         activeThread = codexInstance.resumeThread(
           activeThreadId,
-          THREAD_OPTIONS,
+          threadOptions,
         );
         if (activeThread) {
           detectThreadCapabilities(activeThread);
@@ -446,16 +497,16 @@ async function getThread() {
   // the priming turn is STREAMED (runStreamed) instead of blocking (run).
   // This eliminates the 2-5 minute silent delay the chat UI suffered because
   // the old `thread.run(SYSTEM_PROMPT)` call produced zero streaming events.
-  activeThread = codexInstance.startThread(THREAD_OPTIONS);
+  activeThread = codexInstance.startThread(threadOptions);
   detectThreadCapabilities(activeThread);
   threadNeedsPriming = true;
 
   if (activeThread.id) {
     activeThreadId = activeThread.id;
     await saveState();
-    console.log(`[codex-shell] new thread started: ${activeThreadId} (priming deferred to first user turn)`);
+    console.log(`[codex-shell] new thread started: ${activeThreadId} (priming deferred to first user turn, cwd=${threadOptions.workingDirectory})`);
   } else {
-    console.log("[codex-shell] new thread started (priming deferred to first user turn)");
+    console.log(`[codex-shell] new thread started (priming deferred to first user turn, cwd=${threadOptions.workingDirectory})`);
   }
 
   return activeThread;
@@ -627,6 +678,7 @@ export async function execCodexPrompt(userMessage, options = {}) {
     persistent = false,
     sessionId = null,
     mode = null,
+    cwd = null,
   } = options;
 
   agentSdk = resolveAgentSdkConfig({ reload: true });
@@ -651,9 +703,13 @@ export async function execCodexPrompt(userMessage, options = {}) {
 
   try {
     const streamSafety = resolveCodexStreamSafety(timeoutMs);
+    const requestedWorkingDirectory = normalizeWorkingDirectory(cwd);
+
     if (!persistent) {
       // Task executor path — keep existing fresh-thread behavior
       activeThread = null;
+      activeWorkingDirectory =
+        requestedWorkingDirectory || DEFAULT_WORKING_DIRECTORY;
     } else if (sessionId && sessionId !== currentSessionId) {
       // Switching to a different persistent session
       await loadSession(sessionId);
@@ -669,6 +725,24 @@ export async function execCodexPrompt(userMessage, options = {}) {
     }
     // else: persistent && same session && under limit → reuse activeThread
 
+    if (
+      requestedWorkingDirectory &&
+      requestedWorkingDirectory !== getWorkingDirectory()
+    ) {
+      activeWorkingDirectory = requestedWorkingDirectory;
+      activeThread = null;
+      activeThreadId = null;
+      turnCount = 0;
+      threadNeedsPriming = false;
+      await saveState();
+      if (persistent && currentSessionId) {
+        await saveCurrentSession();
+      }
+      console.log(
+        `[codex-shell] switched working directory to ${requestedWorkingDirectory} for session ${currentSessionId || "(ephemeral)"}`,
+      );
+    }
+
     // ── Mode detection ───────────────────────────────────────────────────
     // "ask" mode should be lightweight — no heavy executor framing that
     // instructs the agent to run commands and read files.  The mode is
@@ -960,6 +1034,7 @@ export async function resetThread() {
   turnCount = 0;
   activeTurn = null;
   currentSessionId = null;
+  activeWorkingDirectory = DEFAULT_WORKING_DIRECTORY;
   threadNeedsPriming = false;
   await saveState();
   console.log("[codex-shell] thread reset");

package/git-editor-fix.mjs

@@ -0,0 +1,273 @@
+#!/usr/bin/env node
+/**
+ * git-editor-fix.mjs — Prevent agents from opening interactive editors
+ *
+ * Problem: Agents inherit user's git config which uses VSCode (`code --wait`)
+ * Result: Git operations block waiting for editor, freezing agents
+ *
+ * Solution: Set GIT_EDITOR=true (or GIT_EDITOR=:) for non-interactive mode
+ *
+ * This script ensures all agent workspaces have non-blocking git config.
+ * Covers: main repo, tmpclaude-* workspaces, git worktrees (ve/*),
+ *         and VK task worktrees under $TEMP/vibe-kanban/worktrees/.
+ */
+
+import { execSync } from "child_process";
+import { existsSync, readdirSync } from "fs";
+import { resolve, basename } from "path";
+import { tmpdir } from "os";
+import { fileURLToPath } from "url";
+import { resolveRepoRoot } from "./repo-root.mjs";
+
+const __dirname = resolve(fileURLToPath(new URL(".", import.meta.url)));
+const REPO_ROOT = resolveRepoRoot();
+
+/**
+ * Configure git to never open interactive editors
+ * @param {string} workspacePath - Path to workspace directory
+ * @returns {boolean} true if configured successfully
+ */
+function configureNonInteractiveGit(workspacePath) {
+  const gitDir = resolve(workspacePath, ".git");
+
+  // .git can be a file (worktree link) or a directory — both are valid
+  if (!existsSync(gitDir)) {
+    console.warn(`[git-editor-fix] No .git entry at ${workspacePath}`);
+    return false;
+  }
+
+  try {
+    // Set local git config for this workspace
+    // Use ':' (colon) as no-op editor — POSIX standard that always succeeds
+    execSync("git config --local core.editor :", {
+      cwd: workspacePath,
+      stdio: "pipe",
+    });
+
+    // Also disable merge commit editor prompts
+    execSync("git config --local merge.commit.autoEdit no", {
+      cwd: workspacePath,
+      stdio: "pipe",
+    });
+
+    console.log(
+      `[git-editor-fix] ✓ Configured ${workspacePath} for non-interactive git`,
+    );
+    return true;
+  } catch (err) {
+    console.error(
+      `[git-editor-fix] Failed to configure ${workspacePath}:`,
+      err.message,
+    );
+    return false;
+  }
+}
+
+// ── Workspace discovery helpers ──────────────────────────────────────────────
+
+/**
+ * Collect tmpclaude-* directories under REPO_ROOT
+ * @returns {string[]}
+ */
+function findTmpclaudeWorkspaces() {
+  /** @type {string[]} */
+  const results = [];
+  try {
+    const entries = readdirSync(REPO_ROOT, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && entry.name.startsWith("tmpclaude-")) {
+        results.push(resolve(REPO_ROOT, entry.name));
+      }
+    }
+  } catch (err) {
+    console.error(
+      "[git-editor-fix] Failed to scan tmpclaude workspaces:",
+      err.message,
+    );
+  }
+  return results;
+}
+
+/**
+ * Parse `git worktree list --porcelain` and return paths of ve/* worktrees
+ * @returns {string[]}
+ */
+function findGitWorktrees() {
+  /** @type {string[]} */
+  const results = [];
+  try {
+    const raw = execSync("git worktree list --porcelain", {
+      cwd: REPO_ROOT,
+      stdio: ["pipe", "pipe", "pipe"],
+      encoding: "utf-8",
+    });
+
+    // Porcelain output has blocks separated by blank lines.
+    // Each block starts with "worktree <path>".
+    // We also look for "branch refs/heads/ve/..." to identify VK worktrees,
+    // but we include ALL worktrees — they all need the fix.
+    for (const line of raw.split("\n")) {
+      const match = line.match(/^worktree\s+(.+)$/);
+      if (match) {
+        const wtPath = match[1].trim();
+        // Skip the bare repo entry if present
+        if (existsSync(resolve(wtPath, ".git"))) {
+          results.push(wtPath);
+        }
+      }
+    }
+  } catch (err) {
+    // git worktree list fails if the repo has no worktrees — that's fine
+    if (!String(err.message).includes("is not a git repository")) {
+      console.warn(
+        "[git-editor-fix] Could not enumerate git worktrees:",
+        err.message,
+      );
+    }
+  }
+  return results;
+}
+
+/**
+ * Scan $TEMP/vibe-kanban/worktrees/ for VK task worktree directories
+ * @returns {string[]}
+ */
+function findVKWorktrees() {
+  /** @type {string[]} */
+  const results = [];
+  const vkBase = resolve(tmpdir(), "vibe-kanban", "worktrees");
+
+  if (!existsSync(vkBase)) {
+    return results;
+  }
+
+  try {
+    const entries = readdirSync(vkBase, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const candidate = resolve(vkBase, entry.name);
+        if (existsSync(resolve(candidate, ".git"))) {
+          results.push(candidate);
+        }
+      }
+    }
+  } catch (err) {
+    console.error("[git-editor-fix] Failed to scan VK worktrees:", err.message);
+  }
+  return results;
+}
+
+// ── Main functions ───────────────────────────────────────────────────────────
+
+/**
+ * Scan for all agent workspaces and fix git config.
+ * Sources:
+ *   1. Main repo root (REPO_ROOT)
+ *   2. tmpclaude-* directories
+ *   3. git worktrees (parsed from `git worktree list --porcelain`)
+ *   4. VK task worktrees under $TEMP/vibe-kanban/worktrees/
+ *
+ * Paths are deduplicated before configuration.
+ */
+function fixAllWorkspaces() {
+  console.log("[git-editor-fix] Scanning for agent workspaces...");
+
+  /** @type {Set<string>} */
+  const seen = new Set();
+
+  /** @param {string} p */
+  const add = (p) => {
+    const normalized = resolve(p);
+    seen.add(normalized);
+  };
+
+  // 1. Main repo root
+  add(REPO_ROOT);
+
+  // 2. tmpclaude-* directories
+  for (const ws of findTmpclaudeWorkspaces()) {
+    add(ws);
+  }
+
+  // 3. Git worktrees (includes ve/* branches)
+  for (const ws of findGitWorktrees()) {
+    add(ws);
+  }
+
+  // 4. VK worktrees under $TEMP
+  for (const ws of findVKWorktrees()) {
+    add(ws);
+  }
+
+  const workspaces = [...seen];
+  console.log(
+    `[git-editor-fix] Found ${workspaces.length} workspace(s) to configure`,
+  );
+
+  let fixed = 0;
+  for (const ws of workspaces) {
+    if (configureNonInteractiveGit(ws)) {
+      fixed++;
+    }
+  }
+
+  console.log(
+    `[git-editor-fix] ✓ Fixed ${fixed}/${workspaces.length} workspaces`,
+  );
+}
+
+/**
+ * Convenience wrapper: configure the main repo and all discoverable worktrees
+ * in a single call. Suitable for use from other modules.
+ * @returns {{ fixed: number, total: number }}
+ */
+function configureRepoAndWorktrees() {
+  console.log("[git-editor-fix] Configuring repo and all worktrees...");
+
+  /** @type {Set<string>} */
+  const seen = new Set();
+
+  const add = (/** @type {string} */ p) => seen.add(resolve(p));
+
+  add(REPO_ROOT);
+  findTmpclaudeWorkspaces().forEach(add);
+  findGitWorktrees().forEach(add);
+  findVKWorktrees().forEach(add);
+
+  const workspaces = [...seen];
+  let fixed = 0;
+  for (const ws of workspaces) {
+    if (configureNonInteractiveGit(ws)) {
+      fixed++;
+    }
+  }
+
+  console.log(
+    `[git-editor-fix] ✓ Configured ${fixed}/${workspaces.length} workspace(s)`,
+  );
+  return { fixed, total: workspaces.length };
+}
+
+// ── CLI Entry Point ──────────────────────────────────────────────────────────
+
+const isMainModule = () => {
+  try {
+    const modulePath = fileURLToPath(import.meta.url);
+    return process.argv[1] === modulePath;
+  } catch {
+    return false;
+  }
+};
+
+if (isMainModule()) {
+  fixAllWorkspaces();
+}
+
+export {
+  configureNonInteractiveGit,
+  fixAllWorkspaces,
+  configureRepoAndWorktrees,
+  findGitWorktrees,
+  findVKWorktrees,
+  findTmpclaudeWorkspaces,
+};