@4pm/cli 1.4.1 → 1.4.2

package/dist/index.js

@@ -33309,9 +33309,47 @@ async function readCgroup(file) {
     return null;
   }
 }
+function parseKv(text) {
+  const map = /* @__PURE__ */ new Map();
+  if (!text) return map;
+  for (const line of text.split("\n")) {
+    const [k, v] = line.trim().split(/\s+/);
+    if (k && v !== void 0) {
+      const n = Number(v);
+      if (Number.isFinite(n)) map.set(k, n);
+    }
+  }
+  return map;
+}
+function parsePressureSome(text) {
+  if (!text) return void 0;
+  const some = text.split("\n").find((l) => l.startsWith("some "));
+  const m = some?.match(/avg10=([\d.]+)/);
+  const n = m ? Number(m[1]) : NaN;
+  return Number.isFinite(n) ? clampPct(n) : void 0;
+}
+function parseIoStat(text) {
+  if (!text) return null;
+  let rBytes = 0;
+  let wBytes = 0;
+  for (const line of text.split("\n")) {
+    const r = line.match(/\brbytes=(\d+)/);
+    const w = line.match(/\bwbytes=(\d+)/);
+    if (r) rBytes += Number(r[1]);
+    if (w) wBytes += Number(w[1]);
+  }
+  return { rBytes, wBytes };
+}
+function parseMaybeMax(text) {
+  if (text === null) return null;
+  if (text === "max") return null;
+  const n = Number(text);
+  return Number.isFinite(n) ? n : null;
+}
 function createWorkerMetricsSampler(diskPath) {
   const cgroupV2 = existsSync4(`${CGROUP}/cpu.stat`) && existsSync4(`${CGROUP}/memory.current`);
-  let prev = null;
+  let cgPrev = null;
+  let osPrev = null;
   async function cgroupCpuCount() {
     const raw = await readCgroup("cpu.max");
     if (raw) {
@@ -33323,22 +33361,6 @@ function createWorkerMetricsSampler(diskPath) {
     }
     return cpus().length;
   }
-  async function cgroupCpuPct(cpuCount) {
-    const stat2 = await readCgroup("cpu.stat");
-    const m = stat2?.match(/usage_usec\s+(\d+)/);
-    const usageUsec = m ? Number(m[1]) : NaN;
-    const now = Date.now();
-    if (!Number.isFinite(usageUsec)) return 0;
-    if (!prev) {
-      prev = { busy: usageUsec, ref: now };
-      return 0;
-    }
-    const dUsage = usageUsec - prev.busy;
-    const dWall = (now - prev.ref) * 1e3;
-    prev = { busy: usageUsec, ref: now };
-    if (dWall <= 0) return 0;
-    return clampPct(dUsage / (dWall * cpuCount) * 100);
-  }
   function osCpuPct() {
     let busy = 0;
     let total = 0;
@@ -33347,13 +33369,13 @@ function createWorkerMetricsSampler(diskPath) {
       busy += t.user + t.nice + t.sys + t.irq;
       total += t.user + t.nice + t.sys + t.irq + t.idle;
     }
-    if (!prev) {
-      prev = { busy, ref: total };
+    if (!osPrev) {
+      osPrev = { busy, total };
       return 0;
     }
-    const dBusy = busy - prev.busy;
-    const dTotal = total - prev.ref;
-    prev = { busy, ref: total };
+    const dBusy = busy - osPrev.busy;
+    const dTotal = total - osPrev.total;
+    osPrev = { busy, total };
     if (dTotal <= 0) return 0;
     return clampPct(dBusy / dTotal * 100);
   }
@@ -33367,9 +33389,74 @@ function createWorkerMetricsSampler(diskPath) {
       return { usedGb: 0, totalGb: 0 };
     }
   }
+  async function cgroupExtended(cpuCount, now) {
+    const [cpuStatRaw, memStatRaw, ioStatRaw, cpuPsi, memPsi, ioPsi, swapCurRaw, swapMaxRaw, memEventsRaw, pidsCurRaw, pidsMaxRaw] = await Promise.all([
+      readCgroup("cpu.stat"),
+      readCgroup("memory.stat"),
+      readCgroup("io.stat"),
+      readCgroup("cpu.pressure"),
+      readCgroup("memory.pressure"),
+      readCgroup("io.pressure"),
+      readCgroup("memory.swap.current"),
+      readCgroup("memory.swap.max"),
+      readCgroup("memory.events"),
+      readCgroup("pids.current"),
+      readCgroup("pids.max")
+    ]);
+    const cpuStat = parseKv(cpuStatRaw);
+    const usageUsec = cpuStat.get("usage_usec") ?? NaN;
+    const nrThrottled = cpuStat.get("nr_throttled") ?? 0;
+    const nrPeriods = cpuStat.get("nr_periods") ?? 0;
+    const io = parseIoStat(ioStatRaw);
+    const extra = {};
+    extra.cpuPressurePct = parsePressureSome(cpuPsi);
+    extra.memPressurePct = parsePressureSome(memPsi);
+    extra.ioPressurePct = parsePressureSome(ioPsi);
+    const memStat = parseKv(memStatRaw);
+    if (memStat.has("anon")) extra.memAnonMb = Math.round(memStat.get("anon") / MB);
+    if (memStat.has("file")) extra.memCacheMb = Math.round(memStat.get("file") / MB);
+    if (swapCurRaw !== null) extra.swapUsedMb = Math.round(Number(swapCurRaw) / MB);
+    if (swapMaxRaw !== null) {
+      const max = parseMaybeMax(swapMaxRaw);
+      extra.swapTotalMb = max === null ? null : Math.round(max / MB);
+    }
+    const memEvents = parseKv(memEventsRaw);
+    if (memEvents.has("oom_kill")) extra.oomKills = memEvents.get("oom_kill");
+    if (pidsCurRaw !== null) {
+      const n = Number(pidsCurRaw);
+      if (Number.isFinite(n)) extra.pidsCurrent = n;
+    }
+    if (pidsMaxRaw !== null) extra.pidsMax = parseMaybeMax(pidsMaxRaw);
+    let cpuPct = 0;
+    if (Number.isFinite(usageUsec)) {
+      if (cgPrev) {
+        const dWallUsec = (now - cgPrev.wallMs) * 1e3;
+        if (dWallUsec > 0) cpuPct = clampPct((usageUsec - cgPrev.usageUsec) / (dWallUsec * cpuCount) * 100);
+        const dPeriods = nrPeriods - cgPrev.nrPeriods;
+        if (dPeriods > 0) extra.cpuThrottledPct = clampPct((nrThrottled - cgPrev.nrThrottled) / dPeriods * 100);
+        if (io) {
+          const dSec = (now - cgPrev.wallMs) / 1e3;
+          if (dSec > 0) {
+            extra.diskReadMbps = round1((io.rBytes - cgPrev.ioR) / MB / dSec);
+            extra.diskWriteMbps = round1((io.wBytes - cgPrev.ioW) / MB / dSec);
+          }
+        }
+      }
+      cgPrev = {
+        usageUsec,
+        nrThrottled,
+        nrPeriods,
+        ioR: io?.rBytes ?? 0,
+        ioW: io?.wBytes ?? 0,
+        wallMs: now
+      };
+    }
+    return { cpuPct, extra };
+  }
   return {
     async sample() {
-      const at = (/* @__PURE__ */ new Date()).toISOString();
+      const now = Date.now();
+      const at = new Date(now).toISOString();
       const { usedGb: diskUsedGb, totalGb: diskTotalGb } = await disk();
       const base = { platform: platform(), arch: arch(), diskUsedGb, diskTotalGb, at };
       if (cgroupV2) {
@@ -33378,14 +33465,15 @@ function createWorkerMetricsSampler(diskPath) {
         const memTotalBytes = memMaxRaw && memMaxRaw !== "max" ? Number(memMaxRaw) : totalmem();
         const memUsedBytes = memCurRaw ? Number(memCurRaw) : totalmem() - freemem();
         const cpuCount = await cgroupCpuCount();
-        const cpuPct = await cgroupCpuPct(cpuCount);
+        const { cpuPct, extra } = await cgroupExtended(cpuCount, now);
         return {
           ...base,
           source: "cgroup",
           cpuCount,
           cpuPct,
           memUsedMb: Math.round(memUsedBytes / MB),
-          memTotalMb: Math.round(memTotalBytes / MB)
+          memTotalMb: Math.round(memTotalBytes / MB),
+          ...extra
         };
       }
       const total = totalmem();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@4pm/cli",
-  "version": "1.4.1",
+  "version": "1.4.2",
   "private": false,
   "description": "4PM CLI — drives Claude/Codex CLIs on AI worker machines (Node + TypeScript)",
   "license": "LicenseRef-4PM-Source-Available",