agent-dag 1.33.62 → 1.33.64

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-DrFdTGt-.js"></script>
+    <script type="module" crossorigin src="/assets/index-B5DB7xOD.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.62",
+  "version": "1.33.64",
   "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/uv-bootstrap.mjs

@@ -80,21 +80,54 @@ async function download(url, { asText = false } = {}) {
 }
 
 /**
- * Unpack the artifact.
+ * A path as a PowerShell single-quoted string literal.
+ *
+ * Inside single quotes PowerShell expands nothing, so a doubled quote is both
+ * the only escape it has and the only one needed. Windows filenames cannot
+ * contain `"`, `<`, `>` or `|`, but they can contain an apostrophe — and the
+ * archive lands under os.tmpdir(), which on Windows is inside the user's own
+ * profile: C:\Users\O'Brien\AppData\Local\Temp. Pasted in raw, that apostrophe
+ * ended the string mid-path and Expand-Archive died of a syntax error, so uv
+ * could never be bootstrapped on an account whose owner has that name.
+ */
+const psQuote = (s) => `'${String(s).replace(/'/g, "''")}'`;
+
+/**
+ * The command that unpacks the artifact, as file + argv.
  *
  * `tar` is present on macOS, on Linux, and on Windows 10 1803 and later (as
  * bsdtar), but Windows ships .zip and older Windows has no tar at all — so zip
  * goes through PowerShell's Expand-Archive, which is always there.
+ *
+ * Exported, pure, and with the platform as a parameter, because the branch that
+ * needs checking is the one that never runs on the machine running the tests.
+ *
+ * Only the tar branch gets to pass its paths as arguments. `powershell.exe
+ * -Command` has no argument channel to pass them through — everything after
+ * -Command is joined back into the script text — so the paths are part of a
+ * PowerShell program either way, and quoting them for PowerShell is the whole
+ * job. Nothing else is quoting them on the way there: powershell.exe is an .exe,
+ * so exec.mjs spawns it directly with shell:false and the -Command string
+ * arrives as one intact argv entry, never seeing cmd.exe.
  */
-async function extract(archivePath, destDir) {
-  if (archivePath.endsWith(".zip")) {
-    const r = await run("powershell.exe", [
-      "-NoProfile", "-NonInteractive", "-Command",
-      `Expand-Archive -LiteralPath '${archivePath}' -DestinationPath '${destDir}' -Force`,
-    ], { timeout: 120_000 });
-    return r.ok;
+export function extractCommand(archivePath, destDir, platform = process.platform) {
+  if (platform === "win32" && archivePath.endsWith(".zip")) {
+    return {
+      file: "powershell.exe",
+      args: [
+        "-NoProfile", "-NonInteractive", "-Command",
+        `Expand-Archive -LiteralPath ${psQuote(archivePath)} ` +
+        `-DestinationPath ${psQuote(destDir)} -Force`,
+      ],
+    };
   }
-  const r = await run("tar", ["-xzf", archivePath, "-C", destDir], { timeout: 120_000 });
+  return { file: "tar", args: ["-xzf", archivePath, "-C", destDir] };
+}
+
+/** Unpack the artifact. */
+async function extract(archivePath, destDir) {
+  const { file, args } = extractCommand(archivePath, destDir);
+  const r = await run(file, args, { timeout: 120_000 });
   return r.ok;
 }