agent-dag 1.33.63 → 1.33.65

package/dist/web/index.html

@@ -5,7 +5,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <title>agents-deck</title>
     <link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'%3E%3Ctext y='84' font-size='84'%3E%E2%97%89%3C/text%3E%3C/svg%3E" />
-    <script type="module" crossorigin src="/assets/index-DQe_LZzS.js"></script>
+    <script type="module" crossorigin src="/assets/index-A5CpPEUh.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-CF2yG9oG.css">
   </head>
   <body>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-dag",
-  "version": "1.33.63",
+  "version": "1.33.65",
   "description": "Live deck of Claude Code and Codex agents — watch parallel subagents fork, call tools, and return on one calm canvas. Also available as npx ccdeck and npx agent-dag.",
   "type": "module",
   "bin": {

package/src/server/codex-usage.mjs

@@ -4,6 +4,7 @@
 import { readdir, open, stat } from "node:fs/promises";
 import { join } from "node:path";
 import { homedir } from "node:os";
+import { StringDecoder } from "node:string_decoder";
 
 const CODEX_HOME = process.env.CODEX_HOME
   ? process.env.CODEX_HOME
@@ -18,6 +19,47 @@ const CACHE_MS = 60_000;
 const WINDOW_5H_MS  = 5 * 60 * 60 * 1000;
 const WINDOW_7D_MS  = 7 * 24 * 60 * 60 * 1000;
 
+// A rollout file grows for as long as its session runs, and a week's worth of
+// them is however much the user happened to type. Reading them all at once made
+// the peak working set a function of that total; these two caps make it a
+// function of the pool instead — at most MAX_PARALLEL_READS files in flight,
+// each holding one chunk plus the line it is still assembling.
+const READ_CHUNK_BYTES = 256 * 1024;
+const MAX_PARALLEL_READS = 4;
+
+// Run `worker` over `items` with at most `limit` of them in flight. Workers
+// pull from a shared cursor, so a slow file delays only its own worker instead
+// of stalling a fixed-size batch.
+async function forEachLimited(items, limit, worker) {
+  let next = 0;
+  const workers = [];
+  for (let i = 0; i < Math.min(limit, items.length); i++) {
+    workers.push((async () => {
+      while (next < items.length) await worker(items[next++]);
+    })());
+  }
+  await Promise.all(workers);
+}
+
+// Append one rollout line's token_count event to the series, if it has one.
+function foldTokenLine(series, raw) {
+  // Cheap pre-filter before the (relatively) expensive JSON.parse.
+  if (!raw.includes("total_token_usage")) return;
+  let obj;
+  try { obj = JSON.parse(raw); } catch { return; }
+  if (obj.type !== "event_msg" || obj.payload?.type !== "token_count") return;
+  const u = obj.payload.info?.total_token_usage;
+  if (!u) return;
+  const ts = obj.timestamp ? Date.parse(obj.timestamp) : NaN;
+  series.push({
+    ts:     isNaN(ts) ? null : ts,
+    inp:    u.input_tokens         ?? 0,
+    out:    u.output_tokens        ?? 0,
+    cacheR: u.cached_input_tokens  ?? 0,
+    total:  u.total_tokens         ?? ((u.input_tokens ?? 0) + (u.output_tokens ?? 0)),
+  });
+}
+
 // Read the full series of cumulative token_count events from a rollout file.
 // Each token_count event carries `info.total_token_usage` — the running total
 // for the session at that point. We keep the whole series (with timestamps) so
@@ -34,25 +76,32 @@ async function readTokenSeries(filePath) {
     fd = await open(filePath, "r");
     const { size } = await fd.stat();
     if (size === 0) return null;
-    const text = (await fd.readFile()).toString("utf8");
     const series = [];
-    for (const raw of text.split("\n")) {
-      // Cheap pre-filter before the (relatively) expensive JSON.parse.
-      if (!raw.includes("total_token_usage")) continue;
-      let obj;
-      try { obj = JSON.parse(raw); } catch { continue; }
-      if (obj.type !== "event_msg" || obj.payload?.type !== "token_count") continue;
-      const u = obj.payload.info?.total_token_usage;
-      if (!u) continue;
-      const ts = obj.timestamp ? Date.parse(obj.timestamp) : NaN;
-      series.push({
-        ts:     isNaN(ts) ? null : ts,
-        inp:    u.input_tokens         ?? 0,
-        out:    u.output_tokens        ?? 0,
-        cacheR: u.cached_input_tokens  ?? 0,
-        total:  u.total_tokens         ?? ((u.input_tokens ?? 0) + (u.output_tokens ?? 0)),
-      });
+    // A chunk at a time rather than the whole file: only the token_count
+    // numbers survive the pass, so buffering megabytes of prompt text (once as
+    // a Buffer, again as a string, a third time as the split array) bought
+    // nothing. StringDecoder carries a UTF-8 sequence that straddles a chunk
+    // boundary over to the next chunk.
+    const buf = Buffer.allocUnsafe(READ_CHUNK_BYTES);
+    const decoder = new StringDecoder("utf8");
+    let pending = "";
+    let pos = 0;
+    while (pos < size) {
+      const { bytesRead } = await fd.read(buf, 0, READ_CHUNK_BYTES, pos);
+      if (bytesRead <= 0) break;
+      pos += bytesRead;
+      pending += decoder.write(buf.subarray(0, bytesRead));
+      let from = 0;
+      let nl;
+      while ((nl = pending.indexOf("\n", from)) >= 0) {
+        foldTokenLine(series, pending.slice(from, nl));
+        from = nl + 1;
+      }
+      if (from > 0) pending = pending.slice(from);
     }
+    // A rollout still being written can end without its final newline.
+    pending += decoder.end();
+    if (pending) foldTokenLine(series, pending);
     return series.length ? series : null;
   } catch { return null; }
   finally { fd?.close().catch(() => {}); }
@@ -161,13 +210,16 @@ export async function fetchCodexUsage({ force = false } = {}) {
     // longer drops active-but-old sessions or over-counts the pre-window tail.
     const files = await listRolloutFiles(WINDOW_7D_MS);
 
-    await Promise.all(files.map(async ({ path }) => {
+    // Bounded fan-out: a week of rollouts is an open-ended list, and opening
+    // every one of them at once also risked EMFILE, which readTokenSeries
+    // swallows into a silent undercount.
+    await forEachLimited(files, MAX_PARALLEL_READS, async ({ path }) => {
       const series = await readTokenSeries(path);
       if (!series) return;
       // Same series feeds both windows; baseline differs per window start.
       addTo(w5h, windowDelta(series, start5h));
       addTo(w7d, windowDelta(series, start7d));
-    }));
+    });
   } catch (err) {
     console.error("agents-deck codex-usage: scan failed:", err?.message ?? err);
     const result = { ok: false, fetchedAt: now };

package/src/server/installer.mjs

@@ -4,7 +4,7 @@
 // Both providers share the discovery dir at <claude config dir>/agent-dag/ so a
 // single running server can receive events from either CLI. Re-runs are safe;
 // entries are tagged with __agent-dag and de-duped.
-import { readFile, writeFile, mkdir, copyFile, unlink, rename, open, stat, chmod } from "node:fs/promises";
+import { readFile, writeFile, mkdir, unlink, rename, open, stat, chmod } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, resolve, dirname } from "node:path";
@@ -203,11 +203,33 @@ async function writeFileAtomic(target, text) {
   }
 }
 
+/**
+ * Install one of the packaged hook scripts without ever exposing a partial one.
+ *
+ * copyFile truncates the destination and then fills it, and the destination here
+ * is a script every live Claude Code session runs on each tool call. Starting the
+ * deck while sessions are open — the normal way this is used — puts a hook
+ * invocation inside that window sooner or later, and what it executes is an
+ * empty or half-written program: a dropped event at best, a SyntaxError in the
+ * user's session at worst. Renaming a finished copy over the name closes it, so
+ * a session opens either the old script or the new one and both are whole.
+ *
+ * Re-installs are the common case and almost always produce the same bytes, so
+ * identical content skips the write and the file is not replaced at all.
+ */
+async function installScript(src, dst) {
+  const text = await readFile(src, "utf8");
+  const current = await readFile(dst, "utf8").catch(() => null);
+  if (current === text) return false;
+  await writeFileAtomic(dst, text);
+  return true;
+}
+
 async function installHookScript(installDir) {
   await ensureDir(installDir);
   const src = join(PKG_ROOT, "hook", "hook.js");
   const dst = join(installDir, "hook.js");
-  await copyFile(src, dst);
+  await installScript(src, dst);
   return dst;
 }
 
@@ -300,5 +322,7 @@ export { AGENT_DAG_DIR, CLAUDE_DIR, CODEX_DIR, CLAUDE_EVENTS, CODEX_EVENTS };
 // Exported for the other modules that rewrite settings.json — the sound toggle
 // today. Every one of them needs the same two guarantees: a file we cannot
 // parse is never treated as an empty one, and the replacement is a single
-// rename rather than a truncate a reader can land inside.
-export { readSettingsForWrite, writeFileAtomic };
+// rename rather than a truncate a reader can land inside. installScript carries
+// the same guarantee to the hook scripts themselves, which are the files live
+// sessions are actually executing.
+export { readSettingsForWrite, writeFileAtomic, installScript };

package/src/server/sound-hook.mjs

@@ -10,13 +10,13 @@
 // Only ever touches its own entry, tagged `__agent-dag-sound`. Hooks the user
 // wrote themselves are left exactly as found — including the platform-specific
 // ones this replaces, which are reported rather than deleted.
-import { readFile, writeFile, copyFile, mkdir } from "node:fs/promises";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { claudeConfigDir } from "./claude-dir.mjs";
-import { readSettingsForWrite, writeFileAtomic } from "./installer.mjs";
+import { readSettingsForWrite, writeFileAtomic, installScript } from "./installer.mjs";
 
 const PKG_ROOT      = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
 const CLAUDE_DIR    = claudeConfigDir();
@@ -229,7 +229,10 @@ export async function setSoundHook(enabled) {
 
   if (enabled) {
     if (!existsSync(INSTALL_DIR)) await mkdir(INSTALL_DIR, { recursive: true });
-    await copyFile(join(PKG_ROOT, "hook", "notify.js"), NOTIFY_PATH);
+    // Same reason the event forwarder is installed this way: the Stop hook fires
+    // notify.js from sessions that are already running, and toggling the sound
+    // on must not leave one of them executing a half-copied file.
+    await installScript(join(PKG_ROOT, "hook", "notify.js"), NOTIFY_PATH);
     others.push({
       [MARK]: true,
       hooks: [{