bosun 0.36.2 → 0.36.4

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/bosun.schema.json

@@ -38,7 +38,13 @@
     "codexEnabled": { "type": "boolean" },
     "primaryAgent": {
       "type": "string",
-      "enum": ["codex-sdk", "copilot-sdk", "claude-sdk", "gemini-sdk", "opencode-sdk"]
+      "enum": [
+        "codex-sdk",
+        "copilot-sdk",
+        "claude-sdk",
+        "gemini-sdk",
+        "opencode-sdk"
+      ]
     },
     "telegramUiTunnel": {
       "type": "string",
@@ -147,6 +153,48 @@
           "default": "auto",
           "description": "Voice provider: openai/azure (Tier 1 realtime), claude/gemini (Tier 2 voice + provider vision), fallback (browser STT/TTS), auto (detect from env)"
         },
+        "providers": {
+          "type": "array",
+          "description": "Ordered provider candidates for voice routing/failover. First match with credentials is used.",
+          "items": {
+            "anyOf": [
+              {
+                "type": "string",
+                "enum": ["openai", "azure", "claude", "gemini", "fallback"]
+              },
+              {
+                "type": "object",
+                "additionalProperties": false,
+                "properties": {
+                  "provider": {
+                    "type": "string",
+                    "enum": ["openai", "azure", "claude", "gemini", "fallback"]
+                  },
+                  "model": { "type": "string" },
+                  "visionModel": { "type": "string" },
+                  "voiceId": {
+                    "type": "string",
+                    "enum": [
+                      "alloy",
+                      "ash",
+                      "ballad",
+                      "coral",
+                      "echo",
+                      "fable",
+                      "onyx",
+                      "nova",
+                      "sage",
+                      "shimmer",
+                      "verse"
+                    ]
+                  },
+                  "azureDeployment": { "type": "string" }
+                },
+                "required": ["provider"]
+              }
+            ]
+          }
+        },
         "model": {
           "type": "string",
           "default": "gpt-4o-realtime-preview-2024-12-17",
@@ -161,10 +209,18 @@
           "type": "string",
           "description": "OpenAI API key for Realtime API (overrides OPENAI_API_KEY env)"
         },
+        "openaiAccessToken": {
+          "type": "string",
+          "description": "OpenAI OAuth access token for voice (OAuth preferred over API key when present)"
+        },
         "azureApiKey": {
           "type": "string",
           "description": "Azure OpenAI API key for Realtime API"
         },
+        "azureAccessToken": {
+          "type": "string",
+          "description": "Azure OAuth/AAD access token for voice realtime"
+        },
         "azureEndpoint": {
           "type": "string",
           "description": "Azure OpenAI endpoint URL"
@@ -178,13 +234,33 @@
           "type": "string",
           "description": "Anthropic API key for Claude voice/vision provider mode"
         },
+        "claudeAccessToken": {
+          "type": "string",
+          "description": "Claude OAuth access token for voice provider mode"
+        },
         "geminiApiKey": {
           "type": "string",
           "description": "Gemini API key for Gemini voice/vision provider mode"
         },
+        "geminiAccessToken": {
+          "type": "string",
+          "description": "Gemini OAuth access token for voice provider mode"
+        },
         "voiceId": {
           "type": "string",
-          "enum": ["alloy", "ash", "ballad", "coral", "echo", "fable", "onyx", "nova", "sage", "shimmer", "verse"],
+          "enum": [
+            "alloy",
+            "ash",
+            "ballad",
+            "coral",
+            "echo",
+            "fable",
+            "onyx",
+            "nova",
+            "sage",
+            "shimmer",
+            "verse"
+          ],
           "default": "alloy",
           "description": "Voice ID for TTS output"
         },
@@ -204,9 +280,31 @@
           "default": "browser",
           "description": "Fallback when Realtime API unavailable: browser (Web Speech API) or disabled"
         },
+        "failover": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "enabled": {
+              "type": "boolean",
+              "default": true,
+              "description": "Enable automatic realtime failover across configured voice providers"
+            },
+            "maxAttempts": {
+              "type": "number",
+              "default": 2,
+              "description": "Maximum realtime provider attempts per voice session token request"
+            }
+          }
+        },
         "delegateExecutor": {
           "type": "string",
-          "enum": ["codex-sdk", "copilot-sdk", "claude-sdk", "gemini-sdk", "opencode-sdk"],
+          "enum": [
+            "codex-sdk",
+            "copilot-sdk",
+            "claude-sdk",
+            "gemini-sdk",
+            "opencode-sdk"
+          ],
           "description": "Which executor to use for delegate_to_agent calls. Defaults to primaryAgent."
         }
       }

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");