@taewooopark/agent-blackbox 0.47.2 → 0.47.4

package/dist/cli.js

@@ -2048,7 +2048,7 @@ async function readTraceEvents(filePath) {
 }
 
 // apps/daemon/dist/server.js
-import { readFile as readFile4 } from "node:fs/promises";
+import { open as open2, stat as stat3 } from "node:fs/promises";
 import { createServer as createServer2 } from "node:http";
 import { join as join4 } from "node:path";
 import { WebSocket, WebSocketServer } from "ws";
@@ -2642,24 +2642,67 @@ async function loadTraceEvents(eventsFile) {
   }
 }
 var SNAPSHOT_EVENT_CAP = 3e4;
+var eventCaches = /* @__PURE__ */ new Map();
+var cacheLocks = /* @__PURE__ */ new Map();
+function withCacheLock(key, run) {
+  const prev = cacheLocks.get(key) ?? Promise.resolve();
+  const result = prev.then(run, run);
+  cacheLocks.set(key, result.then(() => void 0, () => void 0));
+  return result;
+}
 async function loadRecentTraceEvents(eventsFile, cap = SNAPSHOT_EVENT_CAP) {
-  let text;
-  try {
-    text = await readFile4(eventsFile, "utf8");
-  } catch (error) {
-    if (isNodeError(error) && error.code === "ENOENT")
-      return [];
-    throw error;
-  }
-  const lines = text.split("\n");
-  let kept = 0;
-  let start = lines.length;
-  while (start > 0 && kept < cap) {
-    start -= 1;
-    if (lines[start].trim().length > 0)
-      kept += 1;
-  }
-  return parseTraceEvents(lines.slice(start).join("\n"));
+  return withCacheLock(eventsFile, async () => {
+    let cache = eventCaches.get(eventsFile);
+    if (!cache) {
+      cache = { offset: 0, buffer: "", events: [] };
+      eventCaches.set(eventsFile, cache);
+    }
+    let size;
+    try {
+      size = (await stat3(eventsFile)).size;
+    } catch (error) {
+      if (isNodeError(error) && error.code === "ENOENT")
+        return [];
+      throw error;
+    }
+    if (size < cache.offset) {
+      cache.offset = 0;
+      cache.buffer = "";
+      cache.events = [];
+    }
+    if (size > cache.offset) {
+      const handle = await open2(eventsFile, "r");
+      try {
+        const length = size - cache.offset;
+        const buf = Buffer.alloc(length);
+        await handle.read(buf, 0, length, cache.offset);
+        cache.offset = size;
+        cache.buffer += buf.toString("utf8");
+      } finally {
+        await handle.close();
+      }
+      const lines = cache.buffer.split("\n");
+      cache.buffer = lines.pop() ?? "";
+      let from = 0;
+      if (cache.events.length === 0 && lines.length > SNAPSHOT_EVENT_CAP) {
+        let kept = 0;
+        from = lines.length;
+        while (from > 0 && kept < SNAPSHOT_EVENT_CAP) {
+          from -= 1;
+          if (lines[from].trim().length > 0)
+            kept += 1;
+        }
+      }
+      const fresh = parseTraceEvents(lines.slice(from).join("\n"));
+      if (fresh.length > 0) {
+        cache.events.push(...fresh);
+        if (cache.events.length > SNAPSHOT_EVENT_CAP) {
+          cache.events.splice(0, cache.events.length - SNAPSHOT_EVENT_CAP);
+        }
+      }
+    }
+    return cap >= cache.events.length ? cache.events.slice() : cache.events.slice(cache.events.length - cap);
+  });
 }
 async function buildReplaySummary(eventsFile) {
   const events = await loadTraceEvents(eventsFile);
@@ -2785,20 +2828,49 @@ async function broadcastSnapshot(clients, eventsFile) {
   if (clients.size === 0) {
     return;
   }
-  await Promise.allSettled([...clients].map((client) => sendSnapshot(client, eventsFile)));
+  let frame;
+  try {
+    frame = JSON.stringify({ type: "snapshot", data: await buildTraceSnapshot(eventsFile) });
+  } catch (error) {
+    const errFrame = JSON.stringify({
+      type: "error",
+      error: { message: error instanceof Error ? error.message : String(error) }
+    });
+    for (const client of clients)
+      if (client.readyState === WebSocket.OPEN)
+        client.send(errFrame);
+    return;
+  }
+  for (const client of clients)
+    if (client.readyState === WebSocket.OPEN)
+      client.send(frame);
 }
 function makeBroadcastScheduler(clients, eventsFile, delayMs = 150) {
   let timer = null;
-  return () => {
+  let building = false;
+  let pending = false;
+  const schedule = () => {
+    if (building) {
+      pending = true;
+      return;
+    }
     if (timer)
       return;
     timer = setTimeout(() => {
       timer = null;
-      void broadcastSnapshot(clients, eventsFile);
+      building = true;
+      void broadcastSnapshot(clients, eventsFile).finally(() => {
+        building = false;
+        if (pending) {
+          pending = false;
+          schedule();
+        }
+      });
     }, delayMs);
     if (typeof timer.unref === "function")
       timer.unref();
   };
+  return schedule;
 }
 async function sendSnapshot(client, eventsFile) {
   if (client.readyState !== WebSocket.OPEN) {
@@ -2892,7 +2964,7 @@ function isNodeError(error) {
 }
 
 // apps/daemon/dist/initOpenCode.js
-import { mkdir as mkdir3, readFile as readFile5, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
+import { mkdir as mkdir3, readFile as readFile4, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
 import { dirname as dirname3, join as join5 } from "node:path";
 var defaultAdapterPackage = "@agent-blackbox/opencode-adapter";
@@ -2909,7 +2981,7 @@ async function installGlobalRecorder(options) {
     throw new Error("Self-contained recorder bundle not found. Use the published npx package, or build it from source with `npm run build:cli`.");
   }
   const pluginPath = globalRecorderPath();
-  const bundle = (await readFile5(options.pluginBundlePath, "utf8")).replaceAll("__ABB_DAEMON_URL__", options.daemonUrl);
+  const bundle = (await readFile4(options.pluginBundlePath, "utf8")).replaceAll("__ABB_DAEMON_URL__", options.daemonUrl);
   await mkdir3(dirname3(pluginPath), { recursive: true });
   await writeFile2(pluginPath, bundle, "utf8");
   return { pluginPath };
@@ -2938,7 +3010,7 @@ async function initOpenCodeProject(options) {
     throw new Error(`${pluginPath} already exists. Re-run with --force to overwrite it.`);
   }
   if (options.pluginBundlePath && await pathExists(options.pluginBundlePath)) {
-    const bundle = await readFile5(options.pluginBundlePath, "utf8");
+    const bundle = await readFile4(options.pluginBundlePath, "utf8");
     const inlined = bundle.replaceAll("__ABB_DAEMON_URL__", daemonUrl);
     await writeFile2(pluginPath, inlined, "utf8");
     return { pluginPath, packageJsonPath, adapterPackage, adapterImport };
@@ -2977,7 +3049,7 @@ function inferAdapterImport(adapterPackage) {
 }
 async function readPackageJson(packageJsonPath) {
   try {
-    return JSON.parse(await readFile5(packageJsonPath, "utf8"));
+    return JSON.parse(await readFile4(packageJsonPath, "utf8"));
   } catch (error) {
     if (isNodeError2(error) && error.code === "ENOENT") {
       return {};
@@ -2987,7 +3059,7 @@ async function readPackageJson(packageJsonPath) {
 }
 async function pathExists(path) {
   try {
-    await readFile5(path, "utf8");
+    await readFile4(path, "utf8");
     return true;
   } catch (error) {
     if (isNodeError2(error) && error.code === "ENOENT") {
@@ -3023,7 +3095,7 @@ function describeDaemon() {
 }
 
 // apps/daemon/dist/initClaudeHooks.js
-import { mkdir as mkdir4, readFile as readFile6, writeFile as writeFile3 } from "node:fs/promises";
+import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile3 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
 import { dirname as dirname5, join as join7 } from "node:path";
 function globalClaudeDir() {
@@ -3046,7 +3118,7 @@ async function uninstallClaudeCodeHooks() {
   const settingsPath = claudeSettingsPath();
   let settings;
   try {
-    settings = JSON.parse(await readFile6(settingsPath, "utf8"));
+    settings = JSON.parse(await readFile5(settingsPath, "utf8"));
   } catch (error) {
     if (isNotFound(error))
       return { settingsPath, removed: false };
@@ -3060,7 +3132,7 @@ async function uninstallClaudeCodeHooks() {
 }
 async function readSettings(path) {
   try {
-    return JSON.parse(await readFile6(path, "utf8"));
+    return JSON.parse(await readFile5(path, "utf8"));
   } catch (error) {
     if (isNotFound(error))
       return {};