@hienlh/ppm 0.23.10 → 0.23.11

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

@@ -0,0 +1,78 @@
+/** Every per-device darwin collector as one tick-shaped call: each drive, each
+ *  interface, each GPU and each fan, and the CPU page's live extras — thread and
+ *  open-file totals from the kernel, temperature, clock and power from the
+ *  sensors. The tools are the shared reads, so the Overview cards and the process
+ *  table computed a moment earlier in the same tick cost nothing more here. */
+import { collectDarwinCpuLive } from "./cpu-details-darwin.ts";
+import { darwinToolReads, type DarwinToolReads } from "./darwin-tool-reads.ts";
+import { collectDarwinDiskDevices, parseBlockDevices } from "./disk-devices-darwin.ts";
+import { collectDarwinNicDevices, parseIfconfig, parseNetstatLinks, parseServiceOrder } from "./net-devices-darwin.ts";
+import { darwinWifiStatus, type DarwinWifiStatus } from "./wifi-darwin.ts";
+import { darwinGpuCollector, toDarwinGpuMetrics, type DarwinGpuCollector, type DarwinGpuSensors } from "./gpu-darwin.ts";
+import { readDarwinSensors, type DarwinSensorReadings } from "./sensors-darwin.ts";
+import type { DeviceCollection, DeviceSampleState } from "./device-collector-types.ts";
+import type { CpuMetrics } from "../../types/system-metrics.ts";
+
+export interface DarwinDeviceSources {
+  reads: DarwinToolReads;
+  wifi: () => DarwinWifiStatus | undefined;
+  cpu: (sensors: DarwinSensorReadings) => Partial<CpuMetrics>;
+  /** The collector the process table reads too, so both see one `ioreg` a tick. */
+  gpu: DarwinGpuCollector;
+  sensors: () => Promise<DarwinSensorReadings>;
+}
+
+const DEFAULT_SOURCES: DarwinDeviceSources = {
+  reads: darwinToolReads(),
+  wifi: darwinWifiStatus,
+  cpu: (sensors) => collectDarwinCpuLive(undefined, sensors),
+  gpu: darwinGpuCollector(),
+  sensors: () => readDarwinSensors(),
+};
+
+/**
+ * A tool that failed this tick costs its list for the tick and keeps its
+ * baselines, so the next good read is measured over the longer interval rather
+ * than restarting at "measuring…".
+ */
+export async function collectDarwinDevices(
+  prev: DeviceSampleState,
+  sources: Partial<DarwinDeviceSources> = {},
+): Promise<DeviceCollection> {
+  const { reads, wifi, cpu, gpu, sensors } = { ...DEFAULT_SOURCES, ...sources };
+  // The sensors last: their reads block the thread for a few milliseconds, and
+  // started after the tools they run while those child processes do.
+  const [devices, netstat, ifconfig, services, gpuUsage, readings] = await Promise.all([
+    reads.blockDevices(), reads.netstat(), reads.ifconfig(), reads.serviceOrder(), gpu.usage(), sensors(),
+  ]);
+
+  const disks = devices
+    ? collectDarwinDiskDevices(parseBlockDevices(devices.value), devices.atSec, prev.disks, readings.driveC)
+    : { disks: [], next: prev.disks };
+  const nics = netstat && ifconfig
+    ? collectDarwinNicDevices(prev.nics, {
+      links: parseNetstatLinks(netstat.value),
+      atSec: netstat.atSec,
+      ifaces: parseIfconfig(ifconfig.value),
+      services: services ? parseServiceOrder(services.value) : undefined,
+      wifi: wifi(),
+    })
+    : { nics: [], next: prev.nics };
+
+  const accelerators = gpuUsage?.accelerators ?? [];
+  // Neither the SMC's GPU sensors nor IOReport's GPU channels say which GPU they
+  // measure, so they are only attributed where there is one GPU to attribute them
+  // to — every Apple Silicon Mac.
+  const gpuSensors: DarwinGpuSensors = accelerators.length === 1
+    ? { tempC: readings.gpuC, clockMHz: readings.gpuMHz, clockMaxMHz: readings.gpuMaxMHz, powerW: readings.gpuPowerW }
+    : {};
+
+  return {
+    disks: disks.disks,
+    nics: nics.nics,
+    fans: readings.fans,
+    cpu: cpu(readings),
+    gpus: accelerators.flatMap((a) => toDarwinGpuMetrics(a, gpuSensors) ?? []),
+    next: { ...prev, disks: disks.next, nics: nics.next },
+  };
+}

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

@@ -35,6 +35,7 @@ export interface DeviceCollection {
   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;
+/** Synchronous on Linux, where every source is a small sysfs read. A Mac has no
+ *  sysfs — its per-device figures come from tools like `ioreg` and `netstat` —
+ *  so a collector may also answer with a promise, which the tick awaits. */
+export type DeviceCollector = (prev: DeviceSampleState) => DeviceCollection | Promise<DeviceCollection>;

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

@@ -0,0 +1,194 @@
+/**
+ * Per-drive figures on macOS, from the IOKit registry. `ioreg` prints every block
+ * storage device as a small tree — the device (what the drive says it is), its
+ * `IOBlockStorageDriver` (which counts the I/O) and the whole-disk `IOMedia`
+ * (which carries the BSD name, "disk0") — so one call answers for every drive.
+ *
+ * Mounted disk images are block storage devices too, and are skipped the way
+ * Linux skips loop devices: reading a `.dmg` reads the file on the real drive,
+ * so counting both would count every byte twice. So is a device with no media
+ * under it — an empty card reader has nothing to measure.
+ *
+ * The counters are turned into the Linux sample shape so the arithmetic is the
+ * same function on both platforms (`toDiskMetrics`, Mission Center's). The one
+ * figure macOS cannot give is `io_ticks`, the time the device had any request in
+ * flight, which is what Linux's "Active time" is. What IOKit keeps instead is the
+ * time spent on each request, summed per request. Used in its place, busy % is an
+ * ESTIMATE: exact while requests do not overlap, and reaching 100% early once they
+ * do — an NVMe drive serving eight requests at once for a quarter of a second
+ * reports two seconds of request time, which is why the result is capped.
+ */
+import type { DiskMetrics } from "../../types/system-metrics.ts";
+import { toDiskMetrics, type DiskSample, type DiskSampleState } from "./disk-devices-linux.ts";
+import {
+  plistArray, plistBool, plistDict, plistNumber, plistString, type PlistDict, type PlistValue,
+} from "./plist-xml.ts";
+
+const SECTOR_BYTES = 512;
+const NS_PER_MS = 1e6;
+
+/** The driver's cumulative `Statistics`, since the device appeared. */
+export interface DarwinDiskStats {
+  readBytes: number;
+  writeBytes: number;
+  readOps: number;
+  writeOps: number;
+  /** Nanoseconds spent on requests, summed per request. */
+  readTimeNs: number;
+  writeTimeNs: number;
+}
+
+export interface DarwinBlockDevice {
+  /** BSD name of the whole disk, "disk0" — the key `DiskMetrics.id` and
+   *  `DiskInfo.id` use. */
+  id: string;
+  /** `Device Characteristics`, as the drive reports them. */
+  vendor?: string;
+  product?: string;
+  serial?: string;
+  /** "Solid State" or "Rotational"; absent on a card reader and most USB sticks. */
+  medium?: string;
+  /** `Protocol Characteristics`: "Apple Fabric", "PCI-Express", "USB",
+   *  "Secure Digital", "SATA", … and "Internal" / "External". */
+  interconnect?: string;
+  location?: string;
+  /** The device's IOKit class — "IOEmbeddedNVMeBlockDevice",
+   *  "IODVDBlockStorageDevice" — which names what the other fields leave out. */
+  ioClass?: string;
+  capacityBytes: number;
+  /** The media's own flags: a card or a stick can leave the reader (`removable`),
+   *  a USB SSD can leave the Mac (`ejectable`). */
+  removable: boolean;
+  ejectable: boolean;
+  stats: DarwinDiskStats;
+}
+
+/**
+ * Every physical drive in `ioreg -a -r -l -d 3 -c IOBlockStorageDevice`, sorted
+ * by BSD unit so "Disk 0" is disk0. A malformed entry is skipped, never thrown.
+ */
+export function parseBlockDevices(root: PlistValue | undefined): DarwinBlockDevice[] {
+  const out: DarwinBlockDevice[] = [];
+  for (const entry of plistArray(root) ?? []) {
+    const device = plistDict(entry);
+    if (!device) continue;
+    const protocol = plistDict(device["Protocol Characteristics"]);
+    const interconnect = text(protocol?.["Physical Interconnect"]);
+    const location = text(protocol?.["Physical Interconnect Location"]);
+    if (interconnect === "Virtual Interface" || location === "File") continue;
+
+    for (const driver of children(device)) {
+      const stats = plistDict(driver.Statistics);
+      const media = children(driver).find((m) => plistBool(m.Whole) === true && text(m["BSD Name"]));
+      if (!stats || !media) continue;
+      const characteristics = plistDict(device["Device Characteristics"]);
+      out.push({
+        id: text(media["BSD Name"])!,
+        ...optional("vendor", text(characteristics?.["Vendor Name"])),
+        ...optional("product", text(characteristics?.["Product Name"])),
+        ...optional("serial", text(characteristics?.["Serial Number"])),
+        ...optional("medium", text(characteristics?.["Medium Type"])),
+        ...optional("interconnect", interconnect),
+        ...optional("location", location),
+        ...optional("ioClass", text(device.IOObjectClass)),
+        capacityBytes: plistNumber(media.Size) ?? 0,
+        removable: plistBool(media.Removable) === true,
+        ejectable: plistBool(media.Ejectable) === true,
+        stats: {
+          readBytes: counter(stats, "Bytes (Read)"),
+          writeBytes: counter(stats, "Bytes (Write)"),
+          readOps: counter(stats, "Operations (Read)"),
+          writeOps: counter(stats, "Operations (Write)"),
+          readTimeNs: counter(stats, "Total Time (Read)"),
+          writeTimeNs: counter(stats, "Total Time (Write)"),
+        },
+      });
+    }
+  }
+  return out.sort((a, b) => a.id.localeCompare(b.id, undefined, { numeric: true }));
+}
+
+/**
+ * The Linux sample shape, from IOKit's counters. Bytes become 512-byte "sectors"
+ * only so `toDiskMetrics` can multiply them back — division by a power of two is
+ * exact in binary floating point, so no byte is lost either way. There is no
+ * discard or flush count on macOS; zero adds nothing to the sums.
+ */
+export function toDiskSample(stats: DarwinDiskStats, atSec: number): DiskSample {
+  const readTicks = stats.readTimeNs / NS_PER_MS;
+  const writeTicks = stats.writeTimeNs / NS_PER_MS;
+  return {
+    atSec,
+    readIos: stats.readOps, readSectors: stats.readBytes / SECTOR_BYTES, readTicks,
+    writeIos: stats.writeOps, writeSectors: stats.writeBytes / SECTOR_BYTES, writeTicks,
+    // The estimate described at the top of this file.
+    ioTicks: readTicks + writeTicks,
+    discardIos: 0, discardTicks: 0, flushIos: 0, flushTicks: 0,
+  };
+}
+
+export interface DarwinDiskCollection {
+  disks: DiskMetrics[];
+  next: DiskSampleState;
+}
+
+/** The IOKit class of an Apple Silicon Mac's built-in SSD. */
+export const EMBEDDED_NVME_CLASS = "IOEmbeddedNVMeBlockDevice";
+
+/**
+ * One tick's per-drive figures, each drive against its own previous sample.
+ *
+ * `internalTempC` is the built-in SSD's NAND temperature. The sensor names no
+ * disk, only that it is the internal flash, so it goes to the one drive that is
+ * the embedded NVMe device; with none, or with more than one, no drive gets it.
+ */
+export function collectDarwinDiskDevices(
+  devices: readonly DarwinBlockDevice[],
+  atSec: number,
+  prev: DiskSampleState,
+  internalTempC?: number,
+): DarwinDiskCollection {
+  const embedded = devices.filter((d) => d.ioClass === EMBEDDED_NVME_CLASS);
+  const tempOwner = internalTempC !== undefined && embedded.length === 1 ? embedded[0]!.id : undefined;
+  const next: DiskSampleState = new Map();
+  const disks = devices.map((device) => {
+    const sample = toDiskSample(device.stats, atSec);
+    next.set(device.id, sample);
+    return toDiskMetrics(device.id, prev.get(device.id) ?? null, sample, device.id === tempOwner ? internalTempC : undefined);
+  });
+  return { disks, next };
+}
+
+/** The whole-machine Disk card: the same drives the per-drive pages list, so the
+ *  card is their sum rather than a figure with disk images in it. */
+export function sumDiskCounters(devices: readonly DarwinBlockDevice[]): { inBytes: number; outBytes: number } | null {
+  if (devices.length === 0) return null;
+  let inBytes = 0;
+  let outBytes = 0;
+  for (const { stats } of devices) {
+    inBytes += stats.readBytes;
+    outBytes += stats.writeBytes;
+  }
+  return { inBytes, outBytes };
+}
+
+function children(node: PlistDict): PlistDict[] {
+  return (plistArray(node.IORegistryEntryChildren) ?? []).map(plistDict).filter((d): d is PlistDict => !!d);
+}
+
+/** A counter that is missing or not a number reads as 0: it only ever feeds a
+ *  delta, and a device that stops reporting one looks idle rather than broken. */
+function counter(stats: PlistDict, key: string): number {
+  const n = plistNumber(stats[key]);
+  return n !== undefined && n >= 0 ? n : 0;
+}
+
+/** SCSI and ATA fields are fixed-width and arrive padded; an empty one is absent. */
+function text(v: PlistValue | undefined): string | undefined {
+  const s = plistString(v)?.trim();
+  return s ? s : undefined;
+}
+
+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/disk-inventory-darwin.ts

@@ -0,0 +1,222 @@
+/**
+ * Static facts about each drive on macOS: model, kind, capacity, serial, which one
+ * holds the system, and its partitions with what is mounted on them.
+ *
+ * The drive list is the tick's own `ioreg` parse, so the inventory names exactly
+ * the drives the tick measures — the client refetches the inventory for as long
+ * as a tick names a drive it does not know. The partition table comes from
+ * `diskutil list -plist` and the mounts from `mount`, the Mac's mountinfo.
+ *
+ * APFS adds a layer Linux does not have between a partition and a mount: the
+ * partition is the physical store of a CONTAINER, and it is the container's
+ * volumes that are mounted — the internal SSD's one big partition carries `/`,
+ * `/System/Volumes/Data`, Preboot, VM and Update. Every volume shares the
+ * container's free space, so statfs on any of them answers for the whole
+ * container, and the partition gets one bar, the way a btrfs partition with
+ * several subvolumes does on Linux.
+ */
+import type { DiskInfo, DiskKind, PartitionInfo } from "../../types/system-hardware.ts";
+import { parseBlockDevices, type DarwinBlockDevice } from "./disk-devices-darwin.ts";
+import type { DarwinToolReads } from "./darwin-tool-reads.ts";
+import { attachPartitionUsage, type StatfsReader } from "./partitions-linux.ts";
+import { plistArray, plistDict, plistNumber, plistString, type PlistDict, type PlistValue } from "./plist-xml.ts";
+
+/** How far to follow volume → container → store before giving up. Two hops is
+ *  the real depth; the bound only stops a malformed layout from looping. */
+const MAX_DEPTH = 8;
+
+/** The kernel's transport names are not manufacturers — Linux's rule. */
+const GENERIC_VENDORS = new Set(["ATA", "SATA", "NVME", "USB", "SCSI"]);
+
+/** Partition types that name exactly one filesystem, for a partition nothing has
+ *  mounted — the question udev's `ID_FS_TYPE` answers on Linux. "Microsoft Basic
+ *  Data" is deliberately absent: it is exFAT, FAT32 or NTFS, and only a mount says
+ *  which. Names are the ones `mount` prints. */
+const CONTENT_FILESYSTEMS: Record<string, string> = {
+  Apple_APFS: "apfs",
+  Apple_APFS_ISC: "apfs",
+  Apple_APFS_Recovery: "apfs",
+  Apple_HFS: "hfs",
+  Apple_HFSX: "hfs",
+  EFI: "msdos",
+};
+
+export interface DiskutilPartition {
+  id: string;
+  /** The partition type: "Apple_APFS", "EFI", "Microsoft Basic Data", … */
+  content?: string;
+  sizeBytes: number;
+}
+
+/** The part of `diskutil list -plist` that says what sits on what. */
+export interface DiskutilLayout {
+  /** Whole disk → its partitions, in table order. A container is listed too,
+   *  with none. */
+  partitions: Map<string, DiskutilPartition[]>;
+  /** APFS container → the partitions it lives on (two for a Fusion drive). */
+  containerStores: Map<string, string[]>;
+  /** APFS volume, or a snapshot mounted in its place, → its container. */
+  volumeContainer: Map<string, string>;
+}
+
+export function parseDiskutilList(root: PlistValue | undefined): DiskutilLayout {
+  const layout: DiskutilLayout = { partitions: new Map(), containerStores: new Map(), volumeContainer: new Map() };
+  for (const value of plistArray(plistDict(root)?.AllDisksAndPartitions) ?? []) {
+    const entry = plistDict(value);
+    const id = plistString(entry?.DeviceIdentifier);
+    if (!entry || !id) continue;
+    const stores = ids(entry.APFSPhysicalStores, "DeviceIdentifier");
+    if (stores.length > 0) {
+      layout.containerStores.set(id, stores);
+      for (const volume of dicts(entry.APFSVolumes)) {
+        const volumeId = plistString(volume.DeviceIdentifier);
+        if (volumeId) layout.volumeContainer.set(volumeId, id);
+        for (const snapshot of ids(volume.MountedSnapshots, "SnapshotBSD")) layout.volumeContainer.set(snapshot, id);
+      }
+    }
+    layout.partitions.set(id, dicts(entry.Partitions).flatMap((p) => {
+      const partitionId = plistString(p.DeviceIdentifier);
+      if (!partitionId) return [];
+      const content = plistString(p.Content);
+      return [{ id: partitionId, ...(content ? { content } : {}), sizeBytes: plistNumber(p.Size) ?? 0 }];
+    }));
+  }
+  return layout;
+}
+
+/** One `/dev` mount as `mount` prints it. */
+export interface DarwinMount {
+  /** BSD name of the mounted device: "disk3s1", "disk3s3s1" for a snapshot. */
+  id: string;
+  mountPoint: string;
+  filesystem: string;
+}
+
+/**
+ * `mount` prints `<source> on <point> (<fstype>, <options…>)`, with the path
+ * unescaped — `/Volumes/My Drive (1)` arrives with its spaces and its own
+ * parentheses — so the point is everything up to the LAST parenthesised group.
+ * Anything not backed by a `/dev` node (devfs, autofs maps) is not a partition.
+ */
+export function parseMountTable(text: string): DarwinMount[] {
+  const out: DarwinMount[] = [];
+  for (const line of text.split("\n")) {
+    const m = /^\/dev\/(\S+) on (.+) \(([^,()]+)(?:,[^()]*)?\)$/.exec(line.trim());
+    if (m) out.push({ id: m[1]!, mountPoint: m[2]!, filesystem: m[3]!.trim() });
+  }
+  return out;
+}
+
+/** "vendor product", with a generic or repeated vendor dropped — Linux's rule. */
+export function darwinDiskModel({ vendor, product }: Pick<DarwinBlockDevice, "vendor" | "product">): string | undefined {
+  if (!vendor || GENERIC_VENDORS.has(vendor.toUpperCase())) return product;
+  if (!product) return vendor;
+  return product.toLowerCase().startsWith(vendor.toLowerCase()) ? product : `${vendor} ${product}`;
+}
+
+export function darwinDiskKind(d: Pick<DarwinBlockDevice, "interconnect" | "ioClass" | "medium" | "removable">): DiskKind {
+  const ioClass = d.ioClass ?? "";
+  if (d.interconnect === "Secure Digital") return "sd";
+  if (/(?:CD|DVD|BD)BlockStorageDevice/.test(ioClass)) return "optical";
+  // Apple Silicon's internal SSD is NVMe over the SoC fabric; an Intel Mac's and
+  // a Thunderbolt enclosure's are NVMe over PCIe. Both classes say so.
+  if (/NVMe/i.test(ioClass)) return "nvme";
+  // udisks2 calls these thumb drives; they are the removable-media ones on USB.
+  if (d.interconnect === "USB" && d.removable) return "thumb";
+  if (d.medium === "Solid State") return "ssd";
+  if (d.medium === "Rotational") return "hdd";
+  return "unknown";
+}
+
+/** The whole disk a device id lives on: a partition's owner, or for an APFS
+ *  volume the owner of its container's store. `/` is a snapshot of a volume, so
+ *  on a normal Mac that is snapshot → container → partition → disk. */
+export function wholeDiskOf(id: string, layout: DiskutilLayout, depth = 0): string | undefined {
+  if (depth > MAX_DEPTH) return undefined;
+  for (const [disk, parts] of layout.partitions) {
+    if (parts.some((p) => p.id === id)) return disk;
+  }
+  const container = layout.volumeContainer.get(id);
+  if (container !== undefined) {
+    for (const store of layout.containerStores.get(container) ?? []) {
+      const disk = wholeDiskOf(store, layout, depth + 1);
+      if (disk) return disk;
+    }
+    return undefined;
+  }
+  // A filesystem written straight onto a disk with no partition table.
+  return layout.partitions.has(id) && !layout.containerStores.has(id) ? id : undefined;
+}
+
+export function readDarwinPartitions(diskId: string, layout: DiskutilLayout, mounts: readonly DarwinMount[]): PartitionInfo[] {
+  return (layout.partitions.get(diskId) ?? []).map((part) => {
+    const container = [...layout.containerStores].find(([, stores]) => stores.includes(part.id))?.[0];
+    const devices = new Set(container === undefined ? [part.id] : volumesOf(container, layout));
+    const mine = mounts
+      .filter((m) => devices.has(m.id))
+      .sort((a, b) => a.mountPoint.localeCompare(b.mountPoint));
+    const filesystem = container !== undefined
+      ? "apfs"
+      : mine[0]?.filesystem ?? (part.content ? CONTENT_FILESYSTEMS[part.content] : undefined);
+    return {
+      id: part.id,
+      devicePath: `/dev/${part.id}`,
+      sizeBytes: part.sizeBytes,
+      ...(filesystem ? { filesystem } : {}),
+      mounts: mine.map((m) => ({ mountPoint: m.mountPoint, filesystem: m.filesystem })),
+    };
+  });
+}
+
+/**
+ * The inventory's drives, in the tick's order. Without `layout` (diskutil
+ * failed) partitions are left out rather than reported as none, and no drive is
+ * called the system disk.
+ */
+export function buildDarwinDiskInventory(
+  devices: readonly DarwinBlockDevice[],
+  layout: DiskutilLayout | undefined,
+  mounts: readonly DarwinMount[],
+): DiskInfo[] {
+  const root = mounts.find((m) => m.mountPoint === "/")?.id;
+  const systemDisk = layout && root ? wholeDiskOf(root, layout) : undefined;
+  return devices.map((d) => {
+    const model = darwinDiskModel(d);
+    return {
+      id: d.id,
+      ...(model ? { model } : {}),
+      kind: darwinDiskKind(d),
+      capacityBytes: d.capacityBytes,
+      systemDisk: d.id === systemDisk,
+      // A card leaving its reader, or a USB or Thunderbolt drive leaving the Mac.
+      removable: d.removable || d.ejectable,
+      ...(d.serial ? { serial: d.serial } : {}),
+      ...(layout ? { partitions: readDarwinPartitions(d.id, layout, mounts) } : {}),
+    };
+  });
+}
+
+/** The three tools in parallel, then statfs on every mount — async, off the
+ *  event loop, exactly as on Linux. */
+export async function readDarwinDiskInventory(reads: DarwinToolReads, statfs?: StatfsReader): Promise<DiskInfo[]> {
+  const [devices, layout, mounts] = await Promise.all([reads.blockDevices(), reads.diskutilList(), reads.mounts()]);
+  const disks = buildDarwinDiskInventory(
+    parseBlockDevices(devices?.value),
+    layout ? parseDiskutilList(layout.value) : undefined,
+    parseMountTable(mounts?.value ?? ""),
+  );
+  await attachPartitionUsage(disks, statfs);
+  return disks;
+}
+
+function volumesOf(container: string, layout: DiskutilLayout): string[] {
+  return [...layout.volumeContainer].filter(([, c]) => c === container).map(([volume]) => volume);
+}
+
+function dicts(v: PlistValue | undefined): PlistDict[] {
+  return (plistArray(v) ?? []).map(plistDict).filter((d): d is PlistDict => d !== undefined);
+}
+
+function ids(v: PlistValue | undefined, key: string): string[] {
+  return dicts(v).map((d) => plistString(d[key])).filter((s): s is string => !!s);
+}

package/src/services/system-metrics/disk-net-collector-darwin.ts

@@ -1,74 +1,26 @@
 /**
- * macOS disk + net cumulative counters via `ioreg` and `netstat -ib`.
- * Runner-injected; parsers are pure. UNVERIFIED on real macOS hardware — on any
- * parse failure the result is `null` (→ `available:false` + warning), never 0.
+ * macOS whole-machine disk + net counters, for the Overview's Disk and Network
+ * cards. They come out of the same `ioreg` and `netstat` reads the per-drive and
+ * per-interface pages use (`darwin-tool-reads.ts`), so a tick spawns each tool
+ * once and the card is the sum of the pages rather than a figure measured a few
+ * milliseconds apart. On a failed read the counter is `null` (→ `available:false`
+ * plus a warning), never 0.
  */
-import type { Runner } from "../host-info/spawn-runner.ts";
-import { defaultRunner } from "../host-info/spawn-runner.ts";
-import type { CounterSample } from "./rate-delta.ts";
 import type { DiskNetCounters } from "./disk-net-collector-linux.ts";
+import { darwinToolReads, type DarwinToolReads } from "./darwin-tool-reads.ts";
+import { parseBlockDevices, sumDiskCounters } from "./disk-devices-darwin.ts";
+import { parseNetstatLinks, sumNetCounters } from "./net-devices-darwin.ts";
 
-/** Sum every `"Bytes (Read)"=N` / `"Bytes (Write)"=N` pair from `ioreg -rc IOBlockStorageDriver -w0`. */
-export function parseIoregBytes(text: string): { inBytes: number; outBytes: number } | null {
-  let read = 0;
-  let written = 0;
-  let matched = false;
-  for (const m of text.matchAll(/"Bytes \((Read|Write)\)"\s*=\s*(\d+)/g)) {
-    const n = Number(m[2]);
-    if (!Number.isFinite(n)) continue;
-    matched = true;
-    if (m[1] === "Read") read += n;
-    else written += n;
-  }
-  return matched ? { inBytes: read, outBytes: written } : null;
-}
-
-/**
- * `netstat -ib` repeats an interface once per address family; only the
- * `<Link#N>` row (the first per interface) carries the hardware counters, so
- * summing every row would double-count. The Address column is blank on some
- * virtual interfaces, so Ibytes/Obytes are located from the right-hand end.
- */
-export function parseNetstatIb(text: string): { inBytes: number; outBytes: number } | null {
-  let rx = 0;
-  let tx = 0;
-  let matched = false;
-  const seen = new Set<string>();
-  for (const line of text.split("\n")) {
-    const f = line.trim().split(/\s+/);
-    if (f.length < 10) continue;
-    const iface = f[0]!;
-    if (iface === "Name" || iface.startsWith("lo") || seen.has(iface)) continue;
-    if (!(f[2] ?? "").startsWith("<Link#")) continue;
-    const ibytes = Number(f[f.length - 5]);
-    const obytes = Number(f[f.length - 2]);
-    if (!Number.isFinite(ibytes) || !Number.isFinite(obytes)) continue;
-    seen.add(iface);
-    matched = true;
-    rx += ibytes;
-    tx += obytes;
-  }
-  return matched ? { inBytes: rx, outBytes: tx } : null;
-}
-
-export async function collectDarwinDiskNet(run: Runner = defaultRunner, now: () => number = Date.now): Promise<DiskNetCounters> {
+export async function collectDarwinDiskNet(reads: DarwinToolReads = darwinToolReads()): Promise<DiskNetCounters> {
   const warnings: string[] = [];
-  const atSec = now() / 1000;
-  let disk: CounterSample | null = null;
-  let net: CounterSample | null = null;
+  const [devices, netstat] = await Promise.all([reads.blockDevices(), reads.netstat()]);
 
-  try {
-    const r = await run(["ioreg", "-rc", "IOBlockStorageDriver", "-w0"], 3000);
-    const parsed = r.code === 0 ? parseIoregBytes(r.stdout) : null;
-    if (parsed) disk = { ...parsed, atSec };
-  } catch { /* fall through to the warning */ }
-  if (!disk) warnings.push("Disk throughput unavailable: ioreg IOBlockStorageDriver statistics not readable");
+  const diskSum = devices ? sumDiskCounters(parseBlockDevices(devices.value)) : null;
+  const disk = diskSum && devices ? { ...diskSum, atSec: devices.atSec } : null;
+  if (!disk) warnings.push("Disk throughput unavailable: ioreg block storage statistics not readable");
 
-  try {
-    const r = await run(["netstat", "-ib"], 3000);
-    const parsed = r.code === 0 ? parseNetstatIb(r.stdout) : null;
-    if (parsed) net = { ...parsed, atSec };
-  } catch { /* fall through to the warning */ }
+  const netSum = netstat ? sumNetCounters(parseNetstatLinks(netstat.value)) : null;
+  const net = netSum && netstat ? { ...netSum, atSec: netstat.atSec } : null;
   if (!net) warnings.push("Network throughput unavailable: netstat -ib not readable");
 
   return { disk, net, warnings };