@kenkaiiii/gg-boss 4.3.146 → 4.3.148

package/dist/{chunk-3EWLK53W.js → chunk-ZNVFGIDI.js}

@@ -32167,8 +32167,11 @@ var require_jsx_runtime = __commonJS({
   }
 });
 
-// src/worker.ts
+// src/logger.ts
 init_esm_shims();
+import fs26 from "fs";
+import path25 from "path";
+import { randomBytes as randomBytes3 } from "crypto";
 
 // ../ggcoder/dist/index.js
 init_esm_shims();
@@ -90714,6 +90717,73 @@ import { execFileSync as execFileSync2 } from "child_process";
 var ESC3 = String.fromCharCode(27);
 var oscResponsePattern = new RegExp(ESC3 + "\\]11;rgb:([0-9a-fA-F]+)/([0-9a-fA-F]+)/([0-9a-fA-F]+)");
 
+// src/logger.ts
+var MAX_BYTES3 = 10 * 1024 * 1024;
+var fd2 = null;
+var sessionId2 = "";
+function getLogPath() {
+  return path25.join(getAppPaths().agentDir, "boss", "debug.log");
+}
+function rotateIfNeeded(filePath) {
+  try {
+    const st = fs26.statSync(filePath);
+    if (st.size < MAX_BYTES3) return;
+    const rotated = `${filePath}.1`;
+    try {
+      fs26.unlinkSync(rotated);
+    } catch {
+    }
+    fs26.renameSync(filePath, rotated);
+  } catch {
+  }
+}
+function initLogger2(meta3) {
+  if (fd2 !== null) return;
+  const filePath = getLogPath();
+  try {
+    fs26.mkdirSync(path25.dirname(filePath), { recursive: true, mode: 448 });
+  } catch {
+    return;
+  }
+  rotateIfNeeded(filePath);
+  try {
+    fd2 = fs26.openSync(filePath, "a");
+  } catch {
+    return;
+  }
+  sessionId2 = randomBytes3(4).toString("hex");
+  try {
+    fs26.writeSync(fd2, "\n");
+  } catch {
+  }
+  const parts = ["gg-boss"];
+  if (meta3?.version) parts[0] += ` v${meta3.version}`;
+  parts.push("started");
+  if (meta3?.bossProvider) parts.push(`boss=${meta3.bossProvider}/${meta3.bossModel ?? "?"}`);
+  if (meta3?.bossThinking) parts.push(`bossThinking=${meta3.bossThinking}`);
+  if (meta3?.workerProvider) parts.push(`workers=${meta3.workerProvider}/${meta3.workerModel ?? "?"}`);
+  if (meta3?.projectCount !== void 0) parts.push(`projects=${meta3.projectCount}`);
+  parts.push(`pid=${process.pid}`);
+  log2("INFO", "startup", parts.join(" "));
+}
+function log2(level, category, message, data) {
+  if (fd2 === null) return;
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  let line = `[${ts}] [sid=${sessionId2}] [${level}] [${category}] ${message}`;
+  if (data) {
+    const pairs = Object.entries(data).map(([k, v]) => `${k}=${typeof v === "string" ? v : JSON.stringify(v)}`).join(" ");
+    if (pairs) line += ` ${pairs}`;
+  }
+  line += "\n";
+  try {
+    fs26.writeSync(fd2, line);
+  } catch {
+  }
+}
+
+// src/worker.ts
+init_esm_shims();
+
 // src/boss-store.ts
 init_esm_shims();
 var import_react75 = __toESM(require_react(), 1);
@@ -90832,6 +90902,19 @@ var bossStore = {
     };
     notify();
   },
+  /**
+   * Append the eye-catching update-available notice. Distinct kind so the
+   * renderer can give it the rounded green-bordered "✨ ..." box treatment
+   * that mirrors ggcoder's update notice — flat info text gets lost in
+   * worker chatter, this stands out.
+   */
+  appendUpdateNotice(text) {
+    state = {
+      ...state,
+      history: [...state.history, { kind: "update_notice", id: id(), text }]
+    };
+    notify();
+  },
   /**
    * Queue an info message to be appended AFTER the boss's current turn ends.
    * Used by tools (like add_task's keybind hint) that fire mid-turn and would
@@ -91299,6 +91382,20 @@ var bossStore = {
 };
 
 // src/worker.ts
+function safeBusHandler(workerName, handlerName, fn, onError) {
+  return (event) => {
+    try {
+      fn(event);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      log2("ERROR", "worker", `bus handler "${handlerName}" threw`, {
+        worker: workerName,
+        message
+      });
+      onError(`Worker "${workerName}" event handler error: ${message}`);
+    }
+  };
+}
 var Worker = class {
   name;
   cwd;
@@ -91367,45 +91464,88 @@ var Worker = class {
   }
   wireEvents() {
     const bus = this.session.eventBus;
-    bus.on("text_delta", ({ text }) => {
-      this.currentText += text;
-    });
-    bus.on("tool_call_start", ({ toolCallId, name }) => {
-      this.activeTools.set(toolCallId, name);
-    });
-    bus.on("tool_call_end", ({ toolCallId, isError }) => {
-      const name = this.activeTools.get(toolCallId);
-      this.activeTools.delete(toolCallId);
-      if (name) this.currentTools.push({ name, ok: !isError });
-    });
-    bus.on("agent_done", () => {
-      this.turnCount += 1;
-      const summary = {
-        project: this.name,
-        cwd: this.cwd,
-        status: "idle",
-        finalText: this.currentText.trim(),
-        toolsUsed: [...this.currentTools],
-        turnIndex: this.turnCount,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      this.currentText = "";
-      this.currentTools = [];
-      this.status = "idle";
-      bossStore.appendWorkerEvent(summary);
-      this.queue.push({ kind: "worker_turn_complete", summary });
-    });
-    bus.on("error", ({ error: error51 }) => {
-      this.status = "error";
+    const reportError2 = (message) => {
       const ts = (/* @__PURE__ */ new Date()).toISOString();
-      bossStore.appendWorkerError(this.name, error51.message, ts);
+      this.status = "error";
+      bossStore.appendWorkerError(this.name, message, ts);
       this.queue.push({
         kind: "worker_error",
         project: this.name,
-        message: error51.message,
+        message,
         timestamp: ts
       });
-    });
+    };
+    bus.on(
+      "text_delta",
+      safeBusHandler(
+        this.name,
+        "text_delta",
+        ({ text }) => {
+          this.currentText += text;
+        },
+        reportError2
+      )
+    );
+    bus.on(
+      "tool_call_start",
+      safeBusHandler(
+        this.name,
+        "tool_call_start",
+        ({ toolCallId, name }) => {
+          this.activeTools.set(toolCallId, name);
+        },
+        reportError2
+      )
+    );
+    bus.on(
+      "tool_call_end",
+      safeBusHandler(
+        this.name,
+        "tool_call_end",
+        ({ toolCallId, isError }) => {
+          const name = this.activeTools.get(toolCallId);
+          this.activeTools.delete(toolCallId);
+          if (name) this.currentTools.push({ name, ok: !isError });
+        },
+        reportError2
+      )
+    );
+    bus.on(
+      "agent_done",
+      safeBusHandler(
+        this.name,
+        "agent_done",
+        () => {
+          this.turnCount += 1;
+          const summary = {
+            project: this.name,
+            cwd: this.cwd,
+            status: "idle",
+            finalText: this.currentText.trim(),
+            toolsUsed: [...this.currentTools],
+            turnIndex: this.turnCount,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          this.currentText = "";
+          this.currentTools = [];
+          this.status = "idle";
+          bossStore.appendWorkerEvent(summary);
+          this.queue.push({ kind: "worker_turn_complete", summary });
+        },
+        reportError2
+      )
+    );
+    bus.on(
+      "error",
+      safeBusHandler(
+        this.name,
+        "error",
+        ({ error: error51 }) => {
+          reportError2(error51.message);
+        },
+        reportError2
+      )
+    );
   }
 };
 
@@ -91441,17 +91581,17 @@ var EventQueue = class {
 
 // src/settings.ts
 init_esm_shims();
-import fs26 from "fs/promises";
-import path25 from "path";
+import fs27 from "fs/promises";
+import path26 from "path";
 function settingsPath() {
-  return path25.join(getAppPaths().agentDir, "boss", "settings.json");
+  return path26.join(getAppPaths().agentDir, "boss", "settings.json");
 }
 async function ensureDir() {
-  await fs26.mkdir(path25.dirname(settingsPath()), { recursive: true, mode: 448 });
+  await fs27.mkdir(path26.dirname(settingsPath()), { recursive: true, mode: 448 });
 }
 async function loadSettings() {
   try {
-    const content = await fs26.readFile(settingsPath(), "utf-8");
+    const content = await fs27.readFile(settingsPath(), "utf-8");
     const parsed = JSON.parse(content);
     return parsed && typeof parsed === "object" ? parsed : {};
   } catch {
@@ -91465,81 +91605,13 @@ async function saveSettings(patch) {
     const merged = { ...current, ...patch };
     await ensureDir();
     const tmp = `${settingsPath()}.${process.pid}.tmp`;
-    await fs26.writeFile(tmp, JSON.stringify(merged, null, 2) + "\n", "utf-8");
-    await fs26.rename(tmp, settingsPath());
+    await fs27.writeFile(tmp, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+    await fs27.rename(tmp, settingsPath());
   });
   writeChain = next.catch(() => void 0);
   await next;
 }
 
-// src/logger.ts
-init_esm_shims();
-import fs27 from "fs";
-import path26 from "path";
-import { randomBytes as randomBytes3 } from "crypto";
-var MAX_BYTES3 = 10 * 1024 * 1024;
-var fd2 = null;
-var sessionId2 = "";
-function getLogPath() {
-  return path26.join(getAppPaths().agentDir, "boss", "debug.log");
-}
-function rotateIfNeeded(filePath) {
-  try {
-    const st = fs27.statSync(filePath);
-    if (st.size < MAX_BYTES3) return;
-    const rotated = `${filePath}.1`;
-    try {
-      fs27.unlinkSync(rotated);
-    } catch {
-    }
-    fs27.renameSync(filePath, rotated);
-  } catch {
-  }
-}
-function initLogger2(meta3) {
-  if (fd2 !== null) return;
-  const filePath = getLogPath();
-  try {
-    fs27.mkdirSync(path26.dirname(filePath), { recursive: true, mode: 448 });
-  } catch {
-    return;
-  }
-  rotateIfNeeded(filePath);
-  try {
-    fd2 = fs27.openSync(filePath, "a");
-  } catch {
-    return;
-  }
-  sessionId2 = randomBytes3(4).toString("hex");
-  try {
-    fs27.writeSync(fd2, "\n");
-  } catch {
-  }
-  const parts = ["gg-boss"];
-  if (meta3?.version) parts[0] += ` v${meta3.version}`;
-  parts.push("started");
-  if (meta3?.bossProvider) parts.push(`boss=${meta3.bossProvider}/${meta3.bossModel ?? "?"}`);
-  if (meta3?.bossThinking) parts.push(`bossThinking=${meta3.bossThinking}`);
-  if (meta3?.workerProvider) parts.push(`workers=${meta3.workerProvider}/${meta3.workerModel ?? "?"}`);
-  if (meta3?.projectCount !== void 0) parts.push(`projects=${meta3.projectCount}`);
-  parts.push(`pid=${process.pid}`);
-  log2("INFO", "startup", parts.join(" "));
-}
-function log2(level, category, message, data) {
-  if (fd2 === null) return;
-  const ts = (/* @__PURE__ */ new Date()).toISOString();
-  let line = `[${ts}] [sid=${sessionId2}] [${level}] [${category}] ${message}`;
-  if (data) {
-    const pairs = Object.entries(data).map(([k, v]) => `${k}=${typeof v === "string" ? v : JSON.stringify(v)}`).join(" ");
-    if (pairs) line += ` ${pairs}`;
-  }
-  line += "\n";
-  try {
-    fs27.writeSync(fd2, line);
-  } catch {
-  }
-}
-
 // src/boss-system-prompt.ts
 init_esm_shims();
 function buildBossSystemPrompt(projects) {
@@ -92718,132 +92790,144 @@ var GGBoss = class {
   async run() {
     this.running = true;
     while (this.running) {
-      const event = await this.queue.next();
-      if (!this.running) break;
-      if (event.kind === "user_message") {
-        this.pendingUserMessages = Math.max(0, this.pendingUserMessages - 1);
-        bossStore.setPendingMessages(this.pendingUserMessages);
-      }
-      let finishedTaskId = null;
-      if (event.kind === "worker_turn_complete") {
-        void playDoneAudio();
-        this.hadWorkerActivitySinceReady = true;
-        this.lastSummaries.set(event.summary.project, event.summary);
-        log2("INFO", "worker_turn_complete", "worker finished", {
-          project: event.summary.project,
-          turn: event.summary.turnIndex,
-          tools: event.summary.toolsUsed.length,
-          failed: event.summary.toolsUsed.filter((t) => !t.ok).length
-        });
-        const taskId = this.inFlightTaskByProject.get(event.summary.project);
-        finishedTaskId = taskId ?? null;
-        if (taskId) {
-          this.inFlightTaskByProject.delete(event.summary.project);
-          const task = tasksStore.byId(taskId);
-          if (task && task.status === "in_progress") {
-            const reported = parseReportedStatus(event.summary.finalText);
-            const newStatus = reportedToTaskStatus(
-              reported,
-              event.summary.toolsUsed.some((t) => !t.ok)
-            );
-            await tasksStore.update(taskId, {
-              status: newStatus,
-              resultSummary: event.summary.finalText
-            });
-          }
+      try {
+        await this.runIteration();
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        log2("ERROR", "run_loop", "iteration threw", { message });
+        try {
+          bossStore.appendInfo(`Boss loop error (recovered): ${message}`, "error");
+        } catch {
         }
       }
-      if (event.kind === "worker_error") {
-        this.hadWorkerActivitySinceReady = true;
-        log2("ERROR", "worker_error", event.message, { project: event.project });
-        const taskId = this.inFlightTaskByProject.get(event.project);
-        if (taskId) {
-          this.inFlightTaskByProject.delete(event.project);
+    }
+  }
+  async runIteration() {
+    const event = await this.queue.next();
+    if (!this.running) return;
+    if (event.kind === "user_message") {
+      this.pendingUserMessages = Math.max(0, this.pendingUserMessages - 1);
+      bossStore.setPendingMessages(this.pendingUserMessages);
+    }
+    let finishedTaskId = null;
+    if (event.kind === "worker_turn_complete") {
+      void playDoneAudio();
+      this.hadWorkerActivitySinceReady = true;
+      this.lastSummaries.set(event.summary.project, event.summary);
+      log2("INFO", "worker_turn_complete", "worker finished", {
+        project: event.summary.project,
+        turn: event.summary.turnIndex,
+        tools: event.summary.toolsUsed.length,
+        failed: event.summary.toolsUsed.filter((t) => !t.ok).length
+      });
+      const taskId = this.inFlightTaskByProject.get(event.summary.project);
+      finishedTaskId = taskId ?? null;
+      if (taskId) {
+        this.inFlightTaskByProject.delete(event.summary.project);
+        const task = tasksStore.byId(taskId);
+        if (task && task.status === "in_progress") {
+          const reported = parseReportedStatus(event.summary.finalText);
+          const newStatus = reportedToTaskStatus(
+            reported,
+            event.summary.toolsUsed.some((t) => !t.ok)
+          );
           await tasksStore.update(taskId, {
-            status: "blocked",
-            notes: `Worker error: ${event.message}`
+            status: newStatus,
+            resultSummary: event.summary.finalText
           });
         }
       }
-      await this.runCompaction(false);
-      const workerSnapshot = [...this.workers.entries()].map(([name, w]) => ({
-        name,
-        status: w.getStatus()
-      }));
-      const notices = this.pendingAutoChainNotices.splice(0);
-      const text = formatEventForBoss(event, workerSnapshot, notices);
-      bossStore.startStreaming();
-      this.turnAc = new AbortController();
-      this.bossAgent.setSignal(this.turnAc.signal);
-      try {
-        const stream2 = this.bossAgent.prompt(text);
-        for await (const e of stream2) {
-          switch (e.type) {
-            case "text_delta":
-              bossStore.appendStreamText(e.text);
-              break;
-            case "thinking_delta":
-              bossStore.appendStreamThinking(e.text);
-              break;
-            case "tool_call_start":
-              bossStore.flushPendingText();
-              bossStore.startTool(e.toolCallId, e.name, e.args);
-              bossStore.setActivityPhase("tools");
-              break;
-            case "tool_call_end":
-              bossStore.endTool(e.toolCallId, e.isError, e.durationMs, e.result, e.details);
-              break;
-            case "turn_end":
-              if (e.usage) {
-                bossStore.setBossInputTokens(computeContextUsed(e.usage, this.opts.bossProvider));
-              }
-              bossStore.flushPendingText();
-              bossStore.flushEndOfTurnInfos();
-              break;
-            case "retry":
-              if (!e.silent) {
-                bossStore.setRetryInfo({
-                  reason: e.reason,
-                  attempt: e.attempt,
-                  maxAttempts: e.maxAttempts,
-                  delayMs: e.delayMs
-                });
-              }
-              break;
-            case "error":
-              bossStore.appendInfo(formatProviderError(e.error.message), "error");
-              break;
-            default:
-              break;
-          }
+    }
+    if (event.kind === "worker_error") {
+      this.hadWorkerActivitySinceReady = true;
+      log2("ERROR", "worker_error", event.message, { project: event.project });
+      const taskId = this.inFlightTaskByProject.get(event.project);
+      if (taskId) {
+        this.inFlightTaskByProject.delete(event.project);
+        await tasksStore.update(taskId, {
+          status: "blocked",
+          notes: `Worker error: ${event.message}`
+        });
+      }
+    }
+    await this.runCompaction(false);
+    const workerSnapshot = [...this.workers.entries()].map(([name, w]) => ({
+      name,
+      status: w.getStatus()
+    }));
+    const notices = this.pendingAutoChainNotices.splice(0);
+    const text = formatEventForBoss(event, workerSnapshot, notices);
+    bossStore.startStreaming();
+    this.turnAc = new AbortController();
+    this.bossAgent.setSignal(this.turnAc.signal);
+    try {
+      const stream2 = this.bossAgent.prompt(text);
+      for await (const e of stream2) {
+        switch (e.type) {
+          case "text_delta":
+            bossStore.appendStreamText(e.text);
+            break;
+          case "thinking_delta":
+            bossStore.appendStreamThinking(e.text);
+            break;
+          case "tool_call_start":
+            bossStore.flushPendingText();
+            bossStore.startTool(e.toolCallId, e.name, e.args);
+            bossStore.setActivityPhase("tools");
+            break;
+          case "tool_call_end":
+            bossStore.endTool(e.toolCallId, e.isError, e.durationMs, e.result, e.details);
+            break;
+          case "turn_end":
+            if (e.usage) {
+              bossStore.setBossInputTokens(computeContextUsed(e.usage, this.opts.bossProvider));
+            }
+            bossStore.flushPendingText();
+            bossStore.flushEndOfTurnInfos();
+            break;
+          case "retry":
+            if (!e.silent) {
+              bossStore.setRetryInfo({
+                reason: e.reason,
+                attempt: e.attempt,
+                maxAttempts: e.maxAttempts,
+                delayMs: e.delayMs
+              });
+            }
+            break;
+          case "error":
+            bossStore.appendInfo(formatProviderError(e.error.message), "error");
+            break;
+          default:
+            break;
         }
-      } catch (err) {
-        if (isAbortError3(err)) {
-          bossStore.interruptStreaming();
-          if (!this.running) {
-            bossStore.finishStreaming();
-            return;
-          }
-          bossStore.appendInfo("Interrupted by user.", "warning");
+      }
+    } catch (err) {
+      if (isAbortError3(err)) {
+        bossStore.interruptStreaming();
+        if (!this.running) {
           bossStore.finishStreaming();
-          await this.persistNewMessages();
-          continue;
+          return;
         }
-        const message = err instanceof Error ? err.message : String(err);
-        log2("ERROR", "boss_turn", message);
-        bossStore.appendInfo(formatProviderError(message), "error");
-      }
-      bossStore.finishStreaming();
-      await this.persistNewMessages();
-      if (event.kind === "worker_turn_complete" && finishedTaskId) {
-        await this.maybeAutoChain(event.summary.project);
-      }
-      const allWorkersIdle = [...this.workers.values()].every((w) => w.getStatus() === "idle");
-      if (this.hadWorkerActivitySinceReady && allWorkersIdle && this.queue.size() === 0) {
-        this.hadWorkerActivitySinceReady = false;
-        log2("INFO", "all_clear", "all workers idle, queue empty");
-        void playReadyAudio();
+        bossStore.appendInfo("Interrupted by user.", "warning");
+        bossStore.finishStreaming();
+        await this.persistNewMessages();
+        return;
       }
+      const message = err instanceof Error ? err.message : String(err);
+      log2("ERROR", "boss_turn", message);
+      bossStore.appendInfo(formatProviderError(message), "error");
+    }
+    bossStore.finishStreaming();
+    await this.persistNewMessages();
+    if (event.kind === "worker_turn_complete" && finishedTaskId) {
+      await this.maybeAutoChain(event.summary.project);
+    }
+    const allWorkersIdle = [...this.workers.values()].every((w) => w.getStatus() === "idle");
+    if (this.hadWorkerActivitySinceReady && allWorkersIdle && this.queue.size() === 0) {
+      this.hadWorkerActivitySinceReady = false;
+      log2("INFO", "all_clear", "all workers idle, queue empty");
+      void playReadyAudio();
     }
   }
   async maybeAutoChain(project) {
@@ -92990,6 +93074,8 @@ export {
   ModelSelector,
   useBossState,
   bossStore,
+  initLogger2 as initLogger,
+  log2 as log,
   Worker,
   EventQueue,
   useTasksState,
@@ -92997,8 +93083,6 @@ export {
   loadSettings,
   getSplashAudioDurationMs,
   playSplashAudio,
-  initLogger2 as initLogger,
-  log2 as log,
   buildBossSystemPrompt,
   GGBoss
 };
@@ -93114,4 +93198,4 @@ react/cjs/react-jsx-runtime.development.js:
    * LICENSE file in the root directory of this source tree.
    *)
 */
-//# sourceMappingURL=chunk-3EWLK53W.js.map
+//# sourceMappingURL=chunk-ZNVFGIDI.js.map