bosun 0.41.0 → 0.41.2

package/shell/copilot-shell.mjs

@@ -38,9 +38,11 @@ async function getMcpRegistry() {
 // ── Configuration ────────────────────────────────────────────────────────────
 
 const DEFAULT_TIMEOUT_MS = 60 * 60 * 1000; // 60 min for agentic tasks
+const MAX_TIMER_DELAY_MS = 2_147_483_647; // Node.js timer clamp (2^31 - 1)
 const STATE_FILE = resolve(__dirname, "..", "logs", "copilot-shell-state.json");
 const SESSION_LOG_DIR = resolve(__dirname, "..", "logs", "copilot-sessions");
 const REPO_ROOT = resolveRepoRoot();
+const timeoutNormalizationWarningKey = new Set();
 
 // Valid reasoning effort levels for models that support it
 const VALID_REASONING_EFFORTS = ["low", "medium", "high", "xhigh"];
@@ -200,6 +202,28 @@ function safeStringify(value, maxLen = 8000) {
   return text;
 }
 
+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(
+      `[copilot-shell] ${label} ${parsed}ms exceeds Node.js timer max; clamped to ${MAX_TIMER_DELAY_MS}ms`,
+    );
+  }
+  return normalized;
+}
+
 function initSessionLog(sessionId, prompt, timeoutMs) {
   if (!sessionId) return null;
   try {
@@ -588,8 +612,10 @@ async function ensureClientStarted() {
     );
   }
 
-  const START_TIMEOUT_MS =
-    Number(process.env.COPILOT_START_TIMEOUT_MS) || 20_000;
+  const START_TIMEOUT_MS = normalizeTimeoutMs(process.env.COPILOT_START_TIMEOUT_MS, {
+    fallback: 20_000,
+    label: "COPILOT_START_TIMEOUT_MS",
+  });
 
   await withSanitizedOpenAiEnv(async () => {
     copilotClient = new Cls(clientOptions);
@@ -859,6 +885,10 @@ export async function execCopilotPrompt(userMessage, options = {}) {
     persistent = false,
     mode = null,
   } = options;
+  const normalizedTimeoutMs = normalizeTimeoutMs(timeoutMs, {
+    fallback: DEFAULT_TIMEOUT_MS,
+    label: "execCopilotPrompt.timeoutMs",
+  });
 
   if (activeTurn && !options._holdActiveTurn) {
     return {
@@ -880,7 +910,7 @@ export async function execCopilotPrompt(userMessage, options = {}) {
 
   let unsubscribe = null;
   const session = await getSession();
-  const logPath = initSessionLog(activeSessionId, userMessage, timeoutMs);
+  const logPath = initSessionLog(activeSessionId, userMessage, normalizedTimeoutMs);
   const items = [];
   let finalResponse = "";
   let responseFromMessage = false;
@@ -923,7 +953,7 @@ export async function execCopilotPrompt(userMessage, options = {}) {
     }
 
     const controller = abortController || new AbortController();
-    const timer = setTimeout(() => controller.abort("timeout"), timeoutMs);
+    const timer = setTimeout(() => controller.abort("timeout"), normalizedTimeoutMs);
 
     const onAbort = () => {
       const reason = controller.signal.reason || "user_stop";
@@ -963,7 +993,7 @@ export async function execCopilotPrompt(userMessage, options = {}) {
 
     // Pass timeout parameter to sendAndWait to override 60s SDK default
     const sendPromise = session.sendAndWait
-      ? sendFn.call(session, { prompt }, timeoutMs)
+      ? sendFn.call(session, { prompt }, normalizedTimeoutMs)
       : sendFn.call(session, { prompt });
 
     // If send() returns before idle, wait for session.idle if available
@@ -978,9 +1008,21 @@ export async function execCopilotPrompt(userMessage, options = {}) {
         };
         const off = session.on ? session.on(idleHandler) : null;
         Promise.resolve(sendPromise).catch(reject);
-        setTimeout(resolve, timeoutMs + 1000);
+        setTimeout(
+          resolve,
+          normalizeTimeoutMs(normalizedTimeoutMs + 1000, {
+            fallback: DEFAULT_TIMEOUT_MS,
+            label: "execCopilotPrompt.idleWaitResolveTimeoutMs",
+          }),
+        );
         if (typeof off === "function") {
-          setTimeout(() => off(), timeoutMs + 2000);
+          setTimeout(
+            () => off(),
+            normalizeTimeoutMs(normalizedTimeoutMs + 2000, {
+              fallback: DEFAULT_TIMEOUT_MS,
+              label: "execCopilotPrompt.idleWaitCleanupTimeoutMs",
+            }),
+          );
         }
       });
     } else {
@@ -1008,7 +1050,7 @@ export async function execCopilotPrompt(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 };
     }
     // ── Transient stream retry ──────────────────────────────────────────────────

package/task/msg-hub.mjs

@@ -0,0 +1,193 @@
+/**
+ * @module task/msg-hub
+ * @description Lightweight pub-sub hub for active agent sessions.
+ */
+
+import { EventEmitter } from "node:events";
+import { randomUUID } from "node:crypto";
+
+const SAFE_KEYS = new Set([
+  "taskId",
+  "title",
+  "summary",
+  "branch",
+  "baseBranch",
+  "repoSlug",
+  "workspace",
+  "repository",
+  "paths",
+  "files",
+  "status",
+  "runId",
+  "stage",
+]);
+
+function normalizeParticipant(participant, index = 0) {
+  if (typeof participant === "string") {
+    return { id: participant, name: participant };
+  }
+  if (participant && typeof participant === "object") {
+    const id = String(participant.id || participant.name || `participant-${index + 1}`);
+    return {
+      ...participant,
+      id,
+      name: String(participant.name || id),
+    };
+  }
+  throw new TypeError("MsgHub participant must be a string or object");
+}
+
+function truncateText(value, maxLength) {
+  const text = String(value || "").trim();
+  if (text.length <= maxLength) return text;
+  return `${text.slice(0, Math.max(0, maxLength - 1))}…`;
+}
+
+export function sanitizeMessageReference(message, options = {}) {
+  const maxSummaryLength = Number(options.maxSummaryLength || 400);
+  if (message == null) return { summary: "" };
+
+  if (typeof message === "string") {
+    return { summary: truncateText(message, maxSummaryLength) };
+  }
+
+  if (Array.isArray(message)) {
+    return {
+      items: message.slice(0, 20).map((entry) => sanitizeMessageReference(entry, options)),
+    };
+  }
+
+  if (typeof message === "object") {
+    const sanitized = {};
+    for (const [key, value] of Object.entries(message)) {
+      if (!SAFE_KEYS.has(key)) continue;
+      if (typeof value === "string") {
+        sanitized[key] = truncateText(value, maxSummaryLength);
+        continue;
+      }
+      if (Array.isArray(value)) {
+        sanitized[key] = value.slice(0, 50).map((entry) => truncateText(entry, maxSummaryLength));
+        continue;
+      }
+      if (value != null && (typeof value === "number" || typeof value === "boolean")) {
+        sanitized[key] = value;
+      }
+    }
+    if (Object.keys(sanitized).length > 0) return sanitized;
+  }
+
+  return { summary: truncateText(JSON.stringify(message), maxSummaryLength) };
+}
+
+export class MsgHub {
+  constructor(participants = [], options = {}) {
+    this.options = { ...options };
+    this._events = new EventEmitter();
+    this._participants = new Map();
+    this._queues = new Map();
+    this._handlers = new Map();
+    this._closed = false;
+
+    participants.forEach((participant, index) => {
+      this.add(participant, index);
+    });
+  }
+
+  static async create(participants = [], options = {}) {
+    return new MsgHub(participants, options);
+  }
+
+  add(participant, index = this._participants.size) {
+    if (this._closed) throw new Error("MsgHub is closed");
+    const normalized = normalizeParticipant(participant, index);
+    this._participants.set(normalized.id, normalized);
+    if (!this._queues.has(normalized.id)) this._queues.set(normalized.id, []);
+    if (!this._handlers.has(normalized.id)) this._handlers.set(normalized.id, new Set());
+    return normalized;
+  }
+
+  remove(participantOrId) {
+    const id = typeof participantOrId === "string" ? participantOrId : participantOrId?.id;
+    if (!id) return false;
+    const existed = this._participants.delete(id);
+    this._queues.delete(id);
+    this._handlers.delete(id);
+    return existed;
+  }
+
+  has(participantOrId) {
+    const id = typeof participantOrId === "string" ? participantOrId : participantOrId?.id;
+    return !!id && this._participants.has(id);
+  }
+
+  listParticipants() {
+    return Array.from(this._participants.values());
+  }
+
+  subscribe(participantOrId, handler) {
+    const id = typeof participantOrId === "string" ? participantOrId : participantOrId?.id;
+    if (!id || typeof handler !== "function") {
+      throw new TypeError("MsgHub.subscribe requires a participant id and handler");
+    }
+    if (!this._handlers.has(id)) this._handlers.set(id, new Set());
+    this._handlers.get(id).add(handler);
+    return () => {
+      this._handlers.get(id)?.delete(handler);
+    };
+  }
+
+  publish(fromParticipant, message, options = {}) {
+    if (this._closed) throw new Error("MsgHub is closed");
+    const fromId = typeof fromParticipant === "string" ? fromParticipant : fromParticipant?.id;
+    if (!fromId || !this._participants.has(fromId)) {
+      throw new Error("MsgHub.publish requires a known sender");
+    }
+
+    const reference = sanitizeMessageReference(message, this.options);
+    const deliveries = [];
+
+    for (const participant of this._participants.values()) {
+      if (participant.id === fromId) continue;
+      const envelope = {
+        id: randomUUID(),
+        from: fromId,
+        to: participant.id,
+        topic: String(options.topic || "reference"),
+        createdAt: new Date().toISOString(),
+        message: reference,
+      };
+      this._queues.get(participant.id)?.push(envelope);
+      for (const handler of this._handlers.get(participant.id) || []) {
+        handler(envelope);
+      }
+      this._events.emit("message", envelope);
+      deliveries.push(envelope);
+    }
+
+    return deliveries;
+  }
+
+  observeOutput(fromParticipant, output, options = {}) {
+    const descriptor = output?.descriptor || output?.reference || output?.output || output;
+    return this.publish(fromParticipant, descriptor, options);
+  }
+
+  drain(participantOrId) {
+    const id = typeof participantOrId === "string" ? participantOrId : participantOrId?.id;
+    if (!id) return [];
+    const queue = this._queues.get(id) || [];
+    this._queues.set(id, []);
+    return queue.slice();
+  }
+
+  close() {
+    if (this._closed) return;
+    this._closed = true;
+    this._participants.clear();
+    this._queues.clear();
+    this._handlers.clear();
+    this._events.removeAllListeners();
+  }
+}
+
+export default MsgHub;