@yourfam/yf-vitals 0.1.0 → 0.1.1

package/README.md

@@ -37,7 +37,7 @@ One live dashboard. Refresh every **1.0s** (or `--interval`, or **2.0s** with `-
 | **CPU** | Overall utilization 0–100%, plus physical / logical core counts |
 | **RAM** | Percent used, plus used / total (`GiB` / `MiB`) |
 | **DSK** | Read and write **rates** (KiB/s, MiB/s, GiB/s) |
-| **NET** | Send ↑ and receive ↓ in **Mbps** (1 Mbps = 1e6 bit/s) |
+| **NET** | Send ↑ and receive ↓ in **kbps / Mbps / Gbps** (decimal bits; 1 Mbps = 1e6 bit/s) |
 | **GPU** | Utilization and VRAM when telemetry exists; **the row is omitted** when it does not |
 
 Header: `yf-vitals` · hostname · OS · `NP/NL` cores · RAM total · tick interval.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yourfam/yf-vitals",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Live terminal dashboard for CPU, RAM, disk, net, and optional GPU",
   "type": "module",
   "bin": {

package/src/args.js

@@ -98,7 +98,7 @@ Usage:
   --version, -V          Package version
 
 q / Q / Ctrl+C quit. GPU row is omitted when the OS has no GPU telemetry.
-Disk rates are MiB/s; network rates are Mbps.
+Disk rates are KiB/s–GiB/s; network rates are kbps/Mbps/Gbps.
 Disk / net sparklines scale to the max in the last 60 ticks (no 100% ceiling).
 Needs a terminal (no pipes). Node 20+.`;
 }

package/src/disk.js

@@ -1,23 +1,43 @@
 import { spawn } from "node:child_process";
 
-const PS_DISK = `
+const PS_COUNTERS = `
 $ErrorActionPreference = 'SilentlyContinue'
 while (($line = [Console]::In.ReadLine()) -ne $null) {
   if ($line -eq 'q') { break }
+  $dr = [int64]0
+  $dw = [int64]0
+  $rx = [int64]0
+  $tx = [int64]0
   $d = Get-CimInstance -ClassName Win32_PerfRawData_PerfDisk_PhysicalDisk -Filter "Name='_Total'"
-  if ($d) { Write-Output ("{0} {1}" -f $d.DiskReadBytesPersec, $d.DiskWriteBytesPersec) }
-  else { Write-Output "n n" }
+  if ($d) {
+    $dr = [int64]$d.DiskReadBytesPersec
+    $dw = [int64]$d.DiskWriteBytesPersec
+  }
+  Get-NetAdapterStatistics | ForEach-Object {
+    $name = [string]$_.Name
+    if ($name -match 'vEthernet|Loopback|Bluetooth|WSL|Hyper-V|Virtual|Pseudo|isatap|Teredo') { return }
+    $rx += [int64]$_.ReceivedBytes
+    $tx += [int64]$_.SentBytes
+  }
+  Write-Output ("{0} {1} {2} {3}" -f $dr, $dw, $rx, $tx)
 }
 `.trim();
 
 /**
  * @param {string} line
- * @returns {{ rx: number, wx: number } | null}
+ * @returns {{ rx: number, wx: number, netRx: number, netTx: number } | null}
  */
 export function parseDiskCounterLine(line) {
-  const m = String(line || "").trim().match(/^(\d+)\s+(\d+)$/);
+  const m = String(line || "")
+    .trim()
+    .match(/^(\d+)\s+(\d+)(?:\s+(\d+)\s+(\d+))?$/);
   if (!m) return null;
-  return { rx: Number(m[1]), wx: Number(m[2]) };
+  return {
+    rx: Number(m[1]),
+    wx: Number(m[2]),
+    netRx: m[3] != null ? Number(m[3]) : 0,
+    netTx: m[4] != null ? Number(m[4]) : 0,
+  };
 }
 
 function encodedCommand(script) {
@@ -26,11 +46,12 @@ function encodedCommand(script) {
 
 /**
  * Long-lived PowerShell so WMI stays warm (~10ms/tick after first query).
+ * One round-trip: disk bytes + physical NIC byte counters.
  */
 export function createWindowsDiskReader() {
   let child = null;
   let buf = "";
-  /** @type {{ resolve: (v: { rx: number, wx: number } | null) => void }[]} */
+  /** @type {{ resolve: (v: ReturnType<typeof parseDiskCounterLine>) => void }[]} */
   let pending = [];
   let closed = false;
 
@@ -43,7 +64,7 @@ export function createWindowsDiskReader() {
     if (child || closed) return;
     child = spawn(
       "powershell.exe",
-      ["-NoProfile", "-NonInteractive", "-EncodedCommand", encodedCommand(PS_DISK)],
+      ["-NoProfile", "-NonInteractive", "-EncodedCommand", encodedCommand(PS_COUNTERS)],
       { windowsHide: true, stdio: ["pipe", "pipe", "ignore"] },
     );
     child.stdout.setEncoding("utf8");
@@ -67,7 +88,7 @@ export function createWindowsDiskReader() {
 
   return {
     /**
-     * @returns {Promise<{ rx: number, wx: number } | null>}
+     * @returns {Promise<ReturnType<typeof parseDiskCounterLine>>}
      */
     read() {
       if (closed) return Promise.resolve(null);

package/src/format.js

@@ -39,15 +39,19 @@ export function formatByteRate(bytesPerSec) {
 }
 
 /**
- * Network throughput in decimal Mbps (1 Mbps = 1e6 bit/s).
+ * Network throughput in decimal bit/s, auto-scaled (kbps / Mbps / Gbps).
+ * 1 kbps = 1e3 bit/s, 1 Mbps = 1e6 bit/s.
  * @param {number | null | undefined} bytesPerSec
  */
 export function formatBitRate(bytesPerSec) {
   if (bytesPerSec == null) return "—";
   const n = Number(bytesPerSec);
   if (!Number.isFinite(n) || n < 0) return "—";
-  const mbps = (n * 8) / 1e6;
-  return `${mbps.toFixed(1)} Mbps`;
+  const bits = n * 8;
+  if (bits >= 1e9) return `${(bits / 1e9).toFixed(2)} Gbps`;
+  if (bits >= 1e6) return `${(bits / 1e6).toFixed(1)} Mbps`;
+  if (bits >= 1e3) return `${(bits / 1e3).toFixed(1)} kbps`;
+  return `${bits.toFixed(0)} bps`;
 }
 
 /**

package/src/render.js

@@ -140,7 +140,7 @@ export function renderFrame(snap, history, opts = {}) {
   if (snap.net) {
     const up = formatBitRate(snap.net.txBps);
     const down = formatBitRate(snap.net.rxBps);
-    lines.push(`${color.yellow("NET")}  ↑  ${up.padStart(10)}    ↓  ${down.padStart(10)}`);
+    lines.push(`${color.yellow("NET")}  ↑  ${up.padStart(12)}    ↓  ${down.padStart(12)}`);
     lines.push(`     ${color.yellow(sparkline(history.net, sparkW, { ascii }))}`);
   } else {
     lines.push(`${color.yellow("NET")}  n/a`);

package/src/sample.js

@@ -100,23 +100,22 @@ export function gpuBytes(n, vramMb) {
  */
 export function pickGpu(controllers) {
   if (!Array.isArray(controllers) || controllers.length === 0) return null;
-  const usable = controllers.filter((c) => {
+  /** @type {GpuSample[]} */
+  const usable = [];
+  for (const c of controllers) {
     const util = num(c.utilizationGpu);
-    const total = gpuBytes(num(c.memoryTotal), num(c.vram));
     const used = gpuBytes(num(c.memoryUsed), null);
-    return util != null || (total != null && total > 0) || used != null;
-  });
+    const total = gpuBytes(num(c.memoryTotal), null);
+    if (util == null && (used == null || total == null)) continue;
+    usable.push({
+      percent: util ?? 0,
+      used,
+      total,
+    });
+  }
   if (usable.length === 0) return null;
-  const c =
-    usable.find((x) => num(x.utilizationGpu) != null) || usable[0];
-  const percent = num(c.utilizationGpu);
-  const total = gpuBytes(num(c.memoryTotal), num(c.vram));
-  const used = gpuBytes(num(c.memoryUsed), null);
-  return {
-    percent,
-    used,
-    total,
-  };
+  usable.sort((a, b) => (b.total ?? 0) - (a.total ?? 0));
+  return usable[0];
 }
 
 /**
@@ -174,15 +173,16 @@ function mergePair(next, last, a, b) {
 /**
  * @param {os.CpuInfo[]} cpus
  */
-export function cpuIdleTotal(cpus) {
+export function cpuIdleTotal(cpus, windows = process.platform === "win32") {
   let idle = 0;
   let total = 0;
   for (const c of cpus) {
     const t = c.times;
+    const irq = t.irq || 0;
+    const sys = windows ? Math.max(0, (t.sys || 0) - irq) : t.sys || 0;
     const i = t.idle || 0;
-    const sum = (t.user || 0) + (t.nice || 0) + (t.sys || 0) + (t.irq || 0) + i;
     idle += i;
-    total += sum;
+    total += (t.user || 0) + (t.nice || 0) + sys + irq + i;
   }
   return { idle, total };
 }
@@ -204,6 +204,16 @@ export function cpuPercentFromDelta(prev, curr) {
 /**
  * @param {Array<{ iface?: string, rx_bytes?: number, tx_bytes?: number, operstate?: string, internal?: boolean }>} stats
  */
+const VIRTUAL_IFACE =
+  /^(lo|lo0)$|Loopback|vEthernet|Hyper-V|WSL|Bluetooth|Virtual|VPN|TAP|TUN|Tailscale|Pseudo|isatap|Teredo/i;
+
+/**
+ * @param {string} name
+ */
+export function isVirtualIface(name) {
+  return VIRTUAL_IFACE.test(String(name || ""));
+}
+
 export function sumNetBytes(stats) {
   let rx = 0;
   let tx = 0;
@@ -211,12 +221,8 @@ export function sumNetBytes(stats) {
   if (!Array.isArray(stats)) return { rx: null, tx: null };
   for (const n of stats) {
     const name = String(n.iface || "");
-    if (n.internal || name === "lo" || name === "lo0" || /^Loopback/i.test(name)) {
-      continue;
-    }
-    if (n.operstate && n.operstate !== "up" && n.operstate !== "unknown") {
-      continue;
-    }
+    if (n.internal || isVirtualIface(name)) continue;
+    if (n.operstate && n.operstate !== "up") continue;
     const r = num(n.rx_bytes);
     const t = num(n.tx_bytes);
     if (r == null && t == null) continue;
@@ -282,34 +288,28 @@ export function createSampler(si) {
   }
 
   async function sampleCpu(lib) {
-    const curr = cpuIdleTotal(os.cpus());
-    if (!prevCpu) {
-      prevCpu = curr;
-      await new Promise((r) => setTimeout(r, 50));
-      const curr2 = cpuIdleTotal(os.cpus());
-      const pctFast = cpuPercentFromDelta(prevCpu, curr2);
-      prevCpu = curr2;
-      if (pctFast != null) return { percent: pctFast };
-    } else {
-      const pct = cpuPercentFromDelta(prevCpu, curr);
-      prevCpu = curr;
-      if (pct != null) return { percent: pct };
-    }
     try {
       const load = await lib.currentLoad();
       const pct = num(load?.currentLoad);
       if (pct != null) return { percent: Math.min(100, Math.max(0, pct)) };
     } catch {
-      // keep n/a
+      // fall through to os.cpus() idle-delta
     }
-    return null;
+    const curr = cpuIdleTotal(os.cpus());
+    const pct = cpuPercentFromDelta(prevCpu, curr);
+    prevCpu = curr;
+    if (pct == null) return null;
+    return { percent: pct };
   }
 
   async function sampleRam(lib, ramTotal) {
     try {
       const mem = await lib.mem();
       const total = num(mem?.total) ?? ramTotal;
-      const used = num(mem?.used) ?? num(mem?.active);
+      const available = num(mem?.available) ?? num(mem?.free);
+      let used = null;
+      if (total != null && available != null) used = Math.max(0, total - available);
+      else used = num(mem?.used) ?? num(mem?.active);
       if (used == null || total == null || total <= 0) return null;
       return {
         percent: Math.min(100, Math.max(0, (used / total) * 100)),
@@ -329,21 +329,20 @@ export function createSampler(si) {
     }
   }
 
-  async function sampleDisk(lib, ts) {
-    let rx = null;
-    let wx = null;
-    try {
-      const fs = await lib.fsStats();
-      rx = num(fs?.rx);
-      wx = num(fs?.wx);
-    } catch {
-      // Windows fsStats is always null; fall through
-    }
-    if (rx == null && wx == null && winDisk) {
-      const w = await winDisk.read();
-      if (w) {
-        rx = w.rx;
-        wx = w.wx;
+  /**
+   * @param {number} ts
+   * @param {{ rx: number, wx: number } | null} win
+   */
+  async function sampleDisk(lib, ts, win) {
+    let rx = win ? num(win.rx) : null;
+    let wx = win ? num(win.wx) : null;
+    if (rx == null && wx == null) {
+      try {
+        const fs = await lib.fsStats();
+        rx = num(fs?.rx);
+        wx = num(fs?.wx);
+      } catch {
+        // Windows fsStats is always null
       }
     }
     if (rx == null && wx == null) return { readBps: null, writeBps: null };
@@ -353,17 +352,27 @@ export function createSampler(si) {
     return { readBps, writeBps };
   }
 
-  async function sampleNet(lib, ts) {
-    try {
-      const stats = await lib.networkStats("*");
-      const { rx, tx } = sumNetBytes(Array.isArray(stats) ? stats : stats ? [stats] : []);
-      const rxBps = rateFromCounters(prevNet?.rx, rx, prevTs, ts);
-      const txBps = rateFromCounters(prevNet?.tx, tx, prevTs, ts);
-      if (rx != null && tx != null) prevNet = { rx, tx };
-      return { txBps, rxBps };
-    } catch {
-      return { txBps: null, rxBps: null };
+  /**
+   * @param {number} ts
+   * @param {{ netRx?: number, netTx?: number } | null} win
+   */
+  async function sampleNet(lib, ts, win) {
+    let rx = win ? num(win.netRx) : null;
+    let tx = win ? num(win.netTx) : null;
+    if (rx == null && tx == null) {
+      try {
+        const stats = await lib.networkStats("*");
+        const summed = sumNetBytes(Array.isArray(stats) ? stats : stats ? [stats] : []);
+        rx = summed.rx;
+        tx = summed.tx;
+      } catch {
+        return { txBps: null, rxBps: null };
+      }
     }
+    const rxBps = rateFromCounters(prevNet?.rx, rx, prevTs, ts);
+    const txBps = rateFromCounters(prevNet?.tx, tx, prevTs, ts);
+    if (rx != null && tx != null) prevNet = { rx, tx };
+    return { txBps, rxBps };
   }
 
   async function sampleGpu(lib) {
@@ -383,12 +392,13 @@ export function createSampler(si) {
       const lib = await loadSi();
       if (!staticP) staticP = loadStatic();
       const meta = await staticP;
+      const win = winDisk ? await winDisk.read().catch(() => null) : null;
       const ts = Date.now();
       const [cpu, ram, disk, net, gpu] = await Promise.all([
         sampleCpu(lib).catch(() => last?.cpu ?? null),
         sampleRam(lib, meta.ramTotal).catch(() => last?.ram ?? null),
-        sampleDisk(lib, ts).catch(() => last?.disk ?? { readBps: null, writeBps: null }),
-        sampleNet(lib, ts).catch(() => last?.net ?? { txBps: null, rxBps: null }),
+        sampleDisk(lib, ts, win).catch(() => last?.disk ?? { readBps: null, writeBps: null }),
+        sampleNet(lib, ts, win).catch(() => last?.net ?? { txBps: null, rxBps: null }),
         sampleGpu(lib).catch(() => last?.gpu ?? null),
       ]);
       prevTs = ts;