agent-dag 1.33.41 → 1.33.43

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-DNFdr9c6.js"></script>
+    <script type="module" crossorigin src="/assets/index-CkZD1gvK.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-CF2yG9oG.css">
   </head>
   <body>

package/hook/hook.js

@@ -11,16 +11,6 @@ const path = require("path");
 const http = require("http");
 const os = require("os");
 
-// Hard cap so a stuck server can never wedge the host CLI.
-setTimeout(() => process.exit(0), 1500);
-
-// The deck reads the Claude quota by running `claude --print /usage`, which is
-// a full Claude Code invocation and therefore fires these hooks. Reporting it
-// drew a session onto the canvas for every quota poll — no prompt, no tools,
-// a few seconds long — so the deck filled up with its own measurements. The
-// probe sets this in the environment and hooks inherit it.
-if (process.env.AGENTS_DECK_INTERNAL === "1") process.exit(0);
-
 // Single shared discovery dir — Claude Code and Codex CLI both register here
 // via the installer. Lets one running agent-dag server receive both providers.
 //
@@ -48,79 +38,144 @@ function normPath(p) {
   return r;
 }
 
+/**
+ * Does this platform's filesystem treat two spellings that differ only in case
+ * as the same directory? Exported for tests: the platform is a parameter so
+ * both answers can be checked from either kind of machine.
+ *
+ * Windows always does, and macOS does by default (APFS and HFS+ are formatted
+ * case-insensitive unless the user deliberately chose otherwise). Linux does
+ * not, and folding case there would be a bug of its own: /srv/Proj and
+ * /srv/proj are two real directories, and a deck scoped to one must not be
+ * handed the other's events.
+ *
+ * A case-sensitive macOS volume is therefore over-matched. That is the safe
+ * direction to be wrong in — the cost is a deck that also sees a sibling tree
+ * it was not scoped to, against the cost of the default configuration seeing
+ * nothing at all.
+ */
+const foldsCase = (platform = process.platform) =>
+  platform === "win32" || platform === "darwin";
+
+/**
+ * Is `cwd` the workspace directory or somewhere inside it?
+ *
+ * Both sides arrive already resolved, but resolved is not the same as
+ * comparable. Neither path.resolve nor the JS fs.realpathSync canonicalizes
+ * character case, so the drive letter and every component keep whatever case
+ * the process that reported them happened to use — `c:\proj` from one shell,
+ * `C:\Proj` from another, for one directory. A raw === / startsWith then says
+ * "not in the workspace", the hook posts to nobody, and a scoped deck stays
+ * empty with no error printed anywhere. Re-resolving through the platform's
+ * own path flavour also settles separators and a trailing one, so
+ * `C:/proj/` and `C:\proj` compare equal too.
+ *
+ * The platform is a parameter, following spawnSpec/isBatch in
+ * src/server/exec.mjs, so the Windows rule is testable from a POSIX machine.
+ */
+function cwdInWorkspace(cwd, workspace, platform = process.platform) {
+  const p = platform === "win32" ? path.win32 : path.posix;
+  const fold = s => (foldsCase(platform) ? s.toLowerCase() : s);
+  const a = fold(p.resolve(cwd));
+  const b = fold(p.resolve(workspace));
+  if (a === b) return true;
+  // A root ("C:\", "/") already ends in the separator; appending a second one
+  // would match nothing.
+  return a.startsWith(b.endsWith(p.sep) ? b : b + p.sep);
+}
+
 function isAlive(pid) {
   try { process.kill(pid, 0); return true; }
   catch (e) { return e && e.code === "EPERM"; }
 }
 
-let input = "";
-process.stdin.setEncoding("utf8");
-process.stdin.on("data", c => { input += c; });
-process.stdin.on("end", () => {
-  let parsed;
-  try { parsed = JSON.parse(input); } catch { return process.exit(0); }
-  const cwd = parsed && parsed.cwd;
-  if (!cwd) return process.exit(0);
-
-  // Stamp provider so the server / reducer can branch on it without
-  // re-sniffing payload shape.
-  if (parsed && typeof parsed === "object" && !parsed.provider) {
-    parsed.provider = PROVIDER;
-  }
-  const taggedInput = JSON.stringify(parsed);
-
-  const resolvedCwd = normPath(cwd);
-
-  let files;
-  try {
-    files = fs.readdirSync(DIR).filter(f => f.endsWith(".json"));
-  } catch { return process.exit(0); }
-  if (!files.length) return process.exit(0);
-
-  const matches = [];
-  for (const file of files) {
-    let d;
-    try { d = JSON.parse(fs.readFileSync(path.join(DIR, file), "utf8")); } catch { continue; }
-    if (typeof d.workspace !== "string" || !d.pid || !d.port) continue;
-
-    if (!isAlive(d.pid)) {
-      try { fs.unlinkSync(path.join(DIR, file)); } catch {}
-      continue;
+function main() {
+  // Hard cap so a stuck server can never wedge the host CLI.
+  setTimeout(() => process.exit(0), 1500);
+
+  // The deck reads the Claude quota by running `claude --print /usage`, which is
+  // a full Claude Code invocation and therefore fires these hooks. Reporting it
+  // drew a session onto the canvas for every quota poll — no prompt, no tools,
+  // a few seconds long — so the deck filled up with its own measurements. The
+  // probe sets this in the environment and hooks inherit it.
+  if (process.env.AGENTS_DECK_INTERNAL === "1") process.exit(0);
+
+  let input = "";
+  process.stdin.setEncoding("utf8");
+  process.stdin.on("data", c => { input += c; });
+  process.stdin.on("end", () => {
+    let parsed;
+    try { parsed = JSON.parse(input); } catch { return process.exit(0); }
+    const cwd = parsed && parsed.cwd;
+    if (!cwd) return process.exit(0);
+
+    // Stamp provider so the server / reducer can branch on it without
+    // re-sniffing payload shape.
+    if (parsed && typeof parsed === "object" && !parsed.provider) {
+      parsed.provider = PROVIDER;
     }
-
-    if (d.workspace === "") {
-      matches.push({ d, wsLen: 0 });
-      continue;
+    const taggedInput = JSON.stringify(parsed);
+
+    const resolvedCwd = normPath(cwd);
+
+    let files;
+    try {
+      files = fs.readdirSync(DIR).filter(f => f.endsWith(".json"));
+    } catch { return process.exit(0); }
+    if (!files.length) return process.exit(0);
+
+    const matches = [];
+    for (const file of files) {
+      let d;
+      try { d = JSON.parse(fs.readFileSync(path.join(DIR, file), "utf8")); } catch { continue; }
+      if (typeof d.workspace !== "string" || !d.pid || !d.port) continue;
+
+      if (!isAlive(d.pid)) {
+        try { fs.unlinkSync(path.join(DIR, file)); } catch {}
+        continue;
+      }
+
+      if (d.workspace === "") {
+        matches.push({ d, wsLen: 0 });
+        continue;
+      }
+      const ws = normPath(d.workspace);
+      if (cwdInWorkspace(resolvedCwd, ws)) {
+        matches.push({ d, wsLen: ws.length });
+      }
     }
-    const ws = normPath(d.workspace);
-    if (resolvedCwd === ws || resolvedCwd.startsWith(ws + path.sep)) {
-      matches.push({ d, wsLen: ws.length });
+
+    if (!matches.length) return process.exit(0);
+
+    matches.sort((a, b) => b.wsLen - a.wsLen);
+    const bestLen = matches[0].wsLen;
+    const targets = matches.filter(m => m.wsLen === bestLen);
+
+    let pending = targets.length;
+    const done = () => { if (--pending <= 0) process.exit(0); };
+
+    for (const { d } of targets) {
+      let settled = false;
+      const finish = () => { if (settled) return; settled = true; done(); };
+      const req = http.request({
+        hostname: "127.0.0.1",
+        port: d.port,
+        path: "/api/event",
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        timeout: 1000,
+      }, res => { res.resume(); res.on("end", finish); });
+      req.on("error", finish);
+      req.on("timeout", () => req.destroy());
+      req.write(taggedInput);
+      req.end();
     }
-  }
+  });
+}
 
-  if (!matches.length) return process.exit(0);
-
-  matches.sort((a, b) => b.wsLen - a.wsLen);
-  const bestLen = matches[0].wsLen;
-  const targets = matches.filter(m => m.wsLen === bestLen);
-
-  let pending = targets.length;
-  const done = () => { if (--pending <= 0) process.exit(0); };
-
-  for (const { d } of targets) {
-    let settled = false;
-    const finish = () => { if (settled) return; settled = true; done(); };
-    const req = http.request({
-      hostname: "127.0.0.1",
-      port: d.port,
-      path: "/api/event",
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      timeout: 1000,
-    }, res => { res.resume(); res.on("end", finish); });
-    req.on("error", finish);
-    req.on("timeout", () => req.destroy());
-    req.write(taggedInput);
-    req.end();
-  }
-});
+// The host CLI always runs this file as the process entry point — the command
+// the installer writes is `"<node>" "<...>/hook.js" --provider <name>`. Under a
+// require() it exports the matching rule and starts nothing, which is what lets
+// the rule be tested without a 1.5s exit timer in the test runner.
+module.exports = { cwdInWorkspace, foldsCase };
+if (require.main === module) main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-dag",
-  "version": "1.33.41",
+  "version": "1.33.43",
   "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/ccusage.mjs

@@ -15,6 +15,7 @@ import { spawn, spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import os from "node:os";
+import { spawnSpec } from "./exec.mjs";
 
 const CACHE_MS = 120_000; // 2 min — modal is manual-open; cheap to keep warm
 const TIMEOUT_MS = 90_000;
@@ -27,12 +28,26 @@ const MARKER = path.join(CACHE_DIR, ".last-update-check");
 
 const _cache = new Map(); // key `${since}|${until}` → { result, at }
 
-// npm is a .cmd shim on Windows, which spawn can only launch through a shell.
-// Everywhere else shell:false — with a shell, Node warns that arguments are
-// concatenated rather than escaped, and the warning lands in our startup
-// banner now that these run at boot.
-const NPM = process.platform === "win32" ? "npm.cmd" : "npm";
-const NPM_SHELL = process.platform === "win32";
+// npm is a .cmd shim on Windows, which spawn can only launch through cmd.exe.
+// `shell: true` is the tempting way to get there and the wrong one: Node then
+// joins file and args with single spaces and no quoting, so on a profile like
+// C:\Users\John Smith the `--prefix <CACHE_DIR>` below arrived as
+// `--prefix C:\Users\John` plus a bogus package spec `Smith\.agents-deck\...`,
+// npm exited non-zero, and the managed install never materialised. spawnSpec
+// routes the .cmd through cmd.exe with every argument quoted, and hands back
+// the argument vector untouched everywhere else.
+function npmSpec(args, platform = process.platform) {
+  return spawnSpec(platform === "win32" ? "npm.cmd" : "npm", args, platform);
+}
+
+/**
+ * What `spawn` gets for `npm install ccusage@<spec>`.
+ * Exported for tests: the platform is a parameter so the Windows command line
+ * can be checked from any OS.
+ */
+export const installSpec = (spec = "latest", platform = process.platform) =>
+  npmSpec(["install", `ccusage@${spec}`, "--prefix", CACHE_DIR,
+    "--no-save", "--no-audit", "--no-fund", "--loglevel", "error"], platform);
 
 let _installing = null;   // Promise guard so concurrent calls share one install
 let _checkedThisRun = false; // only kick the daily check once per process boot
@@ -68,11 +83,11 @@ function resolveEntry() {
 // the first-run cold path (we must have a binary before we can answer).
 function installSync(spec = "latest") {
   mkdirSync(CACHE_DIR, { recursive: true });
+  const { file, args, opts } = installSpec(spec);
   const r = spawnSync(
-    NPM,
-    ["install", `ccusage@${spec}`, "--prefix", CACHE_DIR,
-     "--no-save", "--no-audit", "--no-fund", "--loglevel", "error"],
-    { shell: NPM_SHELL, windowsHide: true, timeout: INSTALL_TIMEOUT_MS, encoding: "utf8" },
+    file,
+    args,
+    { windowsHide: true, timeout: INSTALL_TIMEOUT_MS, encoding: "utf8", ...opts },
   );
   if (r.status !== 0) {
     throw new Error(`npm install ccusage failed: ${(r.stderr || "").trim() || r.status}`);
@@ -83,11 +98,11 @@ function installSync(spec = "latest") {
 function installAsync(spec = "latest") {
   try {
     mkdirSync(CACHE_DIR, { recursive: true });
+    const { file, args, opts } = installSpec(spec);
     const child = spawn(
-      NPM,
-      ["install", `ccusage@${spec}`, "--prefix", CACHE_DIR,
-       "--no-save", "--no-audit", "--no-fund", "--loglevel", "error"],
-      { shell: NPM_SHELL, windowsHide: true, detached: false, stdio: "ignore" },
+      file,
+      args,
+      { windowsHide: true, detached: false, stdio: "ignore", ...opts },
     );
     child.on("error", () => {});
     child.unref?.();
@@ -118,8 +133,8 @@ function maybeBackgroundUpdate(installedVersion) {
   _checkedThisRun = true;
   touchMarker();
   try {
-    const child = spawn(NPM, ["view", "ccusage", "version"],
-      { shell: NPM_SHELL, windowsHide: true });
+    const { file, args, opts } = npmSpec(["view", "ccusage", "version"]);
+    const child = spawn(file, args, { windowsHide: true, ...opts });
     let out = "";
     child.stdout.on("data", d => { out += d; });
     child.on("error", () => {});