agent-dag 3.2.1 → 3.4.0

package/src/server/quota.mjs

@@ -35,6 +35,11 @@ import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { PRODUCT } from "./brand.mjs";
+// One ANSI stripper for the whole deck. The private copy that used to live
+// here accepted only the BEL terminator for an OSC sequence, while term.mjs's
+// also accepts ESC \\ — so a hyperlink written the other legal way survived
+// into text this module then parsed for quota lines.
+import { stripAnsi } from "./term.mjs";
 import { resetLabelIso } from "./reset-label.mjs";
 
 const USAGE_URL   = "https://api.anthropic.com/api/oauth/usage";
@@ -83,6 +88,73 @@ async function readOAuthToken() {
   }
 }
 
+/**
+ * Whether we may spend a request of the user's budget right now.
+ *
+ * Exported for tests — this is the rule that stopped the deck from starving
+ * claude-swap, and it is worth pinning down.
+ */
+export function maySelfPoll({ now, force, lastSelfPollAt, rateLimitedUntil }) {
+  if (now < rateLimitedUntil) return false;
+  return now - lastSelfPollAt >= (force ? FORCE_POLL_MS : SELF_POLL_MS);
+}
+
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+
+/**
+ * A cooldown from a `retry-after`, kept inside limits the deck can live with.
+ *
+ * Unclamped, the header decided the poller's fate in both directions: `0` (or a
+ * value the server rounds down to it) defeats the cooldown entirely and the
+ * next tick asks again immediately, which is the loop a 429 exists to stop; a
+ * large one — a day is a legal value — freezes the reader for the life of the
+ * process, and nothing here re-reads it. Both are the remote side deciding how
+ * this deck behaves, which a header is not entitled to do.
+ *
+ * The floor is the deck's own minimum backoff and the ceiling is an hour: long
+ * enough to be a real retreat, short enough that a quota panel is not dead for
+ * the rest of the day because one reply said so.
+ */
+export function cooldownFromHeader(raw, fallbackMs, minMs = 30_000, maxMs = 3600_000) {
+  const seconds = parseInt(String(raw ?? ""), 10);
+  if (!Number.isFinite(seconds)) return fallbackMs;
+  return Math.min(Math.max(seconds * 1000, minMs), maxMs);
+}
+
+/**
+ * WHETHER THIS MACHINE HAS A SUBSCRIPTION TO REPORT ON AT ALL.
+ *
+ * Every source here needs a Claude.ai OAuth credential: the claude-swap store
+ * holds one, `claudeAiOauth` in the credentials file is one, and
+ * `claude --print /usage` prints windows only for a session signed in with one.
+ * An API-key, Bedrock or Vertex install has none — and there is no quota to
+ * read, because those are billed per token rather than in five-hour windows.
+ *
+ * That mattered because of what the CLI does on such a machine: it RUNS, prints
+ * no quota lines, and the branch below used to read that as "genuine <1%" and
+ * publish `ok: true` with two zeroes. The panel then drew empty bars, which is
+ * a measurement nobody took. Codex already answers this properly, with
+ * `api_key_mode` as its own reason and its own sentence.
+ *
+ * Cheap and synchronous: environment first, because a machine configured for
+ * Bedrock or Vertex says so there, then the presence of the OAuth block in the
+ * credentials file. `readOAuthToken` above answers a different question — it
+ * also rejects an EXPIRED token, and an expired subscription is still a
+ * subscription.
+ */
+export async function hasSubscriptionCredential(env = process.env) {
+  if (env.CLAUDE_CODE_USE_BEDROCK === "1" || env.CLAUDE_CODE_USE_VERTEX === "1") return false;
+  try {
+    const raw = await readFile(credentialsPath(), "utf8");
+    if (JSON.parse(raw)?.claudeAiOauth?.accessToken) return true;
+  } catch { /* absent or unreadable, decided below */ }
+  // A key in the environment and no OAuth block beside it is the API-key
+  // install. Without either, this deck simply has not been signed in yet, and
+  // "sign in" is the right thing to say — which is the `waiting` branch, not
+  // this one.
+  return !(env.ANTHROPIC_API_KEY || env.ANTHROPIC_AUTH_TOKEN);
+}
+
 // ISO-8601 → "Jun 19, 1:19pm" (local time, matching the CLI display format).
 //
 // The body moved to reset-label.mjs in #374: codex-quota.mjs had a copy that
@@ -156,9 +228,7 @@ async function fetchOAuthUsage() {
     });
 
     if (res.status === 429) {
-      const retryAfter = parseInt(res.headers.get("retry-after") ?? "", 10);
-      const cooldownMs = Number.isFinite(retryAfter) ? retryAfter * 1000 : 5 * 60_000;
-      _rateLimitedUntil = Date.now() + cooldownMs;
+      _rateLimitedUntil = Date.now() + cooldownFromHeader(res.headers.get("retry-after"), 5 * 60_000);
       return null;
     }
     if (!res.ok) return null;
@@ -236,25 +306,6 @@ export function quotaFromStore(entry) {
   return out;
 }
 
-/**
- * Whether we may spend a request of the user's budget right now.
- *
- * Exported for tests — this is the rule that stopped the deck from starving
- * claude-swap, and it is worth pinning down.
- */
-export function maySelfPoll({ now, force, lastSelfPollAt, rateLimitedUntil }) {
-  if (now < rateLimitedUntil) return false;
-  return now - lastSelfPollAt >= (force ? FORCE_POLL_MS : SELF_POLL_MS);
-}
-
-const sleep = (ms) => new Promise(r => setTimeout(r, ms));
-
-function stripAnsi(s) {
-  return s
-    .replace(/\x1B\[[0-9;]*[A-Za-z]/g, "")
-    .replace(/\x1B\][^\x07]*\x07/g, "")
-    .replace(/\x1B[()][AB012]/g, "");
-}
 
 // Parse "Jun 18, 4:09pm" (local time, no tz) into unix seconds.
 // Claude shows times in the user's local timezone, so parsing as local is correct.
@@ -671,12 +722,23 @@ async function _doFetch(now, force = false, gen = _generation) {
     return publish(gen, { ..._lastGood, stale: true }, now - (CACHE_MS - 5_000));
   }
 
-  // Never had good data. CLI ran but lines absent → treat as genuine <1%.
-  // CLI failed entirely → ok:false. Either way short-cache for a quick retry.
-  const result = cliOk
+  // Never had good data. A CLI that RAN and printed no quota lines is two
+  // different machines, and they need two different answers:
+  //
+  //   * a subscription install on a cold invocation — the lines come back on a
+  //     later call, and until then "<1%" is the honest reading of a window that
+  //     has genuinely just reset;
+  //   * an API-key, Bedrock or Vertex install, which has no windows at all.
+  //     Publishing two zeroes there drew empty bars for a measurement nobody
+  //     took, on a machine where no amount of retrying will ever produce one.
+  //
+  // A CLI that failed entirely is `ok: false` as it always was, and the reason
+  // says which of the two the reader is looking at.
+  const subscribed = cliOk ? await hasSubscriptionCredential() : false;
+  const result = cliOk && subscribed
     ? { ok: true, session5hPct: 0, session5hWindowSec: 18000,
         week7dPct: 0, week7dWindowSec: 604800, fetchedAt: now }
-    : { ok: false, fetchedAt: now };
+    : { ok: false, reason: cliOk ? "no_subscription" : "cli_failed", fetchedAt: now };
   return publish(gen, result, now - (CACHE_MS - 5_000));
 }
 

package/src/server/retire-sound-hook.mjs

@@ -94,10 +94,44 @@ const PARKED_PATH = join(homedir(), ".agents-deck", "parked-sound-hooks.json");
 const commandsOf = (entry) =>
   (entry?.hooks ?? []).map(h => (typeof h?.command === "string" ? h.command : ""));
 
+/**
+ * THE TAIL, NOT THE WHOLE PATH — and this is a data-loss fix, not a tidy-up.
+ *
+ * The stored command was written by `shellQuoteArg`, whose POSIX branch
+ * single-quotes the argument and rewrites every `'` as `'\''`. So on a config
+ * dir like `/mnt/Bob's SSD/claude` the command contains `Bob'\''s` and a
+ * `cmd.includes(NOTIFY_PATH)` against the raw path is false — on macOS and
+ * Linux, for a perfectly ordinary directory name.
+ *
+ * What follows is unrecoverable. A mark-less `Stop` entry — the case this
+ * module exists for — is then not recognised as ours, so it is kept; and
+ * `anythingStillNamesOurScripts`, which has no mark to fall back on, also says
+ * no, so the sweep deletes `notify.mjs`. Claude Code throws
+ * `Cannot find module` at the end of every turn afterwards, forever, with the
+ * deck already uninstalled.
+ *
+ * The last two segments are fixed whatever the prefix is — the install
+ * directory is always `<config dir>/agent-dag` — and they contain no character
+ * any quoting rewrites. Case is folded where the filesystem folds it, which is
+ * the other half: `exec.mjs`'s own `sameCommand` lowercases "because Windows
+ * paths are", and this comparison did not.
+ */
+const SCRIPT_TAILS = ["agent-dag/notify.mjs", "agent-dag/notify.js"];
+
+export function namesOurScript(cmd, platform = process.platform) {
+  if (typeof cmd !== "string" || cmd === "") return false;
+  // Backslashes become separators only where they ARE separators. On POSIX a
+  // backslash is an ordinary filename character, and rewriting it there could
+  // invent a match that the filesystem does not have.
+  let hay = platform === "win32" ? cmd.replace(/\\/g, "/") : cmd;
+  if (platform === "win32" || platform === "darwin") hay = hay.toLowerCase();
+  return SCRIPT_TAILS.some(tail => hay.includes(tail));
+}
+
 /** An entry this deck put there: by its mark, or by the script it runs. */
 function isOurs(entry) {
   if (entry?.[MARK] === true) return true;
-  return commandsOf(entry).some(cmd => OUR_SCRIPTS.some(p => cmd.includes(p)));
+  return commandsOf(entry).some(cmd => namesOurScript(cmd));
 }
 
 /** Anywhere in the file — not just `Stop` — that still runs one of our scripts.
@@ -109,7 +143,7 @@ function anythingStillNamesOurScripts(settings) {
   for (const group of Object.values(groups)) {
     if (!Array.isArray(group)) continue;
     for (const entry of group) {
-      if (commandsOf(entry).some(cmd => OUR_SCRIPTS.some(p => cmd.includes(p)))) return true;
+      if (commandsOf(entry).some(cmd => namesOurScript(cmd))) return true;
     }
   }
   return false;

package/src/server/self-update.mjs

@@ -1069,12 +1069,19 @@ function sweepOrphanedNotes(keep) {
   }
 }
 
-// Signal 0 delivers nothing; it only asks whether the pid could be signalled.
-// EPERM is someone else's process answering, which is still a process — the
-// same test sweepStaleDiscovery makes of the discovery files.
+// Signal 0 delivers nothing; it asks whether the pid could be signalled.
+//
+// BOTH ERRNOS, and the second one is the Windows spelling. POSIX `kill(2)`
+// answers EPERM for a process this account may not signal. On Windows
+// `uv_kill` calls `OpenProcess`, a denial is ERROR_ACCESS_DENIED, and libuv
+// maps that to EACCES — so a deck started from an elevated terminal, or under
+// another account, read as DEAD to every probe in this repo. What followed was
+// silent: the live deck's discovery file was unlinked on the next hook fire,
+// rewritten five seconds later by keepDiscovery, and its banner went on
+// claiming it was receiving events it had stopped receiving.
 function processAlive(pid) {
   try { process.kill(pid, 0); return true; }
-  catch (e) { return e?.code === "EPERM"; }
+  catch (e) { return e?.code === "EPERM" || e?.code === "EACCES"; }
 }
 
 /**
@@ -1198,7 +1205,12 @@ export function startUpgrade({ pkgRoot, name = "agents-deck" }) {
       // installedVersion() disagree with the running one, and the ordinary
       // drift path takes it from there — including its wait for an idle moment.
       _upgrade = { state: "done", command, error: null, at: Date.now() };
-    } else if (!timedOut) {
+    } else if (!timedOut && _upgrade?.state !== "failed") {
+      // Not over a failure the 'error' handler already explained. A missing npm
+      // emits 'error' with ENOENT and THEN 'close' with a null code, and this
+      // branch used to replace "spawn npm ENOENT" with "npm exited -2" — the
+      // one message that says what is wrong, overwritten by the one that does
+      // not.
       _upgrade = { state: "failed", command, error: lastMeaningfulLine(err) || `npm exited ${code}`, at: Date.now() };
     }
   });

package/src/server/system-metrics.mjs

@@ -182,10 +182,29 @@ const C_LOCALE = { LC_ALL: "", LC_NUMERIC: "C" };
 function run(file, args, timeoutMs = 2_000) {
   return new Promise(resolve => {
     let child;
-    try { child = spawn(file, args, { windowsHide: true, env: { ...process.env, ...C_LOCALE } }); }
+    try {
+      child = spawn(file, args, {
+        windowsHide: true,
+        env: { ...process.env, ...C_LOCALE },
+        // stderr is PIPED AND NEVER READ, which is a deadlock waiting for a
+        // chatty child: a pipe nobody drains fills at 64 KB and the writer
+        // blocks there until this function's own deadline kills it. Nothing
+        // here has ever looked at it — `run` resolves on stdout or null — so
+        // the honest arrangement is not to open it.
+        stdio: ["ignore", "pipe", "ignore"],
+      });
+    }
     catch { return resolve(null); }
     let out = "";
     const timer = setTimeout(() => { try { child.kill(); } catch {} resolve(null); }, timeoutMs);
+    // DECODE THE STREAM, NOT EACH CHUNK. `out += d` on a Buffer calls toString()
+    // per chunk, and a chunk boundary falls wherever the pipe happened to break
+    // — measured on `ps` output as three chunks of 8192/8192/5718 — so a
+    // multi-byte character split across two of them became two replacement
+    // characters. An application called `Яндекс Музыка` in the process list
+    // rendered as `Ян��екс Музыка`. setEncoding carries the partial sequence
+    // across the boundary, which is the whole reason it exists.
+    child.stdout?.setEncoding?.("utf8");
     child.stdout?.on("data", d => { out += d; });
     child.on("error", () => { clearTimeout(timer); resolve(null); });
     child.on("close", code => { clearTimeout(timer); resolve(code === 0 ? out : null); });
@@ -599,7 +618,14 @@ async function readProcessesNow(platform) {
       "-NoProfile", "-NonInteractive", "-Command",
       "Get-Process | Select-Object Id,ProcessName,CPU,@{n='WorkingSetPrivate';e={$_.PrivateMemorySize64}} | ConvertTo-Json -Compress",
     ], 6_000);
-    if (!out) return [];
+    // The same shape the POSIX branch below returns, and not a bare array: the
+    // caller reads `read.procs.length` to decide whether this was a real
+    // reading, so an array meant a TypeError rather than an empty list. Every
+    // Windows failure — a non-zero exit, a spawn that never started, the 6s
+    // deadline this module's own comment says the runtime sits right on —
+    // therefore answered `/api/system/processes` with a 500 and a logged stack,
+    // every four seconds for as long as the machine panel was open.
+    if (!out) return { procs: [], total: 0 };
     const rows = parseGetProcessJson(out.trim(), os.totalmem());
     const now = Date.now();
     const ranked = cpuFromDeltas(rows, prevProcCpu, now - prevProcAt);
@@ -988,40 +1014,6 @@ export function zoneLabel(raw) {
   return name || "Thermal zone";
 }
 
-/**
- * Windows thermal zones out of MSAcpi_ThermalZoneTemperature.
- *
- * The SECOND source, and only reachable by a deck that happens to be elevated:
- * root\\wmi requires administrator and refuses an ordinary terminal outright.
- * Kept because some boards publish a zone to ACPI and no counter, and because a
- * deck launched from an elevated shell can read it.
- *
- * CurrentTemperature is in tenths of a Kelvin, the same unit as the counter
- * above, and reading it as anything else gives a number that is
- * plausible-looking and wrong.
- *
- * The zone is labelled "Thermal zone" when there is one and by its own name
- * when there are several, because ACPI does not say which zone is the CPU and
- * this module does not guess. `TZ00` is not a friendly label; it is an honest
- * one, and it only appears on a machine that has more than one.
- */
-export function tempFromMsAcpiJson(json) {
-  let rows;
-  try { rows = typeof json === "string" ? JSON.parse(json) : json; }
-  catch { return []; }
-  if (!rows) return [];
-  if (!Array.isArray(rows)) rows = [rows];
-  const found = [];
-  for (const r of rows) {
-    const k = Number(r?.CurrentTemperature);
-    if (!Number.isFinite(k)) continue;
-    const celsius = Math.round(k / 10 - 273.15);
-    if (!plausible(celsius)) continue;
-    found.push({ label: zoneLabel(r?.InstanceName), celsius, warnAt: WARN_C, critAt: CRIT_C });
-  }
-  if (found.length === 1) found[0].label = "Thermal zone";
-  return found.slice(0, 2);
-}
 
 /**
  * The macOS rows, from whatever the three sources answered.

package/src/server/uv-bootstrap.mjs

@@ -46,16 +46,52 @@ const DOWNLOAD_TIMEOUT_MS = 120_000;
  * Rosetta is deliberately not special-cased: an x64 Node on Apple Silicon
  * reports x64 and gets the x64 build, which runs.
  */
-export function assetName(platform = process.platform, arch = process.arch) {
-  const a = { x64: "x86_64", arm64: "aarch64", ia32: "i686" }[arch];
+export function assetName(platform = process.platform, arch = process.arch, libc = detectLibc(platform)) {
+  // `arm` is 32-bit ARM — a Raspberry Pi on the armhf image, which uv publishes
+  // as armv7. Left out, that machine got `unsupported_platform` for a target
+  // that exists.
+  const a = { x64: "x86_64", arm64: "aarch64", ia32: "i686", arm: "armv7" }[arch];
   if (!a) return null;
   // Apple publishes no i686 build, and never will.
   if (platform === "darwin") return a === "i686" ? null : `uv-${a}-apple-darwin.tar.gz`;
   if (platform === "win32")  return `uv-${a}-pc-windows-msvc.zip`;
-  if (platform === "linux")  return `uv-${a}-unknown-linux-gnu.tar.gz`;
+  if (platform === "linux") {
+    // MUSL IS ITS OWN TARGET, and asking for the gnu build on Alpine is not a
+    // degraded install, it is an endless one: the glibc ELF interpreter is
+    // absent, so the downloaded binary cannot start, `bootstrapUv` returns
+    // `does_not_run`, and because ensureCswap runs whenever cswapVersion() is
+    // null the 35 MB archive is fetched, hashed and extracted again on EVERY
+    // launch — with the accounts panel permanently unavailable. `node:alpine`
+    // is a common enough base image for this to be somebody's whole experience
+    // of the deck.
+    if (libc === "musl") return `uv-${a}-unknown-linux-musl.tar.gz`;
+    return `uv-${a}-unknown-linux-gnu.tar.gz`;
+  }
   return null;
 }
 
+/**
+ * "glibc" or "musl" for this process.
+ *
+ * Node's own report names the glibc it is linked against, and a musl build has
+ * no such field — which is the check every native-addon loader uses, and needs
+ * no child process. Anything unexpected reads as glibc, because that is the
+ * overwhelmingly common case and the wrong guess there is the state this code
+ * was already in.
+ */
+export function detectLibc(platform = process.platform, report = () => process.report?.getReport?.()) {
+  // The question only exists on Linux. macOS and Windows have no glibc field
+  // either, so asking there and reading the absence as musl would answer "musl"
+  // for every Mac — which is why the platform comes first.
+  if (platform !== "linux") return "glibc";
+  try {
+    const header = report()?.header;
+    if (!header) return "glibc";
+    if (typeof header.glibcVersionRuntime === "string") return "glibc";
+    return "musl";
+  } catch { return "glibc"; }
+}
+
 /** Path to a uv this function installed earlier, or null. */
 export function existingBootstrappedUv() {
   const bin = join(UV_DIR, process.platform === "win32" ? "uv.exe" : "uv");