bosun 0.41.0 → 0.41.2

package/server/ui-server.mjs

@@ -50,6 +50,7 @@ import {
   execWithRetry,
   invalidateThread,
 } from "../agent/agent-pool.mjs";
+import { withTaskLifetimeTotals } from "../infra/runtime-accumulator.mjs";
 import { resolveAgentPrompts } from "../agent/agent-prompts.mjs";
 import {
   listActiveWorktrees,
@@ -140,6 +141,12 @@ import {
   addSessionEventListener,
 } from "../infra/session-tracker.mjs";
 import { ensureTestRuntimeSandbox } from "../infra/test-runtime.mjs";
+import {
+  addSessionAccumulationListener,
+  getCompletedSessions,
+  getRuntimeStats,
+  getTaskLifetimeTotals,
+} from "../infra/runtime-accumulator.mjs";
 import {
   collectDiffStats,
   getCompactDiffSummary,
@@ -3462,6 +3469,7 @@ const DEFAULT_AUTO_OPEN_COOLDOWN_MS = 12 * 60 * 60 * 1000; // 12h
 const DEFAULT_SESSION_TOKEN_TTL_MS = 30 * 24 * 60 * 60 * 1000; // 30 days
 const wsClients = new Set();
 let sessionListenerAttached = false;
+let sessionAccumulatorListenerAttached = false;
 /** @type {ReturnType<typeof setInterval>|null} */
 let wsHeartbeatTimer = null;
 const WORKFLOW_WS_BATCH_MS = 80;
@@ -7128,6 +7136,20 @@ async function reconcileTaskAfterDispatchAttempt({
   return persistTaskStatusForExecution(adapter, taskId, targetStatus, source);
 }
 
+function enrichTaskLifetimeTotals(task) {
+  if (!task || typeof task !== "object") return task;
+  const taskId = String(task?.id || task?.taskId || "").trim();
+  const lifetimeTotals = taskId ? getTaskLifetimeTotals(taskId) : null;
+  return {
+    ...task,
+    lifetimeTotals,
+    meta: {
+      ...(task.meta || {}),
+      lifetimeTotals,
+    },
+  };
+}
+
 function buildTaskRuntimeSnapshot(task) {
   const runtimeExecutor = uiDeps.getInternalExecutor?.() || null;
   const status = runtimeExecutor?.getStatus?.() || {};
@@ -7146,6 +7168,7 @@ function buildTaskRuntimeSnapshot(task) {
       taskId,
       taskStatus: task?.status || null,
       statusLabel: "Live execution",
+      lifetimeTotals: task?.lifetimeTotals || task?.meta?.lifetimeTotals || null,
       slot: {
         taskId,
         branch: slot?.branch || slot?.branchName || null,
@@ -7169,6 +7192,7 @@ function buildTaskRuntimeSnapshot(task) {
       taskStatus: task?.status || null,
       statusLabel: "Queued for execution",
       reason: "no_free_slots",
+      lifetimeTotals: task?.lifetimeTotals || task?.meta?.lifetimeTotals || null,
     };
   }
   if (normalizedStatus === "inprogress") {
@@ -7179,6 +7203,7 @@ function buildTaskRuntimeSnapshot(task) {
       taskStatus: task?.status || null,
       statusLabel: "No live execution detected",
       reason: "no_active_executor_slot",
+      lifetimeTotals: task?.lifetimeTotals || task?.meta?.lifetimeTotals || null,
     };
   }
   if (normalizedStatus === "inreview") {
@@ -7188,6 +7213,7 @@ function buildTaskRuntimeSnapshot(task) {
       taskId,
       taskStatus: task?.status || null,
       statusLabel: "Awaiting review",
+      lifetimeTotals: task?.lifetimeTotals || task?.meta?.lifetimeTotals || null,
     };
   }
   return {
@@ -7196,17 +7222,19 @@ function buildTaskRuntimeSnapshot(task) {
     taskId,
     taskStatus: task?.status || null,
     statusLabel: "No active execution",
+    lifetimeTotals: task?.lifetimeTotals || task?.meta?.lifetimeTotals || null,
   };
 }
 
 function withTaskRuntimeSnapshot(task) {
   if (!task || typeof task !== "object") return task;
-  const runtimeSnapshot = buildTaskRuntimeSnapshot(task);
+  const withLifetimeTotals = enrichTaskLifetimeTotals(task);
+  const runtimeSnapshot = buildTaskRuntimeSnapshot(withLifetimeTotals);
   return {
-    ...task,
+    ...withLifetimeTotals,
     runtimeSnapshot,
     meta: {
-      ...(task.meta || {}),
+      ...(withLifetimeTotals.meta || {}),
       runtimeSnapshot,
     },
   };
@@ -8040,10 +8068,12 @@ async function collectUiStats() {
     } catch { /* best effort */ }
   }
 
+  const runtimeStats = getRuntimeStats();
+
   return {
     uptimeMs: process.uptime() * 1000,
-    runtimeMs: globalThis.__bosun_runtimeMs || 0,
-    totalCostUsd: globalThis.__bosun_totalCostUsd || 0,
+    runtimeMs: runtimeStats.runtimeMs || 0,
+    totalCostUsd: runtimeStats.totalCostUsd || 0,
     totalSessions: sessionStats.total,
     activeSessions: sessionStats.active,
     completedSessions: sessionStats.completed,
@@ -8055,7 +8085,24 @@ async function collectUiStats() {
     queuedTasks: taskStats.queued,
     activeSlots: orchestratorStatus?.active_slots || "0/0",
     executorMode: orchestratorStatus?.executor_mode || "unknown",
-    retryQueue: globalThis.__bosun_setRetryQueueData ? _retryQueue : { count: 0, items: [] },
+    retryQueue: (() => {
+      const bus = _resolveEventBus();
+      if (bus && typeof bus.getRetryQueue === "function") {
+        try {
+          const snapshot = bus.getRetryQueue();
+          if (snapshot && typeof snapshot === "object") return snapshot;
+        } catch {
+          /* best effort */
+        }
+      }
+      return globalThis.__bosun_setRetryQueueData
+        ? _retryQueue
+        : {
+            count: 0,
+            items: [],
+            stats: { totalRetriesToday: 0, peakRetryDepth: 0, exhaustedTaskIds: [] },
+          };
+    })(),
     workflows: {
       active: globalThis.__bosun_activeWorkflows || [],
       total: globalThis.__bosun_totalWorkflows || 0,
@@ -8111,20 +8158,30 @@ async function listDirFilesWithMtime(dir, predicate = () => true) {
   return entries.filter(Boolean);
 }
 
-async function resolvePreferredSystemLogPath() {
+const SYSTEM_LOG_PRIORITY = Object.freeze({
+  "monitor.log": 300,
+  "monitor-error.log": 250,
+  "daemon.log": 200,
+});
+
+async function listPreferredSystemLogEntries(limit = 4) {
   const rootLogEntries = await listDirFilesWithMtime(
     logsDir,
     (name) => name.endsWith(".log"),
   );
-  const nonDaemonEntries = rootLogEntries.filter((entry) => entry.name !== "daemon.log");
-
-  const preferredEntries = [...nonDaemonEntries].sort(
-    (a, b) => b.mtimeMs - a.mtimeMs,
-  );
-  if (preferredEntries.length > 0) return preferredEntries[0].path;
+  return rootLogEntries
+    .sort((a, b) => {
+      const priorityDelta =
+        (SYSTEM_LOG_PRIORITY[b.name] || 0) - (SYSTEM_LOG_PRIORITY[a.name] || 0);
+      if (priorityDelta !== 0) return priorityDelta;
+      return b.mtimeMs - a.mtimeMs;
+    })
+    .slice(0, Math.max(1, limit));
+}
 
-  const daemonEntry = rootLogEntries.find((entry) => entry.name === "daemon.log");
-  return daemonEntry ? daemonEntry.path : null;
+async function resolvePreferredSystemLogPath() {
+  const preferredEntries = await listPreferredSystemLogEntries(1);
+  return preferredEntries[0]?.path || null;
 }
 
 /**
@@ -9302,10 +9359,70 @@ function withTaskMetadataTopLevel(task) {
 }
 
 async function getLatestLogTail(lineCount) {
-  const logPath = await resolvePreferredSystemLogPath();
-  if (!logPath) return { file: null, lines: [] };
-  const tail = await tailFile(logPath, lineCount);
-  return { file: basename(logPath), lines: tail.lines || [] };
+  return getMergedSystemLogTail(lineCount);
+}
+
+function parseSystemLogTimestamp(line) {
+  const match = String(line || "").match(/^\s*(\d{4}-\d{2}-\d{2}T[^\s]+)/);
+  if (!match?.[1]) return Number.NaN;
+  const parsed = Date.parse(match[1]);
+  return Number.isFinite(parsed) ? parsed : Number.NaN;
+}
+
+async function getMergedSystemLogTail(
+  lineCount,
+  {
+    fileLimit = 4,
+    maxBytesPerFile = 350_000,
+  } = {},
+) {
+  const entries = await listPreferredSystemLogEntries(fileLimit);
+  if (!entries.length) {
+    return { file: null, files: [], lines: [], truncated: false };
+  }
+
+  const perFileLineBudget = Math.max(lineCount * 2, 160);
+  const tails = await Promise.all(
+    entries.map((entry) => tailFile(entry.path, perFileLineBudget, maxBytesPerFile).catch(() => null)),
+  );
+
+  const merged = [];
+  let truncated = false;
+  tails.forEach((tail, sourceIndex) => {
+    if (!tail) return;
+    truncated = truncated || tail.truncated === true;
+    const lines = Array.isArray(tail.lines) ? tail.lines : [];
+    lines.forEach((line, lineIndex) => {
+      merged.push({
+        line,
+        timestamp: parseSystemLogTimestamp(line),
+        sourceIndex,
+        lineIndex,
+      });
+    });
+  });
+
+  merged.sort((a, b) => {
+    const aHasTs = Number.isFinite(a.timestamp);
+    const bHasTs = Number.isFinite(b.timestamp);
+    if (aHasTs && bHasTs && a.timestamp !== b.timestamp) {
+      return a.timestamp - b.timestamp;
+    }
+    if (aHasTs !== bHasTs) {
+      return aHasTs ? -1 : 1;
+    }
+    if (a.sourceIndex !== b.sourceIndex) {
+      return a.sourceIndex - b.sourceIndex;
+    }
+    return a.lineIndex - b.lineIndex;
+  });
+
+  return {
+    file: entries[0]?.name || null,
+    files: entries.map((entry) => entry.name),
+    lines: merged.slice(-lineCount).map((entry) => entry.line),
+    truncated,
+  };
 }
 
 async function tailFile(filePath, lineCount, maxBytes = 1_000_000) {
@@ -13494,7 +13611,24 @@ async function handleApi(req, res, url) {
       const logDir = resolveAgentWorkLogDir();
       const metricsPath = resolve(logDir, "agent-metrics.jsonl");
       const metrics = await readJsonlTail(metricsPath, 3000);
-      const summary = summarizeTelemetry(metrics, days);
+      const summary = summarizeTelemetry(metrics, days) || {};
+      const runtimeStats = getRuntimeStats();
+      const completedSessions = getCompletedSessions(10_000);
+      const lifetimeTotals = completedSessions.reduce(
+        (acc, session) => {
+          acc.attemptsCount += 1;
+          acc.tokenCount += Number(session?.tokenCount || 0);
+          acc.inputTokens += Number(session?.inputTokens || 0);
+          acc.outputTokens += Number(session?.outputTokens || 0);
+          return acc;
+        },
+        { attemptsCount: 0, tokenCount: 0, inputTokens: 0, outputTokens: 0 },
+      );
+      summary.runtimeMs = Number(runtimeStats?.runtimeMs || 0);
+      summary.lifetimeTotals = {
+        ...lifetimeTotals,
+        durationMs: summary.runtimeMs,
+      };
       jsonResponse(res, 200, { ok: true, data: summary });
     } catch (err) {
       jsonResponse(res, 500, { ok: false, error: err.message });
@@ -14586,12 +14720,25 @@ async function handleApi(req, res, url) {
       }
       const wfMod = wfCtx.wfMod;
       const types = wfMod.listNodeTypes();
-      jsonResponse(res, 200, { ok: true, nodeTypes: types.map(nt => ({
-        type: nt.type,
-        category: nt.type.split(".")[0],
-        description: nt.description || "",
-        schema: nt.schema || {},
-      })) });
+      jsonResponse(res, 200, { ok: true, nodeTypes: types.map((nt) => {
+        const rawPorts = nt?.ports && typeof nt.ports === "object" ? nt.ports : {};
+        const ports = {
+          inputs: Array.isArray(rawPorts.inputs) ? rawPorts.inputs : [],
+          outputs: Array.isArray(rawPorts.outputs) ? rawPorts.outputs : [],
+        };
+        return {
+          type: nt.type,
+          category: nt.type.split(".")[0],
+          description: nt.description || "",
+          schema: nt.schema || {},
+          source: nt.source || "builtin",
+          badge: nt.badge || null,
+          isCustom: nt.isCustom === true,
+          filePath: nt.filePath || null,
+          ports,
+          ui: nt?.ui && typeof nt.ui === "object" ? nt.ui : {},
+        };
+      }) });
     } catch (err) {
       jsonResponse(res, 500, { ok: false, error: err.message });
     }
@@ -15469,6 +15616,14 @@ async function handleApi(req, res, url) {
           `[telegram-ui] failed to retry task ${taskId}: ${error.message}`,
         );
       });
+      const bus = _resolveEventBus();
+      if (bus && typeof bus.clearRetryQueueTask === "function") {
+        try {
+          bus.clearRetryQueueTask(taskId, "manual-retry-now");
+        } catch {
+          /* best effort */
+        }
+      }
       jsonResponse(res, 200, { ok: true, taskId });
       broadcastUiEvent(
         ["tasks", "overview", "executor", "agents"],
@@ -15484,14 +15639,45 @@ async function handleApi(req, res, url) {
   // ── GET /api/retry-queue ───────────────────────────────────────────
   if (path === "/api/retry-queue" && req.method === "GET") {
     try {
-      const retryQueue = globalThis.__bosun_setRetryQueueData ? _retryQueue : { count: 0, items: [] };
+      const bus = _resolveEventBus();
+      let retryQueue = null;
+      if (bus && typeof bus.getRetryQueue === "function") {
+        try {
+          const snapshot = bus.getRetryQueue();
+          if (snapshot && typeof snapshot === "object") {
+            retryQueue = snapshot;
+          }
+        } catch {
+          /* best effort */
+        }
+      }
+      if (!retryQueue) {
+        retryQueue = globalThis.__bosun_setRetryQueueData
+          ? _retryQueue
+          : {
+              count: 0,
+              items: [],
+              stats: { totalRetriesToday: 0, peakRetryDepth: 0, exhaustedTaskIds: [] },
+            };
+      }
       jsonResponse(res, 200, {
         ok: true,
         count: retryQueue.count || 0,
         items: retryQueue.items || [],
+        stats: retryQueue.stats || {
+          totalRetriesToday: 0,
+          peakRetryDepth: 0,
+          exhaustedTaskIds: [],
+        },
       });
     } catch (err) {
-      jsonResponse(res, 500, { ok: false, error: err.message, count: 0, items: [] });
+      jsonResponse(res, 500, {
+        ok: false,
+        error: err.message,
+        count: 0,
+        items: [],
+        stats: { totalRetriesToday: 0, peakRetryDepth: 0, exhaustedTaskIds: [] },
+      });
     }
     return;
   }
@@ -18029,6 +18215,17 @@ export async function startTelegramUiServer(options = {}) {
         broadcastSessionMessage(payload);
       });
     }
+    if (!sessionAccumulatorListenerAttached) {
+      sessionAccumulatorListenerAttached = true;
+      addSessionAccumulationListener((payload) => {
+        broadcastUiEvent(["tasks", "overview", "telemetry", "sessions"], "invalidate", {
+          reason: "session-accumulated",
+          taskId: payload?.taskId || null,
+          totals: payload?.totals || null,
+          type: payload?.type || "session-accumulated",
+        });
+      });
+    }
 
     // Periodic stats broadcast for TUI
     let statsBroadcastInterval = null;
@@ -18050,7 +18247,29 @@ export async function startTelegramUiServer(options = {}) {
     // Retry queue tracking
     let _retryQueue = { count: 0, items: [] };
     function setRetryQueueData(data) {
-      _retryQueue = data || { count: 0, items: [] };
+      const normalized = data && typeof data === "object" ? data : {};
+      _retryQueue = {
+        count: Number(normalized.count || 0),
+        items: Array.isArray(normalized.items) ? normalized.items : [],
+        stats: normalized.stats && typeof normalized.stats === "object"
+          ? {
+              totalRetriesToday: Number(normalized.stats.totalRetriesToday || 0),
+              peakRetryDepth: Number(normalized.stats.peakRetryDepth || 0),
+              exhaustedTaskIds: Array.isArray(normalized.stats.exhaustedTaskIds)
+                ? normalized.stats.exhaustedTaskIds
+                : [],
+            }
+          : {
+              totalRetriesToday: 0,
+              peakRetryDepth: 0,
+            exhaustedTaskIds: [],
+          },
+      };
+      broadcastUiEvent(["retry-queue", "overview", "telemetry", "tasks"], "retry-queue-updated", _retryQueue);
+      broadcastUiEvent(["overview", "telemetry", "retry-queue"], "invalidate", {
+        reason: "retry-queue-updated",
+        count: _retryQueue.count,
+      });
     }
     globalThis.__bosun_setRetryQueueData = setRetryQueueData;
 

package/setup.mjs

@@ -60,6 +60,7 @@ import {
   resolveWorkflowTemplateIds,
   normalizeTemplateOverridesById,
 } from "./workflow/workflow-templates.mjs";
+import { discoverTelegramChats } from "./telegram/get-telegram-chat-id.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -89,6 +90,14 @@ function getVersion() {
   }
 }
 
+function formatTelegramChatChoice(chat) {
+  const parts = [String(chat.id)];
+  if (chat.type) parts.push(chat.type);
+  if (chat.username) parts.push(`@${chat.username}`);
+  if (chat.title) parts.push(chat.title);
+  return parts.join(" · ");
+}
+
 function hasSetupMarkers(dir) {
   const markers = [
     ".env",
@@ -3883,32 +3892,26 @@ async function main() {
               // Try to fetch chat ID from Telegram API
               info("Fetching your chat ID from Telegram...");
               try {
-                const response = await fetch(
-                  `https://api.telegram.org/bot${env.TELEGRAM_BOT_TOKEN}/getUpdates`,
-                );
-                const data = await response.json();
-
-                if (data.ok && data.result && data.result.length > 0) {
-                  // Find the most recent message
-                  const latestMessage = data.result[data.result.length - 1];
-                  const chatId = latestMessage?.message?.chat?.id;
-
-                  if (chatId) {
-                    env.TELEGRAM_CHAT_ID = String(chatId);
-                    info(`✓ Found your chat ID: ${chatId}`);
-                    console.log();
-                  } else {
-                    warn(
-                      "Couldn't find a chat ID. Make sure you sent a message to your bot.",
-                    );
-                    env.TELEGRAM_CHAT_ID = await prompt.ask(
-                      "Enter chat ID manually",
-                      "",
-                    );
-                  }
+                const discovery = await discoverTelegramChats(env.TELEGRAM_BOT_TOKEN);
+
+                if (discovery.chats.length === 1) {
+                  env.TELEGRAM_CHAT_ID = String(discovery.chats[0].id);
+                  info(`✓ Found your chat ID: ${env.TELEGRAM_CHAT_ID}`);
+                  console.log();
+                } else if (discovery.chats.length > 1) {
+                  const selectedIdx = await prompt.choose(
+                    "Select the chat Bosun should use:",
+                    discovery.chats.map(formatTelegramChatChoice),
+                    0,
+                  );
+                  const selectedChat = discovery.chats[selectedIdx];
+                  env.TELEGRAM_CHAT_ID = String(selectedChat.id);
+                  info(`✓ Selected chat ID: ${env.TELEGRAM_CHAT_ID}`);
+                  console.log();
                 } else {
                   warn(
-                    "No messages found. Make sure you sent a message to your bot first.",
+                    discovery.message ||
+                    "Couldn't find a chat ID. Make sure you sent a message to your bot.",
                   );
                   console.log(
                     chalk.dim(

package/shell/codex-shell.mjs

@@ -31,10 +31,12 @@ const __dirname = resolve(fileURLToPath(new URL(".", import.meta.url)));
 // ── Configuration ────────────────────────────────────────────────────────────
 
 const DEFAULT_TIMEOUT_MS = 60 * 60 * 1000; // 60 min for agentic tasks (matches Azure stream timeout)
+const MAX_TIMER_DELAY_MS = 2_147_483_647; // Node.js timer clamp (2^31 - 1)
 // MAX_STREAM_RETRIES, isTransientStreamError, streamRetryDelay ← imported from ./stream-resilience.mjs
 const STATE_FILE = resolve(__dirname, "..", "logs", "codex-shell-state.json");
 const SESSIONS_DIR = resolve(__dirname, "..", "logs", "sessions");
 const MAX_PERSISTENT_TURNS = 50;
+const timeoutNormalizationWarningKey = new Set();
 
 // ── Payload safety ────────────────────────────────────────────────────────────
 // The Codex API rejects JSON bodies with malformed or oversized strings.
@@ -54,6 +56,28 @@ function parseBoundedNumber(value, fallback, min, max) {
   return Math.min(Math.max(Math.trunc(num), min), max);
 }
 
+function parsePositiveTimeoutMs(value, fallback = DEFAULT_TIMEOUT_MS) {
+  const fallbackValue = Number(fallback);
+  if (!Number.isFinite(fallbackValue) || fallbackValue <= 0) {
+    throw new Error("parsePositiveTimeoutMs requires a positive finite fallback");
+  }
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) return fallbackValue;
+  return parsed;
+}
+
+function normalizeTimeoutMs(value, { fallback = DEFAULT_TIMEOUT_MS, label = "timeoutMs" } = {}) {
+  const parsed = parsePositiveTimeoutMs(value, fallback);
+  const normalized = Math.min(parsed, MAX_TIMER_DELAY_MS);
+  if (normalized !== parsed && !timeoutNormalizationWarningKey.has(label)) {
+    timeoutNormalizationWarningKey.add(label);
+    console.warn(
+      `[codex-shell] ${label} ${parsed}ms exceeds Node.js timer max; clamped to ${MAX_TIMER_DELAY_MS}ms`,
+    );
+  }
+  return normalized;
+}
+
 function getInternalExecutorStreamConfig() {
   try {
     const cfg = loadConfig();
@@ -692,6 +716,10 @@ export async function execCodexPrompt(userMessage, options = {}) {
     mode = null,
     cwd = null,
   } = options;
+  const normalizedTimeoutMs = normalizeTimeoutMs(timeoutMs, {
+    fallback: DEFAULT_TIMEOUT_MS,
+    label: "execCodexPrompt.timeoutMs",
+  });
 
   agentSdk = resolveAgentSdkConfig({ reload: true });
   if (agentSdk.primary !== "codex") {
@@ -714,7 +742,7 @@ export async function execCodexPrompt(userMessage, options = {}) {
   activeTurn = true;
 
   try {
-    const streamSafety = resolveCodexStreamSafety(timeoutMs);
+    const streamSafety = resolveCodexStreamSafety(normalizedTimeoutMs);
     const requestedWorkingDirectory = normalizeWorkingDirectory(cwd);
 
     if (!persistent) {
@@ -811,7 +839,10 @@ export async function execCodexPrompt(userMessage, options = {}) {
       // immediately fail.  The total wall-clock budget is still bounded by the
       // outer timeoutMs passed in.
       const controller = abortController || new AbortController();
-      const timer = setTimeout(() => controller.abort("timeout"), timeoutMs);
+      const timer = setTimeout(
+        () => controller.abort("timeout"),
+        normalizedTimeoutMs,
+      );
 
       try {
         // Use runStreamed for real-time event streaming
@@ -939,7 +970,7 @@ export async function execCodexPrompt(userMessage, options = {}) {
             const msg =
               reason === "user_stop"
                 ? ":close: Agent stopped by user."
-                : `:clock: Agent timed out after ${timeoutMs / 1000}s`;
+                : `:clock: Agent timed out after ${normalizedTimeoutMs / 1000}s`;
             return { finalResponse: msg, items: [], usage: null };
           }
         }