agent-dag 1.33.43 → 1.33.45

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-CkZD1gvK.js"></script>
+    <script type="module" crossorigin src="/assets/index-BnOcuI0t.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.43",
+  "version": "1.33.45",
   "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/quota.mjs

@@ -19,8 +19,8 @@
 //      notably on macOS, where Claude Code keeps credentials in the Keychain
 //      and that file does not exist, so this is the ONLY self-service path
 //      there. It is also the most expensive: a whole Claude Code process per
-//      poll. On Windows the binary is a .cmd wrapper, so exec() (shell-based)
-//      is used for correct quoting + stdin.
+//      poll. On Windows the binary may be a .cmd wrapper, so exec()
+//      (shell-based) is used for correct quoting + stdin.
 //
 // 2 and 3 are rate-floored (SELF_POLL_MS) and gated behind the same 429
 // cooldown; 1 is not, because it is a local file read.
@@ -29,11 +29,10 @@ import { exec } from "node:child_process";
 import { promisify } from "node:util";
 import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { homedir, platform } from "node:os";
+import { join, posix as posixPath, win32 as winPath } from "node:path";
+import { homedir } from "node:os";
 
 const execAsync = promisify(exec);
-const IS_WIN = platform() === "win32";
 
 const CREDS_PATH  = join(homedir(), ".claude", ".credentials.json");
 const USAGE_URL   = "https://api.anthropic.com/api/oauth/usage";
@@ -298,31 +297,65 @@ function parseUsageText(raw) {
   return Object.keys(result).length > 0 ? result : null;
 }
 
+/**
+ * Every place the `claude` CLI is known to live, in the order to try them.
+ *
+ * Pure, and the platform, environment and home directory are parameters, so the
+ * Windows list can be checked from a Mac — which is the only way this list stays
+ * right, since it exists entirely for machines the author is not sitting at.
+ */
+export function quotaClaudeCandidates(platform = process.platform, env = process.env, home = homedir()) {
+  // The path flavour follows the PLATFORM ARGUMENT, not the host: node's `join`
+  // would emit forward slashes when the Windows list is built on a Mac.
+  const { join } = platform === "win32" ? winPath : posixPath;
+  if (platform !== "win32") {
+    return [
+      "claude",
+      join(home, ".local", "bin", "claude"),
+      "/usr/local/bin/claude",
+      "/opt/homebrew/bin/claude",
+    ];
+  }
+  return [
+    // The native installer, which ships a bare claude.exe and NO .cmd shim. It
+    // was the one install this branch could not reach: the npm path below does
+    // not exist on such a machine, and the bare-name fallback used to be spelled
+    // `claude.cmd`, which cmd.exe cannot resolve to an .exe — PATHEXT supplies a
+    // missing extension, it never substitutes one that is already there.
+    join(home, ".local", "bin", "claude.exe"),
+    // `npm i -g @anthropic-ai/claude-code`. npm's global prefix is %APPDATA%\npm
+    // — Roaming rather than Local, deliberately, since it follows the user
+    // between machines — and APPDATA is read from the environment because a
+    // roaming profile puts it on a network share, not under the home directory.
+    join(env.APPDATA || join(home, "AppData", "Roaming"), "npm", "claude.cmd"),
+    // Last resort: the bare name, which cmd.exe resolves through PATH + PATHEXT
+    // and so finds claude.exe and claude.cmd alike.
+    "claude",
+  ];
+}
+
 /** Build the shell command string for `claude --print /usage`.
  *
  *  We use exec() (shell-based) so cmd.exe / sh processes redirects.
  *  On Windows: `< nul` closes stdin immediately, preventing the 3-second
  *  "no stdin data" wait the claude CLI does when it detects a pipe.
  *  On Unix: `< /dev/null` has the same effect.
+ *
+ *  Exported, with everything it touches injectable, so the Windows branch is
+ *  testable from the platforms this repo is actually developed on.
  */
-function buildQuotaShellCmd() {
-  if (IS_WIN) {
-    const npmBin = join(homedir(), "AppData", "Roaming", "npm", "claude.cmd");
-    const bin = existsSync(npmBin) ? npmBin : "claude.cmd";
-    // exec() on Windows uses cmd /c, so < nul redirect works fine.
-    // Wrap path in quotes in case of spaces in username.
-    return `"${bin}" --print /usage < nul`;
-  }
-  const candidates = [
-    "claude",
-    join(homedir(), ".local", "bin", "claude"),
-    "/usr/local/bin/claude",
-    "/opt/homebrew/bin/claude",
-  ];
-  for (const c of candidates) {
-    if (!c.includes("/") || existsSync(c)) return `${c} --print /usage < /dev/null`;
-  }
-  return "claude --print /usage < /dev/null";
+export function buildQuotaShellCmd(platform = process.platform, env = process.env,
+                                   home = homedir(), exists = existsSync) {
+  const win = platform === "win32";
+  const sep = win ? "\\" : "/";
+  // A bare name is left to the shell's own lookup; a full path is only worth
+  // naming when it is actually there.
+  const bin = quotaClaudeCandidates(platform, env, home)
+    .find(c => !c.includes(sep) || exists(c)) ?? "claude";
+  // Quote a path — a username can contain a space — but not a bare name, which
+  // cmd.exe resolves more predictably unquoted.
+  const quoted = bin.includes(sep) ? `"${bin}"` : bin;
+  return `${quoted} --print /usage < ${win ? "nul" : "/dev/null"}`;
 }
 
 export async function fetchClaudeQuota({ force = false } = {}) {

package/src/server/self-update.mjs

@@ -36,6 +36,13 @@ import { dirname, join, resolve } from "node:path";
 // is the case where it bites hardest, since npx runs are short-lived and each
 // one inherits the same stale marker. The request is ~20 bytes.
 const CHECK_MS = 3600_000;
+// A lookup that failed is not an answer, so it must not spend the hour an
+// answer buys. It still has to spend something: the reason to rate-limit is
+// gone, but a registry that is down would otherwise be asked again on every
+// single poll. Five minutes is the compromise — short enough that a network
+// coming back is noticed while the user is still looking at the deck, long
+// enough that a full npm outage costs a dozen ~20-byte requests an hour.
+const RETRY_MS = 300_000;
 const FETCH_TIMEOUT_MS = 6_000;
 // A third marker path: ccusage owns ~/.agents-deck/ccusage/.last-update-check
 // and cswap owns ~/.agents-deck/.cswap-update-check. Sharing one would make the
@@ -158,38 +165,66 @@ export function upgradeCommand(pkgRoot, name = "agents-deck") {
 
 // The dist-tags endpoint answers with ~20 bytes ({"latest":"1.30.7"}); the full
 // packument is >2 KB and needs parsing we have no use for.
+//
+// Answers `{ ok, version }` rather than a bare string, because "npm says the
+// latest is X" and "npm did not answer" used to arrive here as the same null.
+// `ok` is true only when the registry handed back a usable version — a
+// timeout, a non-200 and a 200 with no `latest` in it are all failures, and
+// the caller has to be able to tell them from an up-to-date deck.
 async function fetchLatest(name) {
   try {
     const res = await fetch(`https://registry.npmjs.org/-/package/${name}/dist-tags`, {
       headers: { accept: "application/json", "user-agent": "agents-deck" },
       signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
     });
-    if (!res.ok) return null;
+    if (!res.ok) return { ok: false, version: null };
     const v = (await res.json())?.latest;
-    return typeof v === "string" ? v : null;
+    return typeof v === "string" ? { ok: true, version: v } : { ok: false, version: null };
   } catch {
-    return null;
+    return { ok: false, version: null };
   }
 }
 
 // The marker carries the answer, not just the timestamp. The existing markers
 // store only an mtime, which means a restart inside the 24h window forgets what
 // npm said and shows nothing until the window expires.
+//
+// It carries the outcome too. `at` is when npm last ANSWERED and `version` is
+// what it said; `failedAt` is when the last attempt failed, and is null the
+// moment one succeeds. Keeping them apart is what lets the deck say "checked
+// 3m ago" and "could not reach npm" as the different things they are, instead
+// of reporting a timeout as a fresh, up-to-date check.
 function readMarker() {
   try {
     const m = JSON.parse(readFileSync(MARKER, "utf8"));
-    return typeof m?.at === "number" ? m : null;
+    // Either half is enough to be worth keeping: a marker written by a first
+    // attempt that failed has no `at` yet, and markers written before
+    // `failedAt` existed have no `failedAt` at all.
+    return (typeof m?.at === "number" || typeof m?.failedAt === "number") ? m : null;
   } catch {
     return null;
   }
 }
-function writeMarker(at, version) {
+function writeMarker(marker) {
   try {
     mkdirSync(dirname(MARKER), { recursive: true });
-    writeFileSync(MARKER, JSON.stringify({ at, version: version ?? null }));
+    writeFileSync(MARKER, JSON.stringify(marker));
   } catch { /* a read-only home must not break the deck */ }
 }
 
+/** What the marker should hold after an attempt. Pure, because "a failed
+ *  lookup must not be recorded as a successful one" is precisely the rule this
+ *  file used to get wrong, and a rule worth a bug is worth a test.
+ *
+ *  A success stamps the hour and clears the failure. A failure records only
+ *  itself, leaving the last real answer and the time it arrived untouched —
+ *  the deck keeps showing what it knew, and stops claiming it just confirmed
+ *  it. */
+export function nextMarker({ prev, now, ok, version }) {
+  if (ok) return { at: now, version: version ?? null, failedAt: null };
+  return { at: prev?.at ?? null, version: prev?.version ?? null, failedAt: now };
+}
+
 // The marker is shared by every deck on the machine, so one deck's check
 // silences the others for the rest of the window. Asking once per PROCESS fixes
 // that, and it lands the check exactly where the user expects the truth: a
@@ -201,8 +236,16 @@ let _askedThisProcess = false;
  * banner appear" is the question this feature gets asked, and the rule behind
  * it should be readable in one place.
  */
-export function checkDue({ at, now, first = false, force = false, ttlMs = CHECK_MS }) {
+export function checkDue({ at, failedAt, now, first = false, force = false, ttlMs = CHECK_MS, retryMs = RETRY_MS }) {
   if (force || first) return true;      // explicit ask, or this process's first
+  // The last attempt failed, so there is nothing to reuse and the long window
+  // does not apply — but the short one does, or an unreachable registry turns
+  // every poll into another request. Answered first: `at` here is the older,
+  // successful check, and letting it decide would ask again immediately.
+  if (typeof failedAt === "number") {
+    if (failedAt > now) return true;    // clock moved; do not wait it out
+    return now - failedAt >= retryMs;
+  }
   if (typeof at !== "number") return true;  // never checked
   if (at > now) return true;            // marker from the future: a moved clock
   return now - at >= ttlMs;
@@ -217,13 +260,16 @@ async function latestOnNpm(name, now, force = false) {
   const m = readMarker();
   const first = !_askedThisProcess;
   _askedThisProcess = true;
-  if (!checkDue({ at: m?.at, now, first, force })) return m?.version ?? null;
+  if (!checkDue({ at: m?.at, failedAt: m?.failedAt, now, first, force })) return m?.version ?? null;
   if (_inflight) return _inflight;
   _inflight = fetchLatest(name)
-    // Stamp before deciding what to keep: a failed lookup must burn the day's
-    // slot rather than retry on every poll, but it must not erase a version we
-    // already knew.
-    .then(v => { writeMarker(now, v ?? m?.version ?? null); return v ?? m?.version ?? null; })
+    // Record the outcome, not just the moment. Only an answer stamps `at`; a
+    // failure takes the short retry window instead of the hour, and keeps the
+    // version we already knew rather than erasing it.
+    .then(({ ok, version }) => {
+      writeMarker(nextMarker({ prev: m, now, ok, version }));
+      return (ok ? version : null) ?? m?.version ?? null;
+    })
     .catch(() => m?.version ?? null)
     .finally(() => { _inflight = null; });
   return _inflight;
@@ -398,15 +444,22 @@ export async function versionReport({ running, pkgRoot, name = "agents-deck", no
     process.env.AGENTS_DECK_NO_UPDATE_CHECK === "1" ||
     process.env.AGENTS_DECK_NO_INSTALL === "1";
   const latest = skipRegistry ? null : await latestOnNpm(name, now, force);
+  const marker = skipRegistry ? null : readMarker();
   const blocked = upgradeBlock(pkgRoot);
   return {
     name,
     running: running ?? null,
     installed,
     latest,
-    // When npm was last asked, so the UI can say it rather than leaving the
-    // user to wonder whether the check runs at all.
-    checkedAt: skipRegistry ? null : (readMarker()?.at ?? null),
+    // When npm last ANSWERED, so the UI can say it rather than leaving the
+    // user to wonder whether the check runs at all. A lookup that failed does
+    // not move this: "checked 2 minutes ago" over an hour-old answer is the
+    // one thing this field must never say.
+    checkedAt: marker?.at ?? null,
+    // …and when it last failed, null once one succeeds. Without it, the single
+    // most common reason for a missing update button — a proxy, a flaky line,
+    // an offline machine — is indistinguishable from being up to date.
+    checkFailedAt: marker?.failedAt ?? null,
     checkDisabled: skipRegistry,
     notice: pickNotice({ running, installed, latest }),
     command: upgradeCommand(pkgRoot, name),