bosun 0.34.5 → 0.34.6

package/codex-config.mjs

@@ -887,14 +887,17 @@ export function buildCommonMcpBlocks() {
     "",
     "# ── Common MCP servers (added by bosun) ──",
     "[mcp_servers.context7]",
+    "startup_timeout_sec = 120",
     'command = "npx"',
     'args = ["-y", "@upstash/context7-mcp"]',
     "",
     "[mcp_servers.sequential-thinking]",
+    "startup_timeout_sec = 120",
     'command = "npx"',
     'args = ["-y", "@modelcontextprotocol/server-sequential-thinking"]',
     "",
     "[mcp_servers.playwright]",
+    "startup_timeout_sec = 120",
     'command = "npx"',
     'args = ["-y", "@playwright/mcp@latest"]',
     "",
@@ -914,6 +917,44 @@ function hasNamedMcpServer(toml, name) {
   );
 }
 
+function ensureMcpStartupTimeout(toml, name, timeoutSec = 120) {
+  const header = `[mcp_servers.${name}]`;
+  const headerIdx = toml.indexOf(header);
+  if (headerIdx === -1) return { toml, changed: false };
+
+  const afterHeader = headerIdx + header.length;
+  const nextSection = toml.indexOf("\n[", afterHeader);
+  const sectionEnd = nextSection === -1 ? toml.length : nextSection;
+  let section = toml.substring(afterHeader, sectionEnd);
+
+  const timeoutRegex = /^startup_timeout_sec\s*=\s*\d+.*$/m;
+  let changed = false;
+  if (timeoutRegex.test(section)) {
+    const desired = `startup_timeout_sec = ${timeoutSec}`;
+    const updated = section.replace(timeoutRegex, desired);
+    if (updated !== section) {
+      section = updated;
+      changed = true;
+    }
+  } else {
+    section = section.trimEnd() + `\nstartup_timeout_sec = ${timeoutSec}\n`;
+    changed = true;
+  }
+
+  if (!changed) return { toml, changed: false };
+  return {
+    toml: toml.substring(0, afterHeader) + section + toml.substring(sectionEnd),
+    changed: true,
+  };
+}
+
+function stripDeprecatedSandboxPermissions(toml) {
+  return String(toml || "").replace(
+    /^\s*sandbox_permissions\s*=.*(?:\r?\n)?/gim,
+    "",
+  );
+}
+
 // ── Public API ───────────────────────────────────────────────────────────────
 
 /**
@@ -1298,6 +1339,207 @@ export function ensureCodexConfig({
     noChanges: true,
   };
 
+  const configExisted = existsSync(CONFIG_PATH);
+  const originalToml = readCodexConfig();
+  let toml = stripDeprecatedSandboxPermissions(originalToml);
+  if (!configExisted) {
+    result.created = true;
+    toml = "";
+  }
+
+  const sandboxModeResult = ensureTopLevelSandboxMode(
+    toml,
+    env.CODEX_SANDBOX_MODE,
+  );
+  toml = sandboxModeResult.toml;
+  if (sandboxModeResult.changed) {
+    result.sandboxAdded = true;
+  }
+
+  const repoRoot =
+    env.BOSUN_AGENT_REPO_ROOT ||
+    env.REPO_ROOT ||
+    env.BOSUN_HOME ||
+    process.cwd();
+  const additionalRoots = env.BOSUN_WORKSPACES_DIR
+    ? [env.BOSUN_WORKSPACES_DIR]
+    : [];
+  const sandboxWorkspaceResult = ensureSandboxWorkspaceWrite(toml, {
+    repoRoot,
+    additionalRoots,
+    writableRoots: env.CODEX_SANDBOX_WRITABLE_ROOTS,
+  });
+  toml = sandboxWorkspaceResult.toml;
+  result.sandboxWorkspaceAdded = sandboxWorkspaceResult.added;
+  result.sandboxWorkspaceUpdated =
+    sandboxWorkspaceResult.changed && !sandboxWorkspaceResult.added;
+  result.sandboxWorkspaceRootsAdded = sandboxWorkspaceResult.rootsAdded;
+
+  const pruneResult = pruneStaleSandboxRoots(toml);
+  toml = pruneResult.toml;
+  result.sandboxStaleRootsRemoved = pruneResult.removed;
+
+  if (!hasShellEnvPolicy(toml)) {
+    toml += buildShellEnvPolicy(env.CODEX_SHELL_ENV_POLICY || "all");
+    result.shellEnvAdded = true;
+  }
+
+  const rawPrimary = String(primarySdk || env.PRIMARY_AGENT || "codex")
+    .trim()
+    .toLowerCase();
+  const normalizedPrimary =
+    rawPrimary === "copilot" || rawPrimary.includes("copilot")
+      ? "copilot"
+      : rawPrimary === "claude" || rawPrimary.includes("claude")
+        ? "claude"
+        : rawPrimary === "codex" || rawPrimary.includes("codex")
+          ? "codex"
+          : "codex";
+  if (!hasAgentSdkConfig(toml)) {
+    toml += buildAgentSdkBlock({ primary: normalizedPrimary });
+    result.agentSdkAdded = true;
+  }
+
+  const maxThreads = resolveAgentMaxThreads(env);
+  if (maxThreads.explicit && !maxThreads.value) {
+    result.agentMaxThreadsSkipped = String(maxThreads.raw);
+  } else {
+    const maxThreadsResult = ensureAgentMaxThreads(toml, {
+      maxThreads: maxThreads.value,
+      overwrite: maxThreads.explicit,
+    });
+    toml = maxThreadsResult.toml;
+    if (maxThreadsResult.changed && !maxThreadsResult.skipped) {
+      result.agentMaxThreads = {
+        from: maxThreadsResult.existing,
+        to: maxThreadsResult.applied,
+        explicit: maxThreads.explicit,
+      };
+    } else if (maxThreadsResult.skipped && maxThreads.explicit) {
+      result.agentMaxThreadsSkipped = String(maxThreads.raw);
+    }
+  }
+
+  const featureResult = ensureFeatureFlags(toml, env);
+  result.featuresAdded = featureResult.added;
+  toml = featureResult.toml;
+
+  if (skipVk) {
+    if (hasVibeKanbanMcp(toml)) {
+      toml = removeVibeKanbanMcp(toml);
+      result.vkRemoved = true;
+    }
+  } else if (!hasVibeKanbanMcp(toml)) {
+    toml += buildVibeKanbanBlock({ vkBaseUrl });
+    result.vkAdded = true;
+  } else {
+    const vkEnvValues = {
+      VK_BASE_URL: vkBaseUrl,
+      VK_ENDPOINT_URL: vkBaseUrl,
+    };
+    const beforeVkEnv = toml;
+    if (!hasVibeKanbanEnv(toml)) {
+      toml =
+        toml.trimEnd() +
+        "\n\n[mcp_servers.vibe_kanban.env]\n" +
+        `VK_BASE_URL = "${vkBaseUrl}"\n` +
+        `VK_ENDPOINT_URL = "${vkBaseUrl}"\n`;
+    } else {
+      toml = updateVibeKanbanEnv(toml, vkEnvValues);
+    }
+    if (toml !== beforeVkEnv) {
+      result.vkEnvUpdated = true;
+    }
+  }
+
+  const commonMcpBlocks = [
+    {
+      present: hasContext7Mcp(toml),
+      block: [
+        "",
+        "# ── Common MCP servers (added by bosun) ──",
+        "[mcp_servers.context7]",
+        "startup_timeout_sec = 120",
+        'command = "npx"',
+        'args = ["-y", "@upstash/context7-mcp"]',
+        "",
+      ].join("\n"),
+    },
+    {
+      present: hasNamedMcpServer(toml, "sequential-thinking"),
+      block: [
+        "",
+        "[mcp_servers.sequential-thinking]",
+        "startup_timeout_sec = 120",
+        'command = "npx"',
+        'args = ["-y", "@modelcontextprotocol/server-sequential-thinking"]',
+        "",
+      ].join("\n"),
+    },
+    {
+      present: hasNamedMcpServer(toml, "playwright"),
+      block: [
+        "",
+        "[mcp_servers.playwright]",
+        "startup_timeout_sec = 120",
+        'command = "npx"',
+        'args = ["-y", "@playwright/mcp@latest"]',
+        "",
+      ].join("\n"),
+    },
+    {
+      present: hasMicrosoftDocsMcp(toml),
+      block: [
+        "",
+        "[mcp_servers.microsoft-docs]",
+        'url = "https://learn.microsoft.com/api/mcp"',
+        'tools = ["microsoft_docs_search", "microsoft_code_sample_search"]',
+        "",
+      ].join("\n"),
+    },
+  ];
+  for (const item of commonMcpBlocks) {
+    if (item.present) continue;
+    toml += item.block;
+    result.commonMcpAdded = true;
+  }
+
+  for (const serverName of ["context7", "sequential-thinking", "playwright"]) {
+    const timeoutResult = ensureMcpStartupTimeout(toml, serverName, 120);
+    toml = timeoutResult.toml;
+  }
+
+  const providerResult = ensureModelProviderSectionsFromEnv(toml, env);
+  toml = providerResult.toml;
+  result.profileProvidersAdded = providerResult.added;
+
+  const timeoutAudit = auditStreamTimeouts(toml);
+  for (const item of timeoutAudit) {
+    if (!item.needsUpdate) continue;
+    toml = setStreamTimeout(toml, item.provider, RECOMMENDED_STREAM_IDLE_TIMEOUT_MS);
+    result.timeoutsFixed.push({
+      provider: item.provider,
+      from: item.currentValue,
+      to: RECOMMENDED_STREAM_IDLE_TIMEOUT_MS,
+    });
+  }
+
+  const providers = auditStreamTimeouts(toml).map((item) => item.provider);
+  for (const provider of providers) {
+    const beforeRetry = toml;
+    toml = ensureRetrySettings(toml, provider);
+    if (toml !== beforeRetry) {
+      result.retriesAdded.push(provider);
+    }
+  }
+
+  const changed = toml !== originalToml;
+  result.noChanges = !result.created && !changed;
+
+  if (!dryRun && (result.created || changed)) {
+    writeCodexConfig(toml);
+  }
+
   return result;
 }
 

package/config.mjs

@@ -29,6 +29,7 @@ import { applyAllCompatibility } from "./compat.mjs";
 import {
   normalizeExecutorKey,
   getModelsForExecutor,
+  MODEL_ALIASES,
 } from "./task-complexity.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -408,13 +409,43 @@ function parseListValue(value) {
     .filter(Boolean);
 }
 
-function normalizeExecutorModels(executor, models) {
+function inferExecutorModelsFromVariant(executor, variant) {
+  const normalizedExecutor = normalizeExecutorKey(executor);
+  if (!normalizedExecutor) return [];
+  const normalizedVariant = String(variant || "DEFAULT")
+    .trim()
+    .toUpperCase();
+  if (!normalizedVariant || normalizedVariant === "DEFAULT") return [];
+
+  const known = getModelsForExecutor(normalizedExecutor);
+  const inferred = known.filter((model) => {
+    const alias = MODEL_ALIASES[model];
+    return (
+      String(alias?.variant || "")
+        .trim()
+        .toUpperCase() === normalizedVariant
+    );
+  });
+  if (inferred.length > 0) return inferred;
+
+  // Fallback for variants encoded as model slug with underscores.
+  const slugGuess = normalizedVariant.toLowerCase().replaceAll("_", "-");
+  if (known.includes(slugGuess)) return [slugGuess];
+
+  return [];
+}
+
+function normalizeExecutorModels(executor, models, variant = "DEFAULT") {
   const normalizedExecutor = normalizeExecutorKey(executor);
   if (!normalizedExecutor) return [];
   const input = parseListValue(models);
   const known = new Set(getModelsForExecutor(normalizedExecutor));
   if (input.length === 0) {
-    return [...known];
+    const inferred = inferExecutorModelsFromVariant(
+      normalizedExecutor,
+      variant,
+    );
+    return inferred.length > 0 ? inferred : [...known];
   }
   return input.filter((model) => known.has(model));
 }
@@ -433,7 +464,7 @@ function normalizeExecutorEntry(entry, index = 0, total = 1) {
   const name =
     String(entry.name || "").trim() ||
     `${normalized}-${String(variant || "default").toLowerCase()}`;
-  const models = normalizeExecutorModels(executorType, entry.models);
+  const models = normalizeExecutorModels(executorType, entry.models, variant);
   const codexProfile = String(
     entry.codexProfile || entry.modelProfile || "",
   ).trim();
@@ -723,7 +754,11 @@ function parseExecutorsFromEnv() {
     const parts = entries[i].split(":");
     if (parts.length < 2) continue;
     const executorType = parts[0].toUpperCase();
-    const models = normalizeExecutorModels(executorType, parts[3] || "");
+    const models = normalizeExecutorModels(
+      executorType,
+      parts[3] || "",
+      parts[1] || "DEFAULT",
+    );
     executors.push({
       name: `${parts[0].toLowerCase()}-${parts[1].toLowerCase()}`,
       executor: executorType,
@@ -857,12 +892,23 @@ function loadExecutorConfig(configDir, configData) {
 
     for (let index = 0; index < executors.length; index++) {
       const current = executors[index];
-      if (current.codexProfile) continue;
       const match = findExecutorMetadataMatch(current, fileExecutors, index);
-      if (!match?.codexProfile) continue;
+      if (!match) continue;
+      const merged = { ...current };
+      if (typeof match.name === "string" && match.name.trim()) {
+        merged.name = match.name.trim();
+      }
+      if (typeof match.enabled === "boolean") {
+        merged.enabled = match.enabled;
+      }
+      if (Array.isArray(match.models) && match.models.length > 0) {
+        merged.models = [...new Set(match.models)];
+      }
+      if (match.codexProfile) {
+        merged.codexProfile = match.codexProfile;
+      }
       executors[index] = {
-        ...current,
-        codexProfile: match.codexProfile,
+        ...merged,
       };
     }
   }

package/monitor.mjs

@@ -478,8 +478,12 @@ async function ensureWorkflowAutomationEngine() {
           delete payload.projectId;
           return createTask(projectId, payload);
         },
-        updateTaskStatus: async (taskId, status) =>
-          updateKanbanTaskStatus(String(taskId || ""), String(status || "")),
+        updateTaskStatus: async (taskId, status, options = {}) =>
+          updateTaskStatus(
+            String(taskId || ""),
+            String(status || ""),
+            options && typeof options === "object" ? options : {},
+          ),
         listTasks: async (projectId, filters = {}) =>
           listKanbanTasks(String(projectId || ""), filters || {}),
       };
@@ -4431,6 +4435,10 @@ async function updateTaskStatus(taskId, newStatus, options = {}) {
     options?.taskData && typeof options.taskData === "object"
       ? options.taskData
       : null;
+  const workflowData =
+    options?.workflowData && typeof options.workflowData === "object"
+      ? options.workflowData
+      : null;
   const taskTitle = String(
     options?.taskTitle || taskData?.title || getInternalTask(normalizedTaskId)?.title || "",
   ).trim();
@@ -4444,6 +4452,43 @@ async function updateTaskStatus(taskId, newStatus, options = {}) {
     taskTitle,
     previousStatus: previousStatus || null,
     status: normalizedStatus,
+    branch: String(
+      options?.branch ||
+        taskData?.branch ||
+        taskData?.branchName ||
+        taskData?.meta?.branch_name ||
+        workflowData?.branch ||
+        "",
+    ).trim() || null,
+    baseBranch: String(
+      options?.baseBranch ||
+        taskData?.baseBranch ||
+        taskData?.base_branch ||
+        taskData?.meta?.base_branch ||
+        workflowData?.baseBranch ||
+        "",
+    ).trim() || null,
+    worktreePath: String(
+      options?.worktreePath ||
+        taskData?.worktreePath ||
+        taskData?.meta?.worktreePath ||
+        workflowData?.worktreePath ||
+        "",
+    ).trim() || null,
+    prNumber: String(
+      options?.prNumber ||
+        taskData?.prNumber ||
+        taskData?.meta?.pr_number ||
+        workflowData?.prNumber ||
+        "",
+    ).trim() || null,
+    prUrl: String(
+      options?.prUrl ||
+        taskData?.prUrl ||
+        taskData?.meta?.pr_url ||
+        workflowData?.prUrl ||
+        "",
+    ).trim() || null,
   };
   const queueTaskStatusWorkflowEvents = () => {
     const statusChanged = previousStatus !== normalizedStatus;
@@ -14536,6 +14581,29 @@ if (isExecutorDisabled()) {
       },
       onTaskCompleted: (task, result) => {
         const taskId = String(task?.id || task?.task_id || "").trim();
+        const branch = String(
+          result?.branch ||
+            task?.branchName ||
+            task?.meta?.branch_name ||
+            "",
+        ).trim() || null;
+        const worktreePath = String(
+          result?.worktreePath ||
+            task?.worktreePath ||
+            task?.meta?.worktreePath ||
+            "",
+        ).trim() || null;
+        const prNumber = result?.prNumber
+          ? String(result.prNumber)
+          : null;
+        const prUrl = String(result?.prUrl || "").trim() || null;
+        const baseBranch = String(
+          result?.baseBranch ||
+            task?.baseBranch ||
+            task?.base_branch ||
+            task?.meta?.base_branch ||
+            "",
+        ).trim() || null;
         console.log(
           `[task-executor] ✅ completed: "${task.title}" (${result.attempts} attempt(s))`,
         );
@@ -14566,6 +14634,11 @@ if (isExecutorDisabled()) {
               taskStatus: "completed",
               attempts: Number(result?.attempts || 0),
               success: result?.success !== false,
+              branch,
+              worktreePath,
+              prNumber,
+              prUrl,
+              baseBranch,
             },
             { dedupKey: `workflow-event:task.completed:${taskId}:${result?.attempts || 0}` },
           );
@@ -14573,6 +14646,27 @@ if (isExecutorDisabled()) {
       },
       onTaskFailed: (task, err) => {
         const taskId = String(task?.id || task?.task_id || "").trim();
+        const branch = String(
+          err?.branch ||
+            task?.branchName ||
+            task?.meta?.branch_name ||
+            "",
+        ).trim() || null;
+        const worktreePath = String(
+          err?.worktreePath ||
+            task?.worktreePath ||
+            task?.meta?.worktreePath ||
+            "",
+        ).trim() || null;
+        const baseBranch = String(
+          err?.baseBranch ||
+            task?.baseBranch ||
+            task?.base_branch ||
+            task?.meta?.base_branch ||
+            "",
+        ).trim() || null;
+        const attempts =
+          Number(err?.attempts || 0) > 0 ? Number(err.attempts) : null;
         console.warn(
           `[task-executor] ❌ failed: "${task.title}" — ${formatMonitorError(err)}`,
         );
@@ -14586,6 +14680,10 @@ if (isExecutorDisabled()) {
               taskTitle: task?.title || "",
               taskStatus: "failed",
               error: errorMessage,
+              branch,
+              worktreePath,
+              baseBranch,
+              attempts,
             },
             { dedupKey: `workflow-event:task.failed:${taskId}:${errorMessage}` },
           );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bosun",
-  "version": "0.34.5",
+  "version": "0.34.6",
   "description": "AI-powered orchestrator supervisor — manages AI agent executors with failover, auto-restarts on failure, analyzes crashes with Codex SDK, creates PRs via Vibe-Kanban API, and sends Telegram notifications. Supports N executors with weighted distribution, multi-repo projects, and auto-setup.",
   "type": "module",
   "license": "Apache 2.0",