agent-dag 3.2.0 → 3.3.0

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");