@yourfam/yf-vitals 0.2.0 → 0.3.2

package/README.md

@@ -36,9 +36,10 @@ 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`) |
+| **GPU** | Utilization and VRAM when telemetry exists; **the row is omitted** when it does not |
 | **DSK** | Read and write **rates** (KiB/s, MiB/s, GiB/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 |
+| **C: / D: / Data** | Capacity last: one bar per local partition. Skips Google Drive, iCloud, network, FAT/USB |
 
 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.2.0",
+  "version": "0.3.2",
   "description": "Live terminal dashboard for CPU, RAM, disk, net, and optional GPU",
   "type": "module",
   "bin": {

package/src/args.js

@@ -98,6 +98,7 @@ Usage:
   --version, -V          Package version
 
 q / Q / Ctrl+C quit. GPU row is omitted when the OS has no GPU telemetry.
+Each local partition (C:, D:, Data, …) gets its own fill bar. No Google Drive, iCloud, or network shares.
 Disk rates are KiB/s–GiB/s; network rates are kbps/Mbps/Gbps.
 Disk / net sparks are split (R/W, ↑/↓) and scale to the pair max in the last 60 ticks.
 Bar fill turns yellow ≥50% and red ≥80%. Unused spark slots use the lowest tick.

package/src/dashboard.js

@@ -1,6 +1,6 @@
 import { appendHistory, createHistory } from "./history.js";
 import { renderFrame } from "./render.js";
-import { createSampler, mergeLastGood } from "./sample.js";
+import { createSampler, instantSnapshot, mergeLastGood } from "./sample.js";
 import { CLEAR_HOME, enterTerminal, restoreTerminal } from "./tty.js";
 
 const CTRL_C = 0x03;
@@ -61,6 +61,16 @@ export async function runDashboard(args, deps) {
   };
 
   enterTerminal(write, stdin);
+  const first = instantSnapshot();
+  write(
+    CLEAR_HOME +
+      renderFrame(first, createHistory(), {
+        columns: deps.columns(),
+        env: deps.env,
+        isTTY: true,
+        intervalSec: args.interval,
+      }),
+  );
 
   const onData = (chunk) => {
     if (isQuitKey(chunk)) quit = true;
@@ -82,7 +92,7 @@ export async function runDashboard(args, deps) {
     sampler = deps.sampler || createSampler();
     let history = createHistory();
     /** @type {import("./sample.js").Snapshot | null} */
-    let last = null;
+    let last = first;
 
     while (!shouldStop()) {
       let snap;

package/src/disk.js

@@ -87,10 +87,14 @@ export function createWindowsDiskReader() {
   }
 
   return {
+    start() {
+      ensure();
+    },
     /**
+     * @param {number} [timeoutMs]
      * @returns {Promise<ReturnType<typeof parseDiskCounterLine>>}
      */
-    read() {
+    read(timeoutMs = 400) {
       if (closed) return Promise.resolve(null);
       ensure();
       if (!child || !child.stdin.writable) return Promise.resolve(null);
@@ -99,7 +103,7 @@ export function createWindowsDiskReader() {
           const i = pending.findIndex((p) => p.resolve === done);
           if (i >= 0) pending.splice(i, 1);
           resolve(null);
-        }, 2500);
+        }, timeoutMs);
         const done = (v) => {
           clearTimeout(t);
           resolve(v);

package/src/diskuse.js

@@ -0,0 +1,98 @@
+const MIN_BYTES = 8 * 1024 * 1024 * 1024;
+
+const SKIP_FS =
+  /^(fat|fat12|fat16|fat32|msdos|nfs|smbfs|cifs|afp|webdav|fuse|sshfs|osxfuse|macfuse|tmpfs|devfs|autofs|iso9660|udf|overlay|9p)$/i;
+
+const SKIP_NAME =
+  /google\s*drive|gdrive|icloud|onedrive|dropbox|cloudstorage|cloudmounter|box\.com/i;
+
+const SKIP_MOUNT =
+  /^\/(System\/Volumes\/(Preboot|VM|Update|Recovery|iOS|hardware|xarts|cryptex)|\.MobileBackups|Volumes\/\.timemachine)/i;
+
+const LOCAL_FS = /^(ntfs|refs|apfs|hfs|hfs\+|ext[234]|xfs|btrfs|zfs)$/i;
+
+/**
+ * @param {{ fs?: string, type?: string, mount?: string, size?: number, used?: number }} row
+ */
+export function isLocalCapacityVolume(row) {
+  if (!row) return false;
+  const type = String(row.type || "");
+  const mount = String(row.mount || "");
+  const fs = String(row.fs || "");
+  const blob = `${type} ${mount} ${fs}`;
+  if (SKIP_NAME.test(blob)) return false;
+  if (SKIP_FS.test(type)) return false;
+  if (SKIP_MOUNT.test(mount)) return false;
+  const size = Number(row.size) || 0;
+  if (size < MIN_BYTES) return false;
+  if (LOCAL_FS.test(type)) return true;
+  if (/^[A-Z]:\\?$/i.test(mount || fs) && LOCAL_FS.test(type)) return true;
+  if (mount === "/" || mount === "/System/Volumes/Data") return true;
+  return false;
+}
+
+/**
+ * @param {string} mount
+ */
+export function shortMount(mount) {
+  const m = String(mount || "");
+  const drive = m.match(/^([A-Z]:)\\?$/i);
+  if (drive) return drive[1].toUpperCase();
+  if (m === "/System/Volumes/Data") return "Data";
+  if (m === "/") return "/";
+  const parts = m.split(/[/\\]/).filter(Boolean);
+  return parts[parts.length - 1] || m || "?";
+}
+
+/**
+ * @param {{ fs?: string, type?: string, mount?: string, size?: number, used?: number, use?: number }} row
+ */
+function systemScore(row) {
+  const m = String(row.mount || "");
+  if (/^C:\\?$/i.test(m)) return 3;
+  if (m === "/System/Volumes/Data") return 2;
+  if (m === "/") return 1;
+  return 0;
+}
+
+/**
+ * @param {{ fs?: string, type?: string, mount?: string, size?: number, used?: number, use?: number }} r
+ */
+function toVolume(r) {
+  const total = Number(r.size) || 0;
+  const used = Number(r.used) || 0;
+  const percent =
+    typeof r.use === "number" && Number.isFinite(r.use)
+      ? r.use
+      : total > 0
+        ? (used / total) * 100
+        : 0;
+  return {
+    percent: Math.min(100, Math.max(0, percent)),
+    used,
+    total,
+    mount: shortMount(r.mount || r.fs || ""),
+  };
+}
+
+/**
+ * One first-class volume per local partition. System disk first, then the rest.
+ * @param {Array<{ fs?: string, type?: string, mount?: string, size?: number, used?: number, use?: number }>} rows
+ * @returns {{ percent: number, used: number, total: number, mount: string }[] | null}
+ */
+export function summarizeLocalDisks(rows) {
+  const local = (Array.isArray(rows) ? rows : []).filter(isLocalCapacityVolume);
+  /** @type {typeof local} */
+  const uniq = [];
+  for (const r of local.slice().sort((a, b) => systemScore(b) - systemScore(a) || (b.size || 0) - (a.size || 0))) {
+    const dupIdx = uniq.findIndex(
+      (u) =>
+        Math.abs((u.size || 0) - (r.size || 0)) < 1024 * 1024 &&
+        Math.abs((u.used || 0) - (r.used || 0)) < 0.01 * (r.size || 1),
+    );
+    if (dupIdx >= 0) continue;
+    uniq.push(r);
+  }
+  if (!uniq.length) return null;
+  return uniq.slice(0, 6).map(toVolume);
+}

package/src/format.js

@@ -1,6 +1,7 @@
 const KIB = 1024;
 const MIB = 1024 * 1024;
 const GIB = 1024 * 1024 * 1024;
+const TIB = 1024 * 1024 * 1024 * 1024;
 
 /**
  * @param {number} bytes
@@ -8,6 +9,7 @@ const GIB = 1024 * 1024 * 1024;
 export function formatBytes(bytes) {
   const n = Number(bytes);
   if (!Number.isFinite(n) || n < 0) return "n/a";
+  if (n >= TIB) return `${(n / TIB).toFixed(1)} TiB`;
   if (n >= GIB) return `${(n / GIB).toFixed(1)} GiB`;
   return `${(n / MIB).toFixed(1)} MiB`;
 }
@@ -20,8 +22,8 @@ export function formatBytePair(used, total) {
   const t = Number(total);
   const u = Number(used);
   if (!Number.isFinite(t) || t < 0 || !Number.isFinite(u) || u < 0) return "n/a";
-  const unit = t >= GIB ? "GiB" : "MiB";
-  const div = unit === "GiB" ? GIB : MIB;
+  const unit = t >= TIB ? "TiB" : t >= GIB ? "GiB" : "MiB";
+  const div = unit === "TiB" ? TIB : unit === "GiB" ? GIB : MIB;
   return `${(u / div).toFixed(1)} / ${(t / div).toFixed(1)} ${unit}`;
 }
 

package/src/history.js

@@ -9,10 +9,11 @@ import { HISTORY_SIZE } from "./bar.js";
  * @property {number[]} dskW
  * @property {number[]} netUp
  * @property {number[]} netDn
+ * @property {Record<string, number[]>} diskUse
  */
 
 export function createHistory() {
-  return { cpu: [], ram: [], gpu: [], dskR: [], dskW: [], netUp: [], netDn: [] };
+  return { cpu: [], ram: [], gpu: [], dskR: [], dskW: [], netUp: [], netDn: [], diskUse: {} };
 }
 
 /**
@@ -43,5 +44,19 @@ export function appendHistory(history, snap) {
     dskW: pushSample(history.dskW, snap.disk?.writeBps),
     netUp: pushSample(history.netUp, snap.net?.txBps),
     netDn: pushSample(history.netDn, snap.net?.rxBps),
+    diskUse: appendDiskUse(history.diskUse, snap.diskUse),
   };
 }
+
+/**
+ * @param {Record<string, number[]>} prev
+ * @param {{ mount: string, percent: number }[] | null | undefined} vols
+ */
+function appendDiskUse(prev, vols) {
+  /** @type {Record<string, number[]>} */
+  const next = { ...prev };
+  for (const vol of vols || []) {
+    next[vol.mount] = pushSample(next[vol.mount] || [], vol.percent);
+  }
+  return next;
+}

package/src/render.js

@@ -208,6 +208,19 @@ export function renderFrame(snap, history, opts = {}) {
     );
   }
   lines.push("");
+
+  if (Array.isArray(snap.diskUse) && snap.diskUse.length) {
+    for (const vol of snap.diskUse) {
+      const label = vol.mount.length >= 3 ? vol.mount.slice(0, 4) : vol.mount.padEnd(3);
+      const spark = history.diskUse?.[vol.mount] || [];
+      lines.push(
+        `${color.green(label)}  ${paintPercentBar(vol.percent, color, "green", ascii)}  ${formatPercent(vol.percent)}   ${formatBytePair(vol.used, vol.total)}`,
+      );
+      lines.push(`     ${color.green(sparkline(spark, sparkW, { ascii, max: 100 }))}`);
+      lines.push("");
+    }
+  }
+
   lines.push("q quit");
 
   return lines.map((ln) => fitLine(ln, columns)).join("\n");

package/src/sample.js

@@ -1,5 +1,6 @@
 import os from "node:os";
 import { createWindowsDiskReader } from "./disk.js";
+import { summarizeLocalDisks } from "./diskuse.js";
 import { rateFromCounters } from "./rates.js";
 
 /**
@@ -36,6 +37,7 @@ import { rateFromCounters } from "./rates.js";
  * @property {DiskSample | null} disk
  * @property {NetSample | null} net
  * @property {GpuSample | null} gpu
+ * @property {{ percent: number, used: number, total: number, mount: string }[] | null} diskUse
  */
 
 /**
@@ -82,6 +84,43 @@ function windowsLabel(release) {
   return "Windows";
 }
 
+/**
+ * Sync snapshot from `os` only — first paint must not wait on PowerShell / nvidia-smi.
+ * @returns {Snapshot}
+ */
+export function instantSnapshot() {
+  const logical = Math.max(os.cpus().length, 1);
+  const total = os.totalmem();
+  const free = os.freemem();
+  const used = Math.max(0, total - free);
+  return {
+    ts: Date.now(),
+    hostname: os.hostname(),
+    osName: shortOsName(null),
+    physical: logical,
+    logical,
+    ramTotal: total,
+    cpu: null,
+    ram: total > 0 ? { percent: Math.min(100, (used / total) * 100), used, total } : null,
+    disk: { readBps: null, writeBps: null },
+    net: { txBps: null, rxBps: null },
+    gpu: null,
+    diskUse: null,
+  };
+}
+
+function ramFromOs(ramTotal) {
+  const total = ramTotal || os.totalmem();
+  const free = os.freemem();
+  const used = Math.max(0, total - free);
+  if (total <= 0) return null;
+  return {
+    percent: Math.min(100, Math.max(0, (used / total) * 100)),
+    used,
+    total,
+  };
+}
+
 /**
  * GPU memory fields in systeminformation are sometimes MiB, sometimes bytes.
  * @param {number | null} n
@@ -139,6 +178,7 @@ export function mergeLastGood(last, next) {
     disk: null,
     net: null,
     gpu: null,
+    diskUse: null,
   };
   return {
     ts: next.ts,
@@ -152,6 +192,7 @@ export function mergeLastGood(last, next) {
     disk: mergePair(next.disk, base.disk, "readBps", "writeBps"),
     net: mergePair(next.net, base.net, "txBps", "rxBps"),
     gpu: next.gpu ?? base.gpu,
+    diskUse: next.diskUse ?? base.diskUse,
   };
 }
 
@@ -248,9 +289,29 @@ export function createSampler(si) {
   let prevTs = null;
   /** @type {Snapshot | null} */
   let last = null;
-  /** @type {Promise<{ hostname: string, osName: string, physical: number, logical: number, ramTotal: number }> | null} */
-  let staticP = null;
-  const winDisk = process.platform === "win32" ? createWindowsDiskReader() : null;
+  /** @type {{ hostname: string, osName: string, physical: number, logical: number, ramTotal: number }} */
+  let meta = (() => {
+    const s = instantSnapshot();
+    return {
+      hostname: s.hostname,
+      osName: s.osName,
+      physical: s.physical,
+      logical: s.logical,
+      ramTotal: s.ramTotal,
+    };
+  })();
+  let staticStarted = false;
+  /** @type {GpuSample | null} */
+  let gpuCache = null;
+  let gpuStarted = false;
+  /** @type {Snapshot["diskUse"]} */
+  let diskUseCache = null;
+  let diskUseStarted = false;
+  const win32 = process.platform === "win32";
+  const winDisk = win32 ? createWindowsDiskReader() : null;
+  winDisk?.start();
+  let winReady = false;
+  prevCpu = cpuIdleTotal(os.cpus());
 
   async function loadSi() {
     if (si) return si;
@@ -258,43 +319,27 @@ export function createSampler(si) {
     return mod.default ?? mod;
   }
 
-  async function loadStatic() {
-    const lib = await loadSi();
-    const hostname = os.hostname();
-    let osName = shortOsName(null);
-    let logical = Math.max(os.cpus().length, 1);
-    let physical = logical;
-    let ramTotal = os.totalmem();
-    try {
-      const info = await lib.osInfo();
-      osName = shortOsName(info);
-    } catch {
-      // keep fallback
-    }
-    try {
-      const cpu = await lib.cpu();
-      if (cpu?.physicalCores) physical = cpu.physicalCores;
-      if (cpu?.cores) logical = cpu.cores;
-    } catch {
-      // keep os.cpus() counts
-    }
-    try {
-      const mem = await lib.mem();
-      if (mem?.total) ramTotal = mem.total;
-    } catch {
-      // keep os.totalmem
-    }
-    return { hostname, osName, physical, logical, ramTotal };
+  function kickStatic(lib) {
+    if (staticStarted) return;
+    staticStarted = true;
+    (async () => {
+      try {
+        const info = await lib.osInfo();
+        meta = { ...meta, osName: shortOsName(info) };
+      } catch {
+        // keep fallback
+      }
+      try {
+        const cpu = await lib.cpu();
+        if (cpu?.physicalCores) meta = { ...meta, physical: cpu.physicalCores };
+        if (cpu?.cores) meta = { ...meta, logical: cpu.cores };
+      } catch {
+        // keep os.cpus() counts
+      }
+    })();
   }
 
-  async function sampleCpu(lib) {
-    try {
-      const load = await lib.currentLoad();
-      const pct = num(load?.currentLoad);
-      if (pct != null) return { percent: Math.min(100, Math.max(0, pct)) };
-    } catch {
-      // fall through to os.cpus() idle-delta
-    }
+  async function sampleCpu() {
     const curr = cpuIdleTotal(os.cpus());
     const pct = cpuPercentFromDelta(prevCpu, curr);
     prevCpu = curr;
@@ -303,6 +348,7 @@ export function createSampler(si) {
   }
 
   async function sampleRam(lib, ramTotal) {
+    if (win32) return ramFromOs(ramTotal);
     try {
       const mem = await lib.mem();
       const total = num(mem?.total) ?? ramTotal;
@@ -310,22 +356,14 @@ export function createSampler(si) {
       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;
+      if (used == null || total == null || total <= 0) return ramFromOs(ramTotal);
       return {
         percent: Math.min(100, Math.max(0, (used / total) * 100)),
         used,
         total,
       };
     } catch {
-      const total = ramTotal || os.totalmem();
-      const free = os.freemem();
-      const used = total - free;
-      if (total <= 0) return null;
-      return {
-        percent: Math.min(100, Math.max(0, (used / total) * 100)),
-        used,
-        total,
-      };
+      return ramFromOs(ramTotal);
     }
   }
 
@@ -336,13 +374,13 @@ export function createSampler(si) {
   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) {
+    if (rx == null && wx == null && !win32) {
       try {
         const fs = await lib.fsStats();
         rx = num(fs?.rx);
         wx = num(fs?.wx);
       } catch {
-        // Windows fsStats is always null
+        // ignore
       }
     }
     if (rx == null && wx == null) return { readBps: null, writeBps: null };
@@ -359,7 +397,7 @@ export function createSampler(si) {
   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) {
+    if (rx == null && tx == null && !win32) {
       try {
         const stats = await lib.networkStats("*");
         const summed = sumNetBytes(Array.isArray(stats) ? stats : stats ? [stats] : []);
@@ -375,13 +413,36 @@ export function createSampler(si) {
     return { txBps, rxBps };
   }
 
-  async function sampleGpu(lib) {
-    try {
-      const g = await lib.graphics();
-      return pickGpu(g?.controllers || []);
-    } catch {
-      return null;
-    }
+  function kickGpu(lib) {
+    if (gpuStarted) return;
+    gpuStarted = true;
+    lib
+      .graphics()
+      .then((g) => {
+        gpuCache = pickGpu(g?.controllers || []);
+      })
+      .catch(() => {
+        gpuCache = null;
+      })
+      .finally(() => {
+        gpuStarted = false;
+      });
+  }
+
+  function kickDiskUse(lib) {
+    if (diskUseStarted) return;
+    diskUseStarted = true;
+    lib
+      .fsSize()
+      .then((rows) => {
+        diskUseCache = summarizeLocalDisks(rows);
+      })
+      .catch(() => {})
+      .finally(() => {
+        setTimeout(() => {
+          diskUseStarted = false;
+        }, 15000);
+      });
   }
 
   return {
@@ -390,16 +451,17 @@ export function createSampler(si) {
      */
     async sample() {
       const lib = await loadSi();
-      if (!staticP) staticP = loadStatic();
-      const meta = await staticP;
-      const win = winDisk ? await winDisk.read().catch(() => null) : null;
+      kickStatic(lib);
+      kickGpu(lib);
+      kickDiskUse(lib);
+      const win = winDisk ? await winDisk.read(winReady ? 400 : 50).catch(() => null) : null;
+      if (win) winReady = true;
       const ts = Date.now();
-      const [cpu, ram, disk, net, gpu] = await Promise.all([
-        sampleCpu(lib).catch(() => last?.cpu ?? null),
+      const [cpu, ram, disk, net] = await Promise.all([
+        sampleCpu().catch(() => last?.cpu ?? null),
         sampleRam(lib, meta.ramTotal).catch(() => last?.ram ?? 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;
       const snap = mergeLastGood(last, {
@@ -409,7 +471,8 @@ export function createSampler(si) {
         ram,
         disk,
         net,
-        gpu,
+        gpu: gpuCache,
+        diskUse: diskUseCache,
       });
       last = snap;
       return snap;