bosun 0.34.4 → 0.34.6

package/agent-endpoint.mjs

@@ -30,7 +30,7 @@ const TAG = "[agent-endpoint]";
 const DEFAULT_PORT = 18432;
 const MAX_BODY_SIZE = 1024 * 1024; // 1 MB
 const REQUEST_TIMEOUT_MS = 30_000; // 30 seconds
-const ACCESS_DENIED_COOLDOWN_MS = 10 * 60 * 1000; // 10 minutes
+const ACCESS_DENIED_COOLDOWN_MS = 10 * 60 * 1000; // 10 minutes
 const BOSUN_ROOT_HINT = __dirname.toLowerCase().replace(/\\/g, '/');
 
 // Valid status transitions when an agent self-reports
@@ -1387,4 +1387,4 @@ export class AgentEndpoint {
 export function createAgentEndpoint(options) {
   return new AgentEndpoint(options);
 }
-
+

package/agent-event-bus.mjs

@@ -112,8 +112,8 @@ export class AgentEventBus {
       options.staleThresholdMs || DEFAULTS.staleThresholdMs;
     this._staleCheckIntervalMs =
       options.staleCheckIntervalMs || DEFAULTS.staleCheckIntervalMs;
-    this._maxAutoRetries =
-      options.maxAutoRetries ?? DEFAULTS.maxAutoRetries;
+    this._maxAutoRetries =
+      options.maxAutoRetries ?? DEFAULTS.maxAutoRetries;
     this._dedupeWindowMs = options.dedupeWindowMs || DEFAULTS.dedupeWindowMs;
 
     /** @type {Array<{type: string, taskId: string, payload: object, ts: number}>} ring buffer */
@@ -203,7 +203,7 @@ export class AgentEventBus {
 
     // ── Dedup
     const key = `${type}:${taskId}`;
-    const last = this._recentEmits.get(key);
+    const last = this._recentEmits.get(key);
     if (typeof last === "number" && ts - last < this._dedupeWindowMs) return;
     this._recentEmits.set(key, ts);
     if (this._recentEmits.size > 200) {

package/agent-work-report.mjs

@@ -359,4 +359,4 @@ export function shouldSendWeeklyReport(options = {}) {
     return true;
   }
   return lastSentMs < scheduledThisWeek.getTime();
-}
+}

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/maintenance.mjs

@@ -888,26 +888,93 @@ export function syncLocalTrackingBranches(repoRoot, branches) {
       );
       if (remoteCheck.status !== 0) continue;
 
-      // Compare: is local behind?
+      // Measure divergence in both directions up front
       const behindCheck = spawnSync(
         "git",
         ["rev-list", "--count", `${branch}..${remoteRef}`],
         { cwd: repoRoot, encoding: "utf8", timeout: 5000, windowsHide: true },
       );
       const behind = parseInt(behindCheck.stdout?.trim(), 10) || 0;
-      if (behind === 0) continue; // Already up to date
 
-      // Check if local has commits not in remote (diverged)
       const aheadCheck = spawnSync(
         "git",
         ["rev-list", "--count", `${remoteRef}..${branch}`],
         { cwd: repoRoot, encoding: "utf8", timeout: 5000, windowsHide: true },
       );
       const ahead = parseInt(aheadCheck.stdout?.trim(), 10) || 0;
-      if (ahead > 0) {
-        console.warn(
-          `[maintenance] local '${branch}' has ${ahead} commit(s) ahead of ${remoteRef} — skipping (diverged)`,
+
+      if (behind === 0 && ahead === 0) continue; // Already in sync
+
+      // Local is ahead of remote but not behind — try a plain push
+      if (behind === 0 && ahead > 0) {
+        const push = spawnSync(
+          "git",
+          ["push", "origin", `${branch}:refs/heads/${branch}`, "--quiet"],
+          { cwd: repoRoot, encoding: "utf8", timeout: 30_000, windowsHide: true },
         );
+        if (push.status === 0) {
+          console.log(
+            `[maintenance] pushed local '${branch}' to origin (${ahead} commit(s) ahead)`,
+          );
+          synced++;
+        } else {
+          console.warn(
+            `[maintenance] git push '${branch}' failed: ${(push.stderr || push.stdout || "").toString().trim()}`,
+          );
+        }
+        continue;
+      }
+
+      // Truly diverged: local has unique commits AND is missing remote commits.
+      // Attempt rebase onto remote then push (checked-out branch only).
+      if (ahead > 0) {
+        const statusCheck = spawnSync("git", ["status", "--porcelain"], {
+          cwd: repoRoot,
+          encoding: "utf8",
+          timeout: 5000,
+          windowsHide: true,
+        });
+        if (statusCheck.stdout?.trim()) {
+          console.warn(
+            `[maintenance] local '${branch}' diverged (${ahead}↑ ${behind}↓) but has uncommitted changes — skipping`,
+          );
+          continue;
+        }
+        if (branch === currentBranch) {
+          const rebase = spawnSync(
+            "git",
+            ["rebase", remoteRef, "--quiet"],
+            { cwd: repoRoot, encoding: "utf8", timeout: 60_000, windowsHide: true },
+          );
+          if (rebase.status !== 0) {
+            spawnSync("git", ["rebase", "--abort"], {
+              cwd: repoRoot, timeout: 10_000, windowsHide: true,
+            });
+            console.warn(
+              `[maintenance] rebase of '${branch}' onto ${remoteRef} failed (${ahead}↑ ${behind}↓) — skipping`,
+            );
+            continue;
+          }
+          const push = spawnSync(
+            "git",
+            ["push", "origin", `${branch}:refs/heads/${branch}`, "--quiet"],
+            { cwd: repoRoot, encoding: "utf8", timeout: 30_000, windowsHide: true },
+          );
+          if (push.status === 0) {
+            console.log(
+              `[maintenance] rebased and pushed '${branch}' (was ${ahead}↑ ${behind}↓)`,
+            );
+            synced++;
+          } else {
+            console.warn(
+              `[maintenance] push after rebase of '${branch}' failed: ${(push.stderr || push.stdout || "").toString().trim()}`,
+            );
+          }
+        } else {
+          console.warn(
+            `[maintenance] local '${branch}' diverged (${ahead}↑ ${behind}↓) and not checked out — skipping (rebase requires checkout)`,
+          );
+        }
         continue;
       }