@hienlh/ppm 0.23.6 → 0.23.8

package/src/services/system-metrics/cpu-memory-collector.ts

@@ -1,9 +1,15 @@
 /**
- * Whole-machine CPU + memory from `node:os`. Runs in both tiers, spawns nothing.
+ * Whole-machine CPU + memory. Runs in both tiers.
+ *
+ * Reads files on Linux and spawns nothing there. On darwin it spawns exactly one
+ * `sysctl` per tick for swap, which `node:os` does not carry — measured at
+ * 1.33 ms, see `memory-darwin.ts`.
  */
 import os from "node:os";
 import { readFileSync } from "node:fs";
 import type { CpuMetrics, MemoryMetrics } from "../../types/system-metrics.ts";
+import { enrichMemory, readZramTotals, type ZramTotals } from "./memory-linux.ts";
+import { parseSwapUsage, readSwapUsage } from "./memory-darwin.ts";
 
 export interface CoreTimes {
   user: number;
@@ -11,8 +17,16 @@ export interface CoreTimes {
   sys: number;
   idle: number;
   irq: number;
+  /** Blocked on I/O: neither busy nor idle. `os.cpus()` has no field for it and
+   *  libuv reads the column into a throwaway, so these three are 0 on any host
+   *  whose sample came from there — see `sampleCpuTimes`. */
+  iowait: number;
+  softirq: number;
+  steal: number;
 }
 
+const NO_EXTRA = { iowait: 0, softirq: 0, steal: 0 } as const;
+
 export interface CpuTimesSample {
   times: CoreTimes[];
   /** Wall clock of the sample, epoch ms. */
@@ -20,38 +34,110 @@ export interface CpuTimesSample {
   model: string;
 }
 
+/** Read `/proc/stat` on Linux, null elsewhere or on failure. Injectable for tests. */
+export function readProcStat(): string | null {
+  if (process.platform !== "linux") return null;
+  try {
+    return readFileSync("/proc/stat", "utf-8");
+  } catch {
+    return null;
+  }
+}
+
 /**
- * Read `os.cpus()` and copy the numbers out immediately. Bun 1.3.10 on Windows
- * returns the SAME `times` on a later call while the array from the previous
- * call is still referenced — the delta then reads 0 % forever, with no error
- * anywhere. Keeping only plain copies between ticks avoids it.
+ * Per-core times from a `/proc/stat` dump, in the file's own jiffies. Null when
+ * no `cpuN` line is present, so the caller can fall back.
+ *
+ * `guest`/`guest_nice` are deliberately NOT read: the kernel already counts them
+ * inside `user`/`nice`, so adding them would inflate the total and under-report
+ * every busy percentage on a host running VMs.
  */
-export function sampleCpuTimes(now: number = Date.now()): CpuTimesSample {
+export function parseProcStatCores(stat: string): CoreTimes[] | null {
+  const cores: CoreTimes[] = [];
+  for (const line of stat.split("\n")) {
+    const m = /^cpu(\d+)\s+(.*)$/.exec(line);
+    if (!m) continue;
+    const n = m[2]!.trim().split(/\s+/).map(Number);
+    if (n.length < 8 || n.some((v) => !Number.isFinite(v))) return null;
+    cores[Number(m[1])] = {
+      user: n[0]!, nice: n[1]!, sys: n[2]!, idle: n[3]!,
+      iowait: n[4]!, irq: n[5]!, softirq: n[6]!, steal: n[7]!,
+    };
+  }
+  // A hole would mean a core index we never saw, which no kernel produces — but
+  // a sparse array here would crash the delta, so treat it as unusable.
+  if (cores.length === 0 || cores.some((c) => c === undefined)) return null;
+  return cores;
+}
+
+/**
+ * Prefer `/proc/stat`; fall back to `os.cpus()`.
+ *
+ * `os.cpus()` cannot express a core that is blocked on I/O. libuv's Linux
+ * `uv_cpu_info` reads the `iowait`, `softirq` and `steal` columns into a
+ * throwaway variable, so a core parked in iowait shows a *tiny* total delta with
+ * no idle in it — measured on this host, 6 jiffies of which 0 were idle while
+ * the kernel reported 195 of 201 in iowait, i.e. the Overview card drew one core
+ * pinned at a red **100%** while it was 3% busy and waiting on a disk write.
+ *
+ * The fallback still copies the numbers out immediately: Bun 1.3.10 on Windows
+ * returns the SAME `times` object on a later call while the previous array is
+ * still referenced, and the delta then reads 0 % forever with no error anywhere.
+ */
+export function sampleCpuTimes(
+  now: number = Date.now(),
+  stat: () => string | null = readProcStat,
+): CpuTimesSample {
   const cpus = os.cpus();
-  const times = cpus.map((c) => ({ ...c.times }));
-  return { times, at: now, model: cpus[0]?.model?.trim() ?? "" };
+  const model = cpus[0]?.model?.trim() ?? "";
+  const dump = stat();
+  const fromProc = dump ? parseProcStatCores(dump) : null;
+  if (fromProc && fromProc.length === cpus.length) return { times: fromProc, at: now, model };
+  return { times: cpus.map((c) => ({ ...c.times, ...NO_EXTRA })), at: now, model };
 }
 
 const round1 = (n: number): number => Math.round(n * 10) / 10;
 
-/** Busy % total + per core between two samples. Pure. First sample → all zeros. */
+/**
+ * Busy % total + per core between two samples. Pure. First sample → all zeros.
+ *
+ * The kernel share is `sys + irq` over the same interval — Mission Center draws
+ * it as a second, darker line under the total, so it is a SUBSET of `total` and
+ * must never be added to it.
+ */
 export function computeCpuFromSamples(prev: CpuTimesSample | null, next: CpuTimesSample): CpuMetrics {
-  const zeros: CpuMetrics = { total: 0, cores: next.times.map(() => 0), model: next.model };
+  const zeros: CpuMetrics = {
+    total: 0, cores: next.times.map(() => 0), model: next.model,
+    kernelPercent: 0, coreKernel: next.times.map(() => 0),
+  };
   if (!prev || prev.times.length !== next.times.length) return zeros;
 
   let busySum = 0;
+  let kernelSum = 0;
   let totalSum = 0;
+  const coreKernel: number[] = [];
   const cores = next.times.map((n, i) => {
     const p = prev.times[i]!;
-    const idle = n.idle - p.idle;
-    const total = (n.user - p.user) + (n.nice - p.nice) + (n.sys - p.sys) + idle + (n.irq - p.irq);
-    if (!(total > 0)) return 0;
-    busySum += total - idle;
+    // Waiting on I/O is not work. Folding it into `idle` is what `top` and
+    // Mission Center both do, and leaving it out of `total` altogether is the
+    // bug that drew an idle core at 100% — see `sampleCpuTimes`.
+    const notBusy = (n.idle - p.idle) + (n.iowait - p.iowait);
+    const kernel = (n.sys - p.sys) + (n.irq - p.irq) + (n.softirq - p.softirq);
+    const total = (n.user - p.user) + (n.nice - p.nice) + kernel
+      + notBusy + (n.steal - p.steal);
+    if (!(total > 0)) {
+      coreKernel.push(0);
+      return 0;
+    }
+    busySum += total - notBusy;
+    kernelSum += kernel;
     totalSum += total;
-    return clampPercent((total - idle) / total * 100);
+    coreKernel.push(clampPercent(kernel / total * 100));
+    return clampPercent((total - notBusy) / total * 100);
   });
   const total = totalSum > 0 ? clampPercent(busySum / totalSum * 100) : 0;
-  return { total, cores, model: next.model };
+  const kernelPercent = totalSum > 0 ? clampPercent(kernelSum / totalSum * 100) : 0;
+  return { total, cores, model: next.model, kernelPercent, coreKernel };
 }
 
 function clampPercent(v: number): number {
@@ -59,6 +145,20 @@ function clampPercent(v: number): number {
   return round1(Math.min(100, Math.max(0, v)));
 }
 
+/**
+ * Seconds since boot, on all three platforms — `os.uptime()` reads
+ * `/proc/uptime`, `kern.boottime` and `GetTickCount64` respectively.
+ *
+ * Linux has a finer figure of its own and `collectDevices` merges it OVER this
+ * one; the reason this exists is that the per-device collector is null off
+ * Linux, so "Up time" was an em dash — the claim that the host could not be
+ * asked how long it had been up — on macOS and Windows both.
+ */
+export function hostUptimeSec(): number | undefined {
+  const seconds = os.uptime();
+  return Number.isFinite(seconds) && seconds > 0 ? Math.round(seconds) : undefined;
+}
+
 /** Read `/proc/meminfo` on Linux, null elsewhere or on failure. Injectable for tests. */
 export function readMeminfo(): string | null {
   if (process.platform !== "linux") return null;
@@ -82,8 +182,19 @@ export function parseMemAvailableBytes(meminfo: string): number | null {
  * and `os.freemem()` is within 0.2 GiB of CIM's `FreePhysicalMemory`. On Linux
  * `freemem()` is `MemFree`, which makes a warm page cache look like a nearly
  * full machine — `MemAvailable` is what `free` and Task-Manager-like tools show.
+ * On **darwin** `freemem()` is already right and must be left alone: it agrees
+ * with what `top` calls unused (75 MB against this figure's 124 MB on the same
+ * host, sampled seconds apart), which is the number Activity Monitor shows.
+ *
+ * Swap is the one field macOS publishes and `os` does not, so it is fetched
+ * separately — see `memory-darwin.ts` for why that costs a spawn and why the
+ * page counts from `vm_stat` are deliberately not used.
  */
-export function collectMemory(meminfo: () => string | null = readMeminfo): MemoryMetrics {
+export function collectMemory(
+  meminfo: () => string | null = readMeminfo,
+  zram: () => ZramTotals | undefined = defaultZram,
+  swapusage: () => string | null = readSwapUsage,
+): MemoryMetrics {
   const totalBytes = os.totalmem();
   let availableBytes = os.freemem();
   const info = meminfo();
@@ -97,5 +208,16 @@ export function collectMemory(meminfo: () => string | null = readMeminfo): Memor
   const availableMB = round1(availableBytes / MB);
   const usedMB = round1(Math.max(totalMB - availableMB, 0));
   const percent = totalMB > 0 ? round1(usedMB / totalMB * 100) : 0;
-  return { totalMB, usedMB, availableMB, percent };
+  const base: MemoryMetrics = { totalMB, usedMB, availableMB, percent };
+  // `info` is null off Linux, so the composition fields simply stay absent there
+  // — but swap is not one of those: macOS answers for it, and leaving it absent
+  // rendered an em dash on a host with 8 GB of swap in use.
+  if (info) return enrichMemory(base, info, zram());
+  return { ...base, ...parseSwapUsage(swapusage()) };
+}
+
+/** Two `/sys` reads on a host that has zram and one cheap directory listing on
+ *  one that does not — small enough to run per tick, unlike the DIMM layout. */
+function defaultZram(): ZramTotals | undefined {
+  return readZramTotals();
 }

package/src/services/system-metrics/device-collector-linux.ts

@@ -0,0 +1,31 @@
+/** Every per-device Linux collector as one tick-shaped call. */
+import { collectLinuxDiskDevices } from "./disk-devices-linux.ts";
+import { collectLinuxNicDevices } from "./net-devices-linux.ts";
+import { collectLinuxFans } from "./fans-linux.ts";
+import { collectCpuLive } from "./cpu-details-linux.ts";
+import { collectLinuxGpus } from "./gpu-devices-linux.ts";
+import type { DrmGpuCollector } from "./gpu-fdinfo-linux.ts";
+import { realLinuxFs, type LinuxFs } from "./linux-fs.ts";
+import type { DeviceCollection, DeviceSampleState } from "./device-collector-types.ts";
+
+export function collectLinuxDevices(
+  prev: DeviceSampleState,
+  drm: DrmGpuCollector,
+  fs: LinuxFs = realLinuxFs,
+  now: () => number = Date.now,
+): DeviceCollection {
+  const disks = collectLinuxDiskDevices(prev.disks, fs, now);
+  const nics = collectLinuxNicDevices(prev.nics, fs, now);
+  const cpu = collectCpuLive(prev.rapl, fs, now);
+  // The same walk the process rows are built from: asking here first (or second)
+  // costs nothing, because the collector memoises one result per tick.
+  const gpus = collectLinuxGpus(prev.gpus, drm.usage(), fs, now);
+  return {
+    disks: disks.disks,
+    nics: nics.nics,
+    fans: collectLinuxFans(fs),
+    cpu: cpu.extras,
+    gpus: gpus.gpus,
+    next: { disks: disks.next, nics: nics.next, rapl: cpu.rapl, gpus: gpus.next },
+  };
+}

package/src/services/system-metrics/device-collector-types.ts

@@ -0,0 +1,40 @@
+/** Shape of the per-device (drive / interface) half of a tick, platform-neutral so
+ *  the tick assembler does not import a Linux module to name its own state. */
+import type { CpuMetrics, DiskMetrics, FanMetrics, GpuMetrics, NicMetrics } from "../../types/system-metrics.ts";
+import type { DiskSampleState } from "./disk-devices-linux.ts";
+import type { NicSampleState } from "./net-devices-linux.ts";
+import type { RaplSample } from "./cpu-details-linux.ts";
+import type { GpuSampleState } from "./gpu-devices-linux.ts";
+
+/** Previous counters, per device id. Each device is measured against its own
+ *  baseline, so one appearing mid-session costs one unavailable tick and never a
+ *  spike measured from zero. */
+export interface DeviceSampleState {
+  disks: DiskSampleState;
+  nics: NicSampleState;
+  /** Cumulative RAPL energy, the baseline package power is measured against. */
+  rapl: RaplSample | null;
+  /** Per-card rc6 / uncore counters. */
+  gpus: GpuSampleState;
+}
+
+export const EMPTY_DEVICE_STATE: DeviceSampleState = {
+  disks: new Map(), nics: new Map(), rapl: null, gpus: new Map(),
+};
+
+export interface DeviceCollection {
+  disks: DiskMetrics[];
+  nics: NicMetrics[];
+  /** Empty where the host has no fan tachometer. */
+  fans: FanMetrics[];
+  /** Merged over the cross-platform `CpuMetrics` by the tick, never replacing it. */
+  cpu: Partial<CpuMetrics>;
+  /** Cards this platform reads from sysfs. Appended to whatever the vendor-tool
+   *  collector (nvidia-smi) found, which covers the drivers sysfs cannot. */
+  gpus: GpuMetrics[];
+  next: DeviceSampleState;
+}
+
+/** Synchronous by design: every source is a small sysfs read, so there is no
+ *  subprocess to await and no reason for the tick to yield. */
+export type DeviceCollector = (prev: DeviceSampleState) => DeviceCollection;

package/src/services/system-metrics/disk-devices-linux.ts

@@ -0,0 +1,156 @@
+/**
+ * Per-disk figures for the Performance page's drive entries, from
+ * `/sys/block/<dev>/stat`. The arithmetic is Mission Center's
+ * (`platform-linux/src/disks/stats.rs`): busy% is iostat's %util, response time
+ * is weighted ticks over completed requests, and throughput is sectors x 512.
+ *
+ * Every device is sampled against its OWN previous sample, so a drive that
+ * appears mid-session reports `available:false` for one tick instead of a spike
+ * measured from zero.
+ */
+import type { DiskMetrics } from "../../types/system-metrics.ts";
+import { readNumber, realLinuxFs, type LinuxFs } from "./linux-fs.ts";
+
+export const SYS_BLOCK = "/sys/block";
+const SECTOR_BYTES = 512;
+
+/** Mission Center's list, matched on a 2-4 character prefix: virtual devices
+ *  whose counters double-count the real drive underneath, or are not a drive. */
+const IGNORED_PREFIXES = ["loop", "ram", "zram", "fd", "md", "dm", "zd"];
+
+/** `/sys/block/<dev>/stat` field indices. The line has 17 fields since 5.5; the
+ *  discard group (12-16) and flush group (17-18) are absent on older kernels,
+ *  which reads as 0 here rather than as an error. */
+const IDX = {
+  readIos: 0, readSectors: 2, readTicks: 3,
+  writeIos: 4, writeSectors: 6, writeTicks: 7,
+  ioTicks: 9,
+  discardIos: 11, discardTicks: 14,
+  flushIos: 15, flushTicks: 16,
+} as const;
+
+export interface DiskSample {
+  /** Wall clock in seconds — the sysfs stat line carries no timestamp. */
+  atSec: number;
+  readIos: number; readSectors: number; readTicks: number;
+  writeIos: number; writeSectors: number; writeTicks: number;
+  ioTicks: number;
+  discardIos: number; discardTicks: number;
+  flushIos: number; flushTicks: number;
+}
+
+/** Previous sample per device id. */
+export type DiskSampleState = Map<string, DiskSample>;
+
+export function isIgnoredDisk(id: string): boolean {
+  return IGNORED_PREFIXES.some((p) => id.startsWith(p));
+}
+
+/** Whole devices udev would call disks: skips the virtual prefixes and anything
+ *  reporting a zero size (an empty card reader, a detached loop device). */
+export function listDiskDevices(fs: Pick<LinuxFs, "list" | "read"> = realLinuxFs): string[] {
+  const names = fs.list(SYS_BLOCK);
+  if (!names) return [];
+  return names
+    .filter((n) => !isIgnoredDisk(n))
+    .filter((n) => (readNumber(fs, `${SYS_BLOCK}/${n}/size`) ?? 0) > 0)
+    .sort();
+}
+
+export function parseDiskStat(text: string, atSec: number): DiskSample | null {
+  const f = text.trim().split(/\s+/).map(Number);
+  if (f.length < 11 || f.some((v) => !Number.isFinite(v))) return null;
+  const at = (i: number) => f[i] ?? 0;
+  return {
+    atSec,
+    readIos: at(IDX.readIos), readSectors: at(IDX.readSectors), readTicks: at(IDX.readTicks),
+    writeIos: at(IDX.writeIos), writeSectors: at(IDX.writeSectors), writeTicks: at(IDX.writeTicks),
+    ioTicks: at(IDX.ioTicks),
+    discardIos: at(IDX.discardIos), discardTicks: at(IDX.discardTicks),
+    flushIos: at(IDX.flushIos), flushTicks: at(IDX.flushTicks),
+  };
+}
+
+/** NVMe exposes a composite sensor at `device/hwmon<N>/temp1_input`; a SATA drive
+ *  exposes the same path only once `drivetemp` is loaded, which it usually is not
+ *  — hence undefined rather than 0. Millidegrees, one decimal kept. */
+export function readDiskTempC(id: string, fs: Pick<LinuxFs, "list" | "read"> = realLinuxFs): number | undefined {
+  const dir = `${SYS_BLOCK}/${id}/device`;
+  const hwmon = fs.list(dir)?.find((n) => n.startsWith("hwmon"));
+  if (!hwmon) return undefined;
+  const milli = readNumber(fs, `${dir}/${hwmon}/temp1_input`);
+  return milli === undefined ? undefined : Math.round(milli / 100) / 10;
+}
+
+export interface DiskDeviceCollection {
+  disks: DiskMetrics[];
+  next: DiskSampleState;
+}
+
+/** One tick's worth of per-device figures. Devices absent from `prev` report
+ *  `available:false` — totals are still real, they are absolutes. */
+export function collectLinuxDiskDevices(
+  prev: DiskSampleState,
+  fs: Pick<LinuxFs, "list" | "read"> = realLinuxFs,
+  now: () => number = Date.now,
+): DiskDeviceCollection {
+  const atSec = now() / 1000;
+  const next: DiskSampleState = new Map();
+  const disks: DiskMetrics[] = [];
+
+  for (const id of listDiskDevices(fs)) {
+    const text = fs.read(`${SYS_BLOCK}/${id}/stat`);
+    const sample = text ? parseDiskStat(text, atSec) : null;
+    if (!sample) continue;
+    next.set(id, sample);
+    disks.push(toDiskMetrics(id, prev.get(id) ?? null, sample, readDiskTempC(id, fs)));
+  }
+  return { disks, next };
+}
+
+export function toDiskMetrics(
+  id: string,
+  prev: DiskSample | null,
+  next: DiskSample,
+  tempC: number | undefined,
+): DiskMetrics {
+  const base: DiskMetrics = {
+    id,
+    available: false,
+    busyPercent: 0,
+    responseMs: 0,
+    readBps: 0,
+    writeBps: 0,
+    readTotal: next.readSectors * SECTOR_BYTES,
+    writeTotal: next.writeSectors * SECTOR_BYTES,
+    ...(tempC === undefined ? {} : { tempC }),
+  };
+
+  const dt = prev ? next.atSec - prev.atSec : 0;
+  // A device reset (hot-replug reusing the name) walks the counters backwards;
+  // one unavailable tick is the honest answer, not a negative rate.
+  if (!prev || !Number.isFinite(dt) || dt <= 0 || next.ioTicks < prev.ioTicks) return base;
+
+  const ticks = delta(next.readTicks, prev.readTicks) + delta(next.writeTicks, prev.writeTicks)
+    + delta(next.discardTicks, prev.discardTicks) + delta(next.flushTicks, prev.flushTicks);
+  const ios = delta(next.readIos, prev.readIos) + delta(next.writeIos, prev.writeIos)
+    + delta(next.discardIos, prev.discardIos) + delta(next.flushIos, prev.flushIos);
+
+  return {
+    ...base,
+    available: true,
+    busyPercent: round1(Math.min(100, delta(next.ioTicks, prev.ioTicks) / (dt * 10))),
+    responseMs: ios > 0 ? round2(ticks / ios) : 0,
+    readBps: Math.round(delta(next.readSectors, prev.readSectors) * SECTOR_BYTES / dt),
+    writeBps: Math.round(delta(next.writeSectors, prev.writeSectors) * SECTOR_BYTES / dt),
+  };
+}
+
+/** Saturating, as Mission Center's `saturating_sub`: these counters only ever
+ *  grow, so a negative delta is a reset and contributes nothing. */
+function delta(next: number, prev: number): number {
+  return next > prev ? next - prev : 0;
+}
+
+const round1 = (n: number) => Math.round(n * 10) / 10;
+const round2 = (n: number) => Math.round(n * 100) / 100;

package/src/services/system-metrics/disk-inventory-linux.ts

@@ -0,0 +1,150 @@
+/**
+ * Static facts about each whole disk: model, kind, capacity, serial, and which
+ * one carries the root filesystem. Read once per inventory request, not per tick.
+ *
+ * Mission Center gets all of this from udisks2 over D-Bus and SKIPS any drive
+ * udisks2 has no object for, which on a headless or container host is every
+ * drive. PPM reads sysfs plus udev's own database instead, so the list is the
+ * same one the kernel has and needs neither a system bus nor root.
+ */
+import type { DiskInfo, DiskKind } from "../../types/system-hardware.ts";
+import { readAttr, readNumber, realLinuxFs, type LinuxFs } from "./linux-fs.ts";
+import { readUdevProperties, udevValue } from "./udev-db.ts";
+import { listDiskDevices, SYS_BLOCK } from "./disk-devices-linux.ts";
+import { parseMountInfo, readPartitions } from "./partitions-linux.ts";
+
+const SECTOR_BYTES = 512;
+/** How far to follow `slaves` links from the root filesystem's device down to a
+ *  real drive (partition -> LUKS -> LVM -> RAID is already four). */
+const MAX_SLAVE_DEPTH = 8;
+
+/** The kernel fills SCSI's vendor field with the transport name for a SATA drive,
+ *  so "ATA" is never a manufacturer. Mission Center prints it; PPM drops it. */
+const GENERIC_VENDORS = new Set(["ATA", "SATA", "NVME", "USB", "SCSI"]);
+
+export function readDiskInventory(fs: LinuxFs = realLinuxFs): DiskInfo[] {
+  const systemDisk = findSystemDisk(fs);
+  // Parsed once for the whole inventory rather than per disk: mountinfo is one
+  // file describing every mount on the host, and re-reading it per drive is the
+  // same work times however many drives there are.
+  const mounts = parseMountInfo(fs.read("/proc/self/mountinfo") ?? "");
+  return listDiskDevices(fs).map((id) => readDiskInfo(id, fs, systemDisk === id, mounts));
+}
+
+export function readDiskInfo(
+  id: string,
+  fs: LinuxFs,
+  systemDisk: boolean,
+  mounts = parseMountInfo(fs.read("/proc/self/mountinfo") ?? ""),
+): DiskInfo {
+  const udev = readUdevProperties(blockDeviceKey(id, fs), fs.read);
+  const sectors = readNumber(fs, `${SYS_BLOCK}/${id}/size`) ?? 0;
+  const rpm = Number(udevValue(udev, "ID_ATA_ROTATION_RATE_RPM"));
+
+  return {
+    id,
+    ...optional("model", diskModel(id, fs, udev)),
+    kind: diskKind(id, fs, udev),
+    capacityBytes: sectors * SECTOR_BYTES,
+    systemDisk,
+    removable: readAttr(fs, `${SYS_BLOCK}/${id}/removable`) === "1",
+    ...optional("serial", readAttr(fs, `${SYS_BLOCK}/${id}/device/serial`) ?? udevValue(udev, "ID_SERIAL_SHORT")),
+    ...optional("wwn", diskWwn(id, fs, udev)),
+    ...(Number.isFinite(rpm) && rpm > 0 ? { rotationRpm: rpm } : {}),
+    partitions: readPartitions(id, fs, mounts),
+  };
+}
+
+/** udev keys a block device by `b<major>:<minor>`, which sysfs reports in `dev`. */
+export function blockDeviceKey(id: string, fs: Pick<LinuxFs, "read">): string {
+  return `b${readAttr(fs, `${SYS_BLOCK}/${id}/dev`) ?? ""}`;
+}
+
+/** "vendor model", with the vendor dropped when it is generic or already the
+ *  start of the model — Mission Center's rule plus the ATA case. */
+export function diskModel(id: string, fs: Pick<LinuxFs, "read">, udev: ReadonlyMap<string, string>): string | undefined {
+  const model = readAttr(fs, `${SYS_BLOCK}/${id}/device/model`) ?? udevValue(udev, "ID_MODEL")?.replace(/_/g, " ");
+  const vendor = readAttr(fs, `${SYS_BLOCK}/${id}/device/vendor`);
+  if (!vendor || GENERIC_VENDORS.has(vendor.toUpperCase())) return model;
+  if (!model) return vendor;
+  return model.startsWith(vendor) ? model : `${vendor} ${model}`;
+}
+
+export function diskKind(id: string, fs: Pick<LinuxFs, "read" | "list">, udev: ReadonlyMap<string, string>): DiskKind {
+  if (id.startsWith("nvme")) return "nvme";
+  if (id.startsWith("mmcblk")) return mmcKind(id, fs);
+  if (id.startsWith("sr")) return "optical";
+  const removable = readAttr(fs, `${SYS_BLOCK}/${id}/removable`) === "1";
+  // udisks2 answers MediaCompatibility::Thumb for these; the same drives are the
+  // removable ones on the USB bus, which udev already knows.
+  if (removable && udevValue(udev, "ID_BUS") === "usb") return "thumb";
+  const rotational = readAttr(fs, `${SYS_BLOCK}/${id}/queue/rotational`);
+  if (rotational === "0") return "ssd";
+  if (rotational === "1") return "hdd";
+  return "unknown";
+}
+
+/** The mmc host's `type` attribute is "SD" or "MMC". */
+function mmcKind(id: string, fs: Pick<LinuxFs, "read" | "list">): DiskKind {
+  const index = id.slice("mmcblk".length);
+  const host = `/sys/class/mmc_host/mmc${index}`;
+  for (const entry of fs.list(host) ?? []) {
+    if (!entry.startsWith(`mmc${index}`)) continue;
+    const type = readAttr(fs, `${host}/${entry}/type`);
+    if (type === "SD") return "sd";
+    if (type === "MMC") return "emmc";
+  }
+  return "unknown";
+}
+
+/** NVMe writes `wwid` on the namespace, SATA on the device; udev's `ID_WWN` is
+ *  cleaner than either and is preferred when present. A T10 identifier is built
+ *  by concatenating fixed-width ATA fields, so it arrives padded — the runs are
+ *  collapsed, since the value is shown to a person, not compared byte for byte. */
+function diskWwn(id: string, fs: Pick<LinuxFs, "read">, udev: ReadonlyMap<string, string>): string | undefined {
+  const raw = udevValue(udev, "ID_WWN")
+    ?? readAttr(fs, `${SYS_BLOCK}/${id}/wwid`)
+    ?? readAttr(fs, `${SYS_BLOCK}/${id}/device/wwid`);
+  return raw?.replace(/\s+/g, " ");
+}
+
+/** The drive behind `/`. mountinfo names the SOURCE path (`/dev/nvme0n1p2`), not
+ *  a disk, so it is resolved through sysfs: a partition's parent directory is its
+ *  disk, and a mapper device (LUKS, LVM, RAID) is followed through `slaves`. */
+export function findSystemDisk(fs: LinuxFs): string | undefined {
+  const source = rootMountSource(fs.read("/proc/self/mountinfo") ?? "");
+  if (!source) return undefined;
+  const node = fs.realpath(source) ?? source;
+  return wholeDiskOf(basename(node), fs, 0);
+}
+
+/** The `/` line's source device, or undefined when `/` is not a block mount. */
+export function rootMountSource(mountinfo: string): string | undefined {
+  for (const line of mountinfo.split("\n")) {
+    const fields = line.split(" ");
+    if (fields[4] !== "/") continue;
+    const sep = fields.indexOf("-", 6);
+    const source = sep >= 0 ? fields[sep + 2] : undefined;
+    if (source?.startsWith("/dev/")) return source;
+  }
+  return undefined;
+}
+
+function wholeDiskOf(name: string, fs: LinuxFs, depth: number): string | undefined {
+  if (!name || depth > MAX_SLAVE_DEPTH) return undefined;
+  const real = fs.realpath(`/sys/class/block/${name}`);
+  if (!real) return undefined;
+  if (fs.exists(`${real}/partition`)) return wholeDiskOf(basename(dirname(real)), fs, depth + 1);
+  for (const slave of fs.list(`${real}/slaves`) ?? []) {
+    const disk = wholeDiskOf(slave, fs, depth + 1);
+    if (disk) return disk;
+  }
+  return fs.exists(`${SYS_BLOCK}/${name}`) ? name : undefined;
+}
+
+const basename = (p: string) => p.slice(p.lastIndexOf("/") + 1);
+const dirname = (p: string) => p.slice(0, p.lastIndexOf("/"));
+
+function optional<K extends string>(key: K, value: string | undefined): Partial<Record<K, string>> {
+  return value === undefined ? {} : ({ [key]: value } as Record<K, string>);
+}

package/src/services/system-metrics/fans-linux.ts

@@ -0,0 +1,51 @@
+/**
+ * Mission Center's Fan page, from `/sys/class/hwmon`. A chip exposes `fanN_input`
+ * in RPM, an optional `pwmN` (0-255 duty) and often a `tempN_input` with the same
+ * index — Mission Center pairs them by index, which is what the board's own
+ * labelling means.
+ *
+ * Fans reading 0 are kept: a header with nothing plugged into it is information,
+ * and hiding it would make the list change length as a fan spins down.
+ */
+import type { FanMetrics } from "../../types/system-metrics.ts";
+import { readAttr, readNumber, realLinuxFs, type LinuxFs } from "./linux-fs.ts";
+
+export const HWMON_DIR = "/sys/class/hwmon";
+const PWM_MAX = 255;
+
+export function collectLinuxFans(fs: Pick<LinuxFs, "list" | "read"> = realLinuxFs): FanMetrics[] {
+  const fans: FanMetrics[] = [];
+  for (const chip of (fs.list(HWMON_DIR) ?? []).sort()) {
+    const dir = `${HWMON_DIR}/${chip}`;
+    const name = readAttr(fs, `${dir}/name`) ?? chip;
+    for (const index of fanIndices(fs, dir)) {
+      const rpm = readNumber(fs, `${dir}/fan${index}_input`);
+      if (rpm === undefined) continue;
+      const pwm = readNumber(fs, `${dir}/pwm${index}`);
+      const milliC = readNumber(fs, `${dir}/temp${index}_input`);
+      fans.push({
+        id: `${name}/fan${index}`,
+        label: readAttr(fs, `${dir}/fan${index}_label`) ?? `Fan ${index}`,
+        rpm: Math.max(0, Math.round(rpm)),
+        ...(pwm === undefined ? {} : { pwmPercent: Math.round(pwm / PWM_MAX * 1000) / 10 }),
+        ...(milliC === undefined ? {} : { tempC: Math.round(milliC / 100) / 10 }),
+        ...defined("tempName", readAttr(fs, `${dir}/temp${index}_label`)),
+      });
+    }
+  }
+  return fans;
+}
+
+/** The `N` of every `fanN_input` the chip publishes, ascending. */
+export function fanIndices(fs: Pick<LinuxFs, "list">, dir: string): number[] {
+  const indices: number[] = [];
+  for (const entry of fs.list(dir) ?? []) {
+    const m = /^fan(\d+)_input$/.exec(entry);
+    if (m) indices.push(Number(m[1]));
+  }
+  return indices.sort((a, b) => a - b);
+}
+
+function defined<K extends string, V>(key: K, value: V | undefined): Partial<Record<K, V>> {
+  return value === undefined ? {} : ({ [key]: value } as Record<K, V>);
+}