bosun 0.34.2 → 0.34.3

package/cli.mjs

@@ -81,6 +81,7 @@ function showHelp() {
     --no-auto-update            Disable background auto-update polling
     --daemon, -d                Run as a background daemon (detached, with PID file)
     --stop-daemon               Stop a running daemon process
+    --terminate                 Hard-stop all bosun processes (daemon + monitor + companions)
     --daemon-status             Check if daemon is running
 
   ORCHESTRATOR
@@ -674,6 +675,122 @@ function daemonStatus() {
   process.exit(0);
 }
 
+function findAllBosunProcessPids() {
+  const patterns = [
+    "cli.mjs",
+    "monitor.mjs",
+    "telegram-bot.mjs",
+    "telegram-sentinel.mjs",
+    "ui-server.mjs",
+  ];
+  const joined = patterns.join("|");
+  if (process.platform === "win32") {
+    try {
+      const out = execFileSync(
+        "powershell",
+        [
+          "-NoProfile",
+          "-Command",
+          `Get-CimInstance Win32_Process | Where-Object { $_.Name -match '^node(\\.exe)?$' -and $_.CommandLine -match '${joined.replace(/\|/g, "|")}' } | Select-Object -ExpandProperty ProcessId`,
+        ],
+        { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"], timeout: 4000 },
+      ).trim();
+      if (!out) return [];
+      return out
+        .split(/\r?\n/)
+        .map((s) => Number.parseInt(String(s).trim(), 10))
+        .filter((pid) => Number.isFinite(pid) && pid > 0 && pid !== process.pid);
+    } catch {
+      return [];
+    }
+  }
+  try {
+    const out = execFileSync("pgrep", ["-f", joined], {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 4000,
+    }).trim();
+    if (!out) return [];
+    return out
+      .split(/\r?\n/)
+      .map((s) => Number.parseInt(String(s).trim(), 10))
+      .filter((pid) => Number.isFinite(pid) && pid > 0 && pid !== process.pid);
+  } catch {
+    return [];
+  }
+}
+
+function removeKnownPidFiles() {
+  const pidFiles = [
+    DAEMON_PID_FILE,
+    PID_FILE,
+    SENTINEL_PID_FILE,
+    SENTINEL_PID_FILE_LEGACY,
+    resolve(__dirname, "..", ".cache", "bosun.pid"),
+    resolve(process.cwd(), ".cache", "bosun.pid"),
+  ];
+  for (const pidFile of pidFiles) {
+    try {
+      if (existsSync(pidFile)) unlinkSync(pidFile);
+    } catch {
+      /* best effort */
+    }
+  }
+}
+
+function terminateBosun() {
+  const tracked = [
+    getDaemonPid(),
+    readAlivePid(PID_FILE),
+    readAlivePid(SENTINEL_PID_FILE),
+    readAlivePid(SENTINEL_PID_FILE_LEGACY),
+  ].filter((pid) => Number.isFinite(pid) && pid > 0);
+  const ghosts = findGhostDaemonPids();
+  const scanned = findAllBosunProcessPids();
+  const allPids = Array.from(new Set([...tracked, ...ghosts, ...scanned])).filter(
+    (pid) => pid !== process.pid,
+  );
+  if (allPids.length === 0) {
+    removeKnownPidFiles();
+    console.log("  No running bosun processes found.");
+    process.exit(0);
+    return;
+  }
+
+  console.log(`  Terminating ${allPids.length} bosun process(es): ${allPids.join(", ")}`);
+  for (const pid of allPids) {
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {
+      /* already dead */
+    }
+  }
+
+  const deadline = Date.now() + 5000;
+  let alive = allPids.filter((pid) => isProcessAlive(pid));
+  while (alive.length > 0 && Date.now() < deadline) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 200);
+    alive = alive.filter((pid) => isProcessAlive(pid));
+  }
+
+  for (const pid of alive) {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+      /* already dead */
+    }
+  }
+  removeKnownPidFiles();
+  const killed = allPids.length - alive.length;
+  console.log(`  ✓ Terminated ${killed}/${allPids.length} process(es).`);
+  if (alive.length > 0) {
+    console.log(`  ⚠️  Still alive: ${alive.join(", ")}`);
+    process.exit(1);
+    return;
+  }
+  process.exit(0);
+}
+
 async function main() {
   // Apply legacy CODEX_MONITOR_* → BOSUN_* env aliases before any config ops
   applyAllCompatibility();
@@ -793,6 +910,10 @@ async function main() {
     stopDaemon();
     return;
   }
+  if (args.includes("--terminate")) {
+    terminateBosun();
+    return;
+  }
   if (args.includes("--daemon-status")) {
     daemonStatus();
     return;
@@ -1500,4 +1621,3 @@ main().catch(async (err) => {
   await sendCrashNotification(1, null).catch(() => {});
   process.exit(1);
 });
-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bosun",
-  "version": "0.34.2",
+  "version": "0.34.3",
   "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",

package/telegram-bot.mjs

@@ -10439,6 +10439,11 @@ export async function startTelegramBot() {
   if (miniAppEnabled || miniAppPort > 0) {
     try {
       await startTelegramUiServer({
+        // Background monitor/bot runtime should not keep opening browser tabs.
+        // Set BOSUN_UI_AUTO_OPEN_BROWSER=1 to opt-in.
+        skipAutoOpen: !["1", "true", "yes", "on"].includes(
+          String(process.env.BOSUN_UI_AUTO_OPEN_BROWSER || "").toLowerCase(),
+        ),
         dependencies: {
           execPrimaryPrompt,
           getInternalExecutor: _getInternalExecutor,

package/ui-server.mjs

@@ -6136,7 +6136,7 @@ async function handleApi(req, res, url) {
           jsonResponse(res, 404, { ok: false, error: "Task not found." });
           return;
         }
-        executor.executeTask(task).catch((error) => {
+        executor.executeTask(task, { force: true }).catch((error) => {
           console.warn(
             `[telegram-ui] dispatch failed for ${taskId}: ${error.message}`,
           );

package/workflow-nodes.mjs

@@ -26,6 +26,76 @@ import { randomUUID } from "node:crypto";
 const TAG = "[workflow-nodes]";
 const PORTABLE_WORKTREE_COUNT_COMMAND = "node -e \"const cp=require('node:child_process');const wt=cp.execSync('git worktree list --porcelain',{encoding:'utf8'});const count=(wt.match(/^worktree /gm)||[]).length;process.stdout.write(String(count)+'\\\\n');\"";
 const PORTABLE_PRUNE_AND_COUNT_WORKTREES_COMMAND = "node -e \"const cp=require('node:child_process');cp.execSync('git worktree prune',{stdio:'ignore'});const wt=cp.execSync('git worktree list --porcelain',{encoding:'utf8'});const count=(wt.match(/^worktree /gm)||[]).length;process.stdout.write(String(count)+'\\\\n');\"";
+const WORKFLOW_AGENT_HEARTBEAT_MS = (() => {
+  const raw = Number(process.env.WORKFLOW_AGENT_HEARTBEAT_MS || 30000);
+  if (!Number.isFinite(raw)) return 30000;
+  return Math.max(5000, Math.min(120000, Math.trunc(raw)));
+})();
+
+function trimLogText(value, max = 180) {
+  const text = String(value || "").replace(/\s+/g, " ").trim();
+  if (!text) return "";
+  return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}
+
+function summarizeAgentStreamEvent(event) {
+  const type = String(event?.type || "").trim();
+  if (!type) return "";
+
+  if (
+    type === "response.output_text.delta" ||
+    type === "response.output_text.done" ||
+    type === "item.updated"
+  ) {
+    return "";
+  }
+
+  if (type === "tool_call") {
+    return `Tool call: ${event?.tool_name || event?.data?.tool_name || "unknown"}`;
+  }
+
+  if (type === "tool_result") {
+    const name = event?.tool_name || event?.data?.tool_name || "unknown";
+    return `Tool result: ${name}`;
+  }
+
+  if (type === "error") {
+    return `Agent error: ${trimLogText(event?.error || event?.message || "unknown error", 220)}`;
+  }
+
+  const messageText = trimLogText(
+    event?.message?.content ||
+      event?.message?.text ||
+      event?.content ||
+      event?.text ||
+      event?.data?.content ||
+      event?.data?.text ||
+      "",
+    220,
+  );
+
+  if (messageText) {
+    if (
+      type === "agent_message" ||
+      type === "assistant_message" ||
+      type === "message" ||
+      type === "item.completed"
+    ) {
+      return `Agent: ${messageText}`;
+    }
+    return `${type}: ${messageText}`;
+  }
+
+  if (
+    type === "turn.complete" ||
+    type === "session.completed" ||
+    type === "response.completed"
+  ) {
+    return `Agent event: ${type}`;
+  }
+
+  return "";
+}
 
 function normalizeLegacyWorkflowCommand(command) {
   let normalized = String(command || "");
@@ -460,8 +530,45 @@ registerNodeType("action.run_agent", {
     // Use the engine's service injection to call agent pool
     const agentPool = engine.services?.agentPool;
     if (agentPool?.launchEphemeralThread) {
-      const result = await agentPool.launchEphemeralThread(finalPrompt, cwd, timeoutMs);
-      ctx.log(node.id, `Agent completed: success=${result.success}`);
+      let streamEventCount = 0;
+      let lastStreamLog = "";
+      const startedAt = Date.now();
+      const launchExtra = {};
+      if (sdk && sdk !== "auto") launchExtra.sdk = sdk;
+
+      launchExtra.onEvent = (event) => {
+        try {
+          const line = summarizeAgentStreamEvent(event);
+          if (!line || line === lastStreamLog) return;
+          lastStreamLog = line;
+          streamEventCount += 1;
+          ctx.log(node.id, line);
+        } catch {
+          // Stream callbacks must never crash workflow execution.
+        }
+      };
+
+      const heartbeat = setInterval(() => {
+        const elapsedSec = Math.max(1, Math.round((Date.now() - startedAt) / 1000));
+        ctx.log(node.id, `Agent still running (${elapsedSec}s elapsed)`);
+      }, WORKFLOW_AGENT_HEARTBEAT_MS);
+
+      let result;
+      try {
+        result = await agentPool.launchEphemeralThread(
+          finalPrompt,
+          cwd,
+          timeoutMs,
+          launchExtra,
+        );
+      } finally {
+        clearInterval(heartbeat);
+      }
+
+      ctx.log(
+        node.id,
+        `Agent completed: success=${result.success} streamEvents=${streamEventCount}`,
+      );
 
       // Propagate session/thread IDs for downstream chaining
       const threadId = result.threadId || result.sessionId || null;