npm - agent-dag - Versions diffs - 1.35.43 → 1.36.0 - Mend

agent-dag 1.35.43 → 1.36.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/dist/web/assets/index-CaAP5Ufx.css +1 -0
package/dist/web/assets/index-OvdPf_n3.js +78 -0
package/dist/web/index.html +2 -2
package/package.json +1 -1
package/src/server/index.mjs +6 -1
package/src/server/system-metrics.mjs +187 -0
package/dist/web/assets/index-CbEDZOIk.js +0 -78
package/dist/web/assets/index-rOAqrum-.css +0 -1

package/dist/web/index.html CHANGED Viewed

@@ -40,8 +40,8 @@
         document.documentElement.setAttribute("data-theme", stored === "light" ? "light" : "dark");
       })();
     </script>
-    <script type="module" crossorigin src="/assets/index-CbEDZOIk.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-rOAqrum-.css">
+    <script type="module" crossorigin src="/assets/index-OvdPf_n3.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-CaAP5Ufx.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "agent-dag",
-  "version": "1.35.43",
+  "version": "1.36.0",
   "description": "Live deck of Claude Code and Codex agents — watch tool calls, token spend and every Claude Code subagent on one calm canvas. Also available as npx ccdeck and npx agent-dag.",
   "type": "module",
   "bin": {

package/src/server/index.mjs CHANGED Viewed

@@ -14,7 +14,7 @@ import { CODEX_HOME, CODEX_SESSIONS_DIR, STOP, walkRolloutDays } from "./codex-d
 import { PRODUCT } from "./brand.mjs";
 import { invokedName, renameNotice } from "./invoked-as.mjs";
 import { appendLogLine, codexCwdInWorkspace, writesCodexLog } from "./log-writer.mjs";
-import { startSystemMetrics, systemSnapshot } from "./system-metrics.mjs";
+import { readProcesses, startSystemMetrics, systemSnapshot } from "./system-metrics.mjs";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PKG_ROOT = resolve(__dirname, "..", "..");
@@ -3054,6 +3054,11 @@ export async function startServer({ port = 4317, host = "127.0.0.1", persist = n
     // Machine state, not session state: sampled on the server's own timer and
     // deliberately kept out of the event stream. See src/server/system-metrics.mjs.
     if (req.method === "GET"  && url.pathname === "/api/system")       return send(res, 200, systemSnapshot());
+    // On demand only — the process list costs a subprocess on every platform,
+    // so it is fetched while the detail panel is open and never on the timer.
+    if (req.method === "GET"  && url.pathname === "/api/system/processes") {
+      return guard(readProcesses().then(procs => send(res, 200, { ok: true, procs })), res);
+    }
     if (req.method === "GET"  && url.pathname === "/api/codex-quota") return guard(handleCodexQuota(req, res), res);
     if (req.method === "GET"  && url.pathname === "/api/ccusage")     return guard(handleCcusage(req, res), res);
     if (req.method === "GET"  && url.pathname === "/api/claude-accounts") return guard(handleClaudeAccounts(req, res), res);

package/src/server/system-metrics.mjs CHANGED Viewed

@@ -33,6 +33,9 @@ const HISTORY = 20;
 let cpuTimer = null;
 let memTimer = null;
 let prevTicks = null;
+let prevCoreTicks = null;
+let cores = null;
+let swap = null;
 /** Newest last. Seeded empty; the first tick produces no percentage because a
  *  delta needs two readings. */
 const cpuHistory = [];
@@ -52,6 +55,40 @@ function readTicks() {
   return { idle, total };
 }
+/** The same pair, per core, in `os.cpus()` order. */
+function readCoreTicks() {
+  return os.cpus().map(cpu => {
+    let idle = 0;
+    let total = 0;
+    for (const [kind, ms] of Object.entries(cpu.times)) {
+      total += ms;
+      if (kind === "idle") idle += ms;
+    }
+    return { idle, total };
+  });
+}
+/**
+ * Busy percentage per core since the previous reading.
+ *
+ * The aggregate figure the topbar draws hides the shape of the load, and the
+ * shape is what tells a saturated machine from a machine running one hot
+ * single-threaded job. Same delta arithmetic as `cpuPercent`, one row per core,
+ * and the same refusal to invent a number before there are two readings.
+ */
+function corePercents() {
+  const now = readCoreTicks();
+  const prev = prevCoreTicks;
+  prevCoreTicks = now;
+  if (!prev || prev.length !== now.length) return null;
+  return now.map((c, i) => {
+    const dTotal = c.total - prev[i].total;
+    const dIdle = c.idle - prev[i].idle;
+    if (dTotal <= 0) return 0;
+    return Math.max(0, Math.min(100, Math.round((1 - dIdle / dTotal) * 1000) / 10));
+  });
+}
 /**
  * Busy percentage across all cores since the previous reading, 0-100.
  *
@@ -160,6 +197,143 @@ async function readAvailable(platform = process.platform) {
   return os.freemem();
 }
+/**
+ * Swap out of macOS `sysctl -n vm.swapusage`, which prints
+ * `total = 14336.00M  used = 12876.00M  free = 1460.00M  (encrypted)`.
+ *
+ * Swap is the reading a percentage cannot give you. A machine at "64% memory
+ * used" that is quietly paging 12 GB to disk is not the same machine as one at
+ * 64% with an empty swap file, and the difference is the one you can feel.
+ */
+export function swapFromSysctl(text) {
+  const unit = s => {
+    const m = /^([\d.]+)([KMG])?$/i.exec(s);
+    if (!m) return null;
+    const mult = { k: 1024, m: 1024 ** 2, g: 1024 ** 3 }[(m[2] || "M").toLowerCase()] ?? 1;
+    return Math.round(Number(m[1]) * mult);
+  };
+  const total = unit(/total\s*=\s*(\S+)/i.exec(String(text ?? ""))?.[1] ?? "");
+  const used = unit(/used\s*=\s*(\S+)/i.exec(String(text ?? ""))?.[1] ?? "");
+  if (total == null || used == null) return null;
+  return { total, used };
+}
+/** Swap out of `/proc/meminfo`, where it is two fields rather than one line. */
+export function swapFromMeminfo(text) {
+  const s = String(text ?? "");
+  const total = /^SwapTotal:\s+(\d+)\s*kB/m.exec(s);
+  const free = /^SwapFree:\s+(\d+)\s*kB/m.exec(s);
+  if (!total || !free) return null;
+  const t = Number(total[1]) * 1024;
+  return { total: t, used: Math.max(0, t - Number(free[1]) * 1024) };
+}
+/**
+ * Windows has no swap file in the Unix sense; the comparable pressure signal is
+ * commit charge, which `Win32_OperatingSystem` reports as total and free
+ * virtual memory in KB. Labelled "commit" in the UI rather than "swap", because
+ * calling it swap would be borrowing a word for a different mechanism.
+ */
+export function swapFromWmicJson(json) {
+  try {
+    const o = typeof json === "string" ? JSON.parse(json) : json;
+    const total = Number(o?.TotalVirtualMemorySize) * 1024;
+    const free = Number(o?.FreeVirtualMemory) * 1024;
+    if (!Number.isFinite(total) || !Number.isFinite(free) || total <= 0) return null;
+    return { total, used: Math.max(0, total - free) };
+  } catch { return null; }
+}
+async function readSwap(platform = process.platform) {
+  if (platform === "darwin") {
+    const out = await run("sysctl", ["-n", "vm.swapusage"]);
+    return out ? swapFromSysctl(out) : null;
+  }
+  if (platform === "linux") {
+    try { return swapFromMeminfo(await readFile("/proc/meminfo", "utf8")); }
+    catch { return null; }
+  }
+  if (platform === "win32") {
+    const out = await run("powershell.exe", [
+      "-NoProfile", "-NonInteractive", "-Command",
+      "Get-CimInstance Win32_OperatingSystem | Select-Object TotalVirtualMemorySize,FreeVirtualMemory | ConvertTo-Json -Compress",
+    ], 4_000);
+    return out ? swapFromWmicJson(out.trim()) : null;
+  }
+  return null;
+}
+/** How many rows the process list keeps. Enough to see what is eating the
+ *  machine, few enough that the panel never becomes a scroll. */
+const TOP_N = 8;
+/**
+ * Rows out of `ps -Aceo pid,pcpu,pmem,comm -r`.
+ *
+ * `-c` gives the executable name without its full path and without the argv
+ * that would leak a prompt or a token into the UI; `-r` sorts by current CPU,
+ * which is the ordering that answers "what is eating this machine right now".
+ */
+export function parsePsProcesses(text, limit = TOP_N) {
+  const lines = String(text ?? "").trim().split("\n");
+  const out = [];
+  for (const line of lines.slice(1)) {           // drop the header row
+    const m = /^\s*(\d+)\s+([\d.]+)\s+([\d.]+)\s+(.+?)\s*$/.exec(line);
+    if (!m) continue;
+    out.push({ pid: Number(m[1]), cpu: Number(m[2]), mem: Number(m[3]), name: m[4] });
+    if (out.length >= limit) break;
+  }
+  return out;
+}
+/**
+ * Rows out of the Windows performance counter.
+ *
+ * `Get-Process` is the obvious call and the wrong one: its `CPU` property is
+ * total processor SECONDS consumed since the process started, so sorting by it
+ * ranks whatever has been running longest rather than whatever is busy now — a
+ * different question, and not the one the panel asks. The formatted performance
+ * counter publishes `PercentProcessorTime` directly, already a rate, so one
+ * query gives the same thing `ps -r` gives on Unix without a second sample.
+ *
+ * `_Total` and `Idle` are pseudo-processes in that class and are dropped.
+ */
+export function parseWindowsProcesses(json, totalMem, limit = TOP_N) {
+  let rows;
+  try { rows = typeof json === "string" ? JSON.parse(json) : json; }
+  catch { return []; }
+  if (!rows) return [];
+  if (!Array.isArray(rows)) rows = [rows];
+  const cores = os.cpus().length || 1;
+  return rows
+    .filter(r => r && r.Name && r.Name !== "_Total" && r.Name !== "Idle")
+    .map(r => ({
+      pid: Number(r.IDProcess) || 0,
+      // The counter is per-core-summed, exactly like macOS's 0-to-N00 scale, so
+      // it is normalised here to the 0-100 the Unix branch already reports.
+      cpu: Math.round((Number(r.PercentProcessorTime) || 0) / cores * 10) / 10,
+      mem: totalMem > 0
+        ? Math.round((Number(r.WorkingSetPrivate) || 0) / totalMem * 1000) / 10
+        : 0,
+      name: String(r.Name),
+    }))
+    .sort((a, b) => b.cpu - a.cpu)
+    .slice(0, limit);
+}
+/** The process list, on demand only — never on the ambient timer. */
+export async function readProcesses(platform = process.platform) {
+  if (platform === "win32") {
+    const out = await run("powershell.exe", [
+      "-NoProfile", "-NonInteractive", "-Command",
+      "Get-CimInstance Win32_PerfFormattedData_PerfProc_Process | Select-Object Name,IDProcess,PercentProcessorTime,WorkingSetPrivate | ConvertTo-Json -Compress",
+    ], 6_000);
+    return out ? parseWindowsProcesses(out.trim(), os.totalmem()) : [];
+  }
+  const out = await run("ps", ["-Aceo", "pid,pcpu,pmem,comm", "-r"], 4_000);
+  return out ? parsePsProcesses(out) : [];
+}
 async function sampleMemory() {
   if (memInFlight) return;
   memInFlight = true;
@@ -171,13 +345,18 @@ async function sampleMemory() {
       available,
       usedPct: Math.max(0, Math.min(100, Math.round(((total - available) / total) * 1000) / 10)),
     };
+    // Same 30s cadence as memory, and for the same reason: it moves in minutes
+    // and costs a subprocess on two of the three platforms.
+    swap = await readSwap();
   } catch { /* keep the previous reading rather than blanking the meter */ }
   finally { memInFlight = false; }
 }
 function sampleCpu() {
+  const per = corePercents();
   const pct = cpuPercent();
   if (pct == null) return;
+  cores = per;
   cpuHistory.push(pct);
   while (cpuHistory.length > HISTORY) cpuHistory.shift();
 }
@@ -189,6 +368,7 @@ function sampleCpu() {
 export function startSystemMetrics() {
   if (cpuTimer) return;
   prevTicks = readTicks();          // baseline, so the first tick has a delta
+  prevCoreTicks = readCoreTicks();
   sampleMemory();
   cpuTimer = setInterval(sampleCpu, CPU_INTERVAL_MS);
   memTimer = setInterval(sampleMemory, MEM_INTERVAL_MS);
@@ -201,8 +381,11 @@ export function stopSystemMetrics() {
   if (memTimer) clearInterval(memTimer);
   cpuTimer = memTimer = null;
   prevTicks = null;
+  prevCoreTicks = null;
   cpuHistory.length = 0;
   memory = null;
+  cores = null;
+  swap = null;
 }
 /**
@@ -223,6 +406,10 @@ export function systemSnapshot() {
     cpuHistory: [...cpuHistory],
     cores: os.cpus().length,
     memory,
+    swap,
+    perCore: cores,
+    uptimeSec: Math.round(os.uptime()),
+    platform: process.platform,
     loadavg: hasLoad ? load.map(n => Math.round(n * 100) / 100) : null,
     intervalMs: CPU_INTERVAL_MS,
     sampledAt: Date.now(),