@glassmkr/crucible 0.7.1 → 0.8.0

package/src/collect/__tests__/system.test.ts

@@ -1,29 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { readOsReleaseField } from "../system.js";
-
-describe("readOsReleaseField", () => {
-  it("parses unquoted Ubuntu values", () => {
-    const s = 'NAME="Ubuntu"\nID=ubuntu\nID_LIKE=debian\nVERSION_ID="24.04"';
-    expect(readOsReleaseField(s, "ID")).toBe("ubuntu");
-    expect(readOsReleaseField(s, "ID_LIKE")).toBe("debian");
-  });
-
-  it("parses quoted RHEL-family values", () => {
-    const s = 'NAME="Rocky Linux"\nID="rocky"\nID_LIKE="rhel centos fedora"';
-    expect(readOsReleaseField(s, "ID")).toBe("rocky");
-    expect(readOsReleaseField(s, "ID_LIKE")).toBe("rhel centos fedora");
-  });
-
-  it("lowercases the result (some distros uppercase their ID)", () => {
-    expect(readOsReleaseField("ID=Alpine", "ID")).toBe("alpine");
-  });
-
-  it("returns undefined for a missing key", () => {
-    expect(readOsReleaseField("ID=arch", "ID_LIKE")).toBeUndefined();
-  });
-
-  it("does not confuse ID with VERSION_ID", () => {
-    const s = 'VERSION_ID="24.04"\nID=ubuntu';
-    expect(readOsReleaseField(s, "ID")).toBe("ubuntu");
-  });
-});

package/src/collect/__tests__/zfs.test.ts

@@ -1,72 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { parseZpoolStatus } from "../zfs.js";
-
-describe("parseZpoolStatus", () => {
-  it("parses a healthy pool", () => {
-    const raw = `  pool: tank
- state: ONLINE
-  scan: scrub repaired 0B in 01:23:45 with 0 errors on Sun Apr  5 12:34:56 2026
-config:
-
-        NAME        STATE     READ WRITE CKSUM
-        tank        ONLINE       0     0     0
-          mirror-0  ONLINE       0     0     0
-
-errors: No known data errors
-`;
-    const pools = parseZpoolStatus(raw);
-    expect(pools).toHaveLength(1);
-    expect(pools[0]).toMatchObject({
-      name: "tank",
-      state: "ONLINE",
-      errors_text: "No known data errors",
-      scrub_errors: 0,
-      scrub_repaired: "0B",
-    });
-    expect(pools[0].last_scrub_date).toContain("2026");
-  });
-
-  it("parses a DEGRADED pool", () => {
-    const raw = `  pool: tank
- state: DEGRADED
-  scan: scrub repaired 16K in 02:00:00 with 3 errors on Sun Apr  5 12:34:56 2026
-
-errors: 3 data errors, use '-v' for a list
-`;
-    const [p] = parseZpoolStatus(raw);
-    expect(p.state).toBe("DEGRADED");
-    expect(p.scrub_errors).toBe(3);
-    expect(p.scrub_repaired).toBe("16K");
-  });
-
-  it("flags never-scrubbed pools", () => {
-    const raw = `  pool: tank
- state: ONLINE
-  scan: none requested
-
-errors: No known data errors
-`;
-    const [p] = parseZpoolStatus(raw);
-    expect(p.scrub_never_run).toBe(true);
-    expect(p.scrub_errors).toBeUndefined();
-  });
-
-  it("returns empty for no pools", () => {
-    expect(parseZpoolStatus("no pools available")).toEqual([]);
-  });
-
-  it("parses multiple pools", () => {
-    const raw = `  pool: tank
- state: ONLINE
-  scan: none requested
-errors: No known data errors
-  pool: data
- state: FAULTED
-  scan: none requested
-errors: 2 data errors
-`;
-    const pools = parseZpoolStatus(raw);
-    expect(pools.map((p) => p.name)).toEqual(["tank", "data"]);
-    expect(pools[1].state).toBe("FAULTED");
-  });
-});

package/src/collect/conntrack.ts

@@ -1,27 +0,0 @@
-import { readProcFile } from "../lib/parse.js";
-
-export interface ConntrackData {
-  available: boolean;
-  count: number;
-  max: number;
-  percent: number;
-}
-
-export function collectConntrack(): ConntrackData {
-  const countRaw = readProcFile("/proc/sys/net/netfilter/nf_conntrack_count");
-  const maxRaw = readProcFile("/proc/sys/net/netfilter/nf_conntrack_max");
-
-  if (!countRaw || !maxRaw) {
-    return { available: false, count: 0, max: 0, percent: 0 };
-  }
-
-  const count = parseInt(countRaw.trim(), 10);
-  const max = parseInt(maxRaw.trim(), 10);
-
-  if (isNaN(count) || isNaN(max) || max === 0) {
-    return { available: false, count: 0, max: 0, percent: 0 };
-  }
-
-  const percent = Math.round(((count / max) * 100) * 10) / 10;
-  return { available: true, count, max, percent };
-}

package/src/collect/cpu.ts

@@ -1,92 +0,0 @@
-import { readProcFile, sleep } from "../lib/parse.js";
-import type { CpuInfo, CpuCoreInfo } from "../lib/types.js";
-
-interface CpuStat {
-  user: number; nice: number; system: number; idle: number;
-  iowait: number; irq: number; softirq: number; steal: number;
-}
-
-function parseLine(line: string): CpuStat {
-  const parts = line.split(/\s+/).slice(1).map(Number);
-  return {
-    user: parts[0] || 0, nice: parts[1] || 0, system: parts[2] || 0, idle: parts[3] || 0,
-    iowait: parts[4] || 0, irq: parts[5] || 0, softirq: parts[6] || 0, steal: parts[7] || 0,
-  };
-}
-
-function parseProcStat(): { aggregate: CpuStat; cores: CpuStat[] } {
-  const raw = readProcFile("/proc/stat") || "";
-  const lines = raw.split("\n");
-  const aggLine = lines.find((l) => l.startsWith("cpu "));
-  const aggregate = aggLine ? parseLine(aggLine) : { user: 0, nice: 0, system: 0, idle: 0, iowait: 0, irq: 0, softirq: 0, steal: 0 };
-
-  const cores: CpuStat[] = [];
-  for (const line of lines) {
-    if (/^cpu\d+\s/.test(line)) {
-      cores.push(parseLine(line));
-    }
-  }
-
-  return { aggregate, cores };
-}
-
-function calcPercents(d: CpuStat): { user: number; system: number; iowait: number; idle: number; irq: number; softirq: number } {
-  const total = Object.values(d).reduce((a, b) => a + b, 0) || 1;
-  const r = (v: number) => Math.round((v / total) * 10000) / 100;
-  return {
-    user: r(d.user + d.nice),
-    system: r(d.system),
-    iowait: r(d.iowait),
-    idle: r(d.idle),
-    irq: r(d.irq),
-    softirq: r(d.softirq),
-  };
-}
-
-function delta(a: CpuStat, b: CpuStat): CpuStat {
-  return {
-    user: b.user - a.user, nice: b.nice - a.nice,
-    system: b.system - a.system, idle: b.idle - a.idle,
-    iowait: b.iowait - a.iowait, irq: b.irq - a.irq,
-    softirq: b.softirq - a.softirq, steal: b.steal - a.steal,
-  };
-}
-
-export async function collectCpu(): Promise<CpuInfo> {
-  const stat1 = parseProcStat();
-  await sleep(1000);
-  const stat2 = parseProcStat();
-
-  const aggDelta = delta(stat1.aggregate, stat2.aggregate);
-  const agg = calcPercents(aggDelta);
-
-  const loadavg = (readProcFile("/proc/loadavg") || "0 0 0").trim().split(" ");
-
-  // Per-core stats
-  const cores: CpuCoreInfo[] = [];
-  const coreCount = Math.min(stat1.cores.length, stat2.cores.length);
-  for (let i = 0; i < coreCount; i++) {
-    const d = delta(stat1.cores[i], stat2.cores[i]);
-    const p = calcPercents(d);
-    cores.push({
-      core: i,
-      user_percent: p.user,
-      system_percent: p.system,
-      iowait_percent: p.iowait,
-      idle_percent: p.idle,
-      irq_percent: p.irq,
-      softirq_percent: p.softirq,
-    });
-  }
-
-  return {
-    user_percent: agg.user,
-    system_percent: agg.system,
-    iowait_percent: agg.iowait,
-    idle_percent: agg.idle,
-    load_1m: parseFloat(loadavg[0]) || 0,
-    load_5m: parseFloat(loadavg[1]) || 0,
-    load_15m: parseFloat(loadavg[2]) || 0,
-    cores,
-  };
-}

package/src/collect/disks.ts

@@ -1,91 +0,0 @@
-import { run } from "../lib/exec.js";
-import { readProcFile } from "../lib/parse.js";
-import type { DiskInfo } from "../lib/types.js";
-
-interface MountInfo {
-  device: string;
-  mount: string;
-  fstype: string;
-  options: string;
-}
-
-function parseMounts(): MountInfo[] {
-  const raw = readProcFile("/proc/mounts") || "";
-  const result: MountInfo[] = [];
-  for (const line of raw.split("\n")) {
-    const parts = line.split(" ");
-    if (parts.length < 4) continue;
-    result.push({
-      device: parts[0],
-      mount: parts[1],
-      fstype: parts[2],
-      options: parts[3],
-    });
-  }
-  return result;
-}
-
-export async function collectDisks(): Promise<DiskInfo[]> {
-  const dfOutput = await run("df", ["-B1", "--output=source,target,size,used,avail,pcent", "-x", "tmpfs", "-x", "devtmpfs", "-x", "squashfs"]);
-  if (!dfOutput) return [];
-
-  // Get inode data (df -i without --output, parse standard columns)
-  const dfInodeOutput = await run("df", ["-i", "-x", "tmpfs", "-x", "devtmpfs", "-x", "squashfs"]);
-  const inodeMap = new Map<string, { total: number; used: number; free: number }>();
-  if (dfInodeOutput) {
-    // Standard df -i output: Filesystem Inodes IUsed IFree IUse% Mounted_on
-    for (const line of dfInodeOutput.trim().split("\n").slice(1)) {
-      const parts = line.trim().split(/\s+/);
-      if (parts.length < 6) continue;
-      const mountPoint = parts[5];
-      inodeMap.set(mountPoint, {
-        total: parseInt(parts[1]) || 0,
-        used: parseInt(parts[2]) || 0,
-        free: parseInt(parts[3]) || 0,
-      });
-    }
-  }
-
-  // Get mount options and fstype from /proc/mounts
-  const mounts = parseMounts();
-  const mountMap = new Map<string, MountInfo>();
-  for (const m of mounts) {
-    mountMap.set(m.mount, m);
-  }
-
-  const lines = dfOutput.trim().split("\n").slice(1);
-  const disks: DiskInfo[] = [];
-
-  for (const line of lines) {
-    const parts = line.trim().split(/\s+/);
-    if (parts.length < 6) continue;
-    const device = parts[0];
-    const mount = parts[1];
-    const totalBytes = parseInt(parts[2]) || 0;
-    const usedBytes = parseInt(parts[3]) || 0;
-    const availBytes = parseInt(parts[4]) || 0;
-    const pctStr = parts[5].replace("%", "");
-    const percent = parseInt(pctStr) || 0;
-
-    if (!device.startsWith("/dev/")) continue;
-
-    const mountInfo = mountMap.get(mount);
-    const inodes = inodeMap.get(mount);
-
-    disks.push({
-      device,
-      mount,
-      total_gb: Math.round((totalBytes / 1073741824) * 100) / 100,
-      used_gb: Math.round((usedBytes / 1073741824) * 100) / 100,
-      available_gb: Math.round((availBytes / 1073741824) * 100) / 100,
-      percent_used: percent,
-      fstype: mountInfo?.fstype,
-      options: mountInfo?.options,
-      inodes_total: inodes?.total,
-      inodes_used: inodes?.used,
-      inodes_free: inodes?.free,
-    });
-  }
-
-  return disks;
-}

package/src/collect/fd.ts

@@ -1,31 +0,0 @@
-import { readProcFile } from "../lib/parse.js";
-
-export interface FileDescriptorData {
-  allocated: number;
-  free: number;
-  max: number;
-  percent: number;
-}
-
-export function collectFileDescriptors(): FileDescriptorData {
-  const raw = readProcFile("/proc/sys/fs/file-nr");
-  if (!raw) {
-    return { allocated: 0, free: 0, max: 0, percent: 0 };
-  }
-
-  const parts = raw.trim().split(/\s+/);
-  if (parts.length < 3) {
-    return { allocated: 0, free: 0, max: 0, percent: 0 };
-  }
-
-  const allocated = parseInt(parts[0], 10);
-  const free = parseInt(parts[1], 10);
-  const max = parseInt(parts[2], 10);
-
-  if (isNaN(allocated) || isNaN(max) || max === 0) {
-    return { allocated: 0, free: 0, max: 0, percent: 0 };
-  }
-
-  const percent = Math.round(((allocated / max) * 100) * 10) / 10;
-  return { allocated, free: isNaN(free) ? 0 : free, max, percent };
-}

package/src/collect/io-errors.ts

@@ -1,23 +0,0 @@
-import { run } from "../lib/exec.js";
-
-export async function collectIoErrors(): Promise<{ count: number; devices: string[] } | null> {
-  // Parse dmesg for recent I/O errors (last 10 minutes covers the 5-min collection interval)
-  const output = await run("bash", ["-c", 'dmesg -T --since "10 minutes ago" 2>/dev/null | grep -i "I/O error\\|Buffer I/O error\\|blk_update_request.*error"'], 5000);
-  if (!output || !output.trim()) return null;
-
-  const lines = output.trim().split("\n").filter((l) => l.trim());
-  if (lines.length === 0) return null;
-
-  // Extract device names from error messages
-  const deviceSet = new Set<string>();
-  for (const line of lines) {
-    // "blk_update_request: I/O error, dev sda, sector 12345"
-    const devMatch = line.match(/dev\s+(\w+)/);
-    if (devMatch) deviceSet.add(devMatch[1]);
-    // "Buffer I/O error on device sda1"
-    const bufMatch = line.match(/on device\s+(\w+)/);
-    if (bufMatch) deviceSet.add(bufMatch[1]);
-  }
-
-  return { count: lines.length, devices: Array.from(deviceSet) };
-}

package/src/collect/io-latency.ts

@@ -1,103 +0,0 @@
-import { readProcFile } from "../lib/parse.js";
-
-export interface IoLatencyInfo {
-  device: string;
-  avg_read_latency_ms: number | null;
-  avg_write_latency_ms: number | null;
-  read_iops: number;
-  write_iops: number;
-}
-
-interface DiskstatsCounters {
-  reads_completed: number;
-  read_time_ms: number;
-  writes_completed: number;
-  write_time_ms: number;
-}
-
-// Previous cumulative counters for delta computation
-const previousCounters = new Map<string, DiskstatsCounters>();
-
-// Match physical block devices, not partitions or virtual devices
-function isPhysicalDevice(name: string): boolean {
-  // sd*, vd*, xvd* without trailing partition number
-  if (/^(sd|vd|xvd)[a-z]+$/.test(name)) return true;
-  // nvme*n* without partition suffix (nvme0n1 yes, nvme0n1p1 no)
-  if (/^nvme\d+n\d+$/.test(name)) return true;
-  // md* (RAID arrays)
-  if (/^md\d+$/.test(name)) return true;
-  return false;
-}
-
-function parseDiskstats(): Record<string, DiskstatsCounters> {
-  const raw = readProcFile("/proc/diskstats") || "";
-  const result: Record<string, DiskstatsCounters> = {};
-
-  for (const line of raw.split("\n")) {
-    const parts = line.trim().split(/\s+/);
-    if (parts.length < 11) continue;
-
-    const name = parts[2];
-    if (!isPhysicalDevice(name)) continue;
-
-    result[name] = {
-      reads_completed: Number(parts[3]) || 0,
-      read_time_ms: Number(parts[6]) || 0,
-      writes_completed: Number(parts[7]) || 0,
-      write_time_ms: Number(parts[10]) || 0,
-    };
-  }
-
-  return result;
-}
-
-function delta(current: number, previous: number): number {
-  if (current >= previous) return current - previous;
-  return current; // counter wrapped or reset
-}
-
-export function collectIoLatency(): IoLatencyInfo[] {
-  const current = parseDiskstats();
-  const results: IoLatencyInfo[] = [];
-  const currentDevices = new Set<string>();
-
-  for (const [name, counters] of Object.entries(current)) {
-    currentDevices.add(name);
-    const prev = previousCounters.get(name);
-
-    // Store current for next cycle
-    previousCounters.set(name, { ...counters });
-
-    if (!prev) {
-      // First cycle: no delta, report null latency
-      results.push({
-        device: name,
-        avg_read_latency_ms: null,
-        avg_write_latency_ms: null,
-        read_iops: 0,
-        write_iops: 0,
-      });
-      continue;
-    }
-
-    const deltaReads = delta(counters.reads_completed, prev.reads_completed);
-    const deltaReadTime = delta(counters.read_time_ms, prev.read_time_ms);
-    const deltaWrites = delta(counters.writes_completed, prev.writes_completed);
-    const deltaWriteTime = delta(counters.write_time_ms, prev.write_time_ms);
-
-    results.push({
-      device: name,
-      avg_read_latency_ms: deltaReads > 0 ? Math.round((deltaReadTime / deltaReads) * 100) / 100 : null,
-      avg_write_latency_ms: deltaWrites > 0 ? Math.round((deltaWriteTime / deltaWrites) * 100) / 100 : null,
-      read_iops: deltaReads,
-      write_iops: deltaWrites,
-    });
-  }
-
-  // Remove stale devices
-  for (const name of previousCounters.keys()) {
-    if (!currentDevices.has(name)) previousCounters.delete(name);
-  }
-
-  return results;
-}

package/src/collect/ipmi.ts

@@ -1,207 +0,0 @@
-import { run } from "../lib/exec.js";
-import type { IpmiInfo, SelEvent, FanStatus } from "../lib/types.js";
-
-export async function collectIpmi(): Promise<IpmiInfo> {
-  const sensorRaw = await run("ipmitool", ["sensor"]);
-  if (!sensorRaw) {
-    return { available: false, sensors: [], ecc_errors: { correctable: 0, uncorrectable: 0 }, sel_entries_count: 0, sel_events_recent: [], fans: [] };
-  }
-
-  // Parse sensor readings
-  const sensors: IpmiInfo["sensors"] = [];
-  for (const line of sensorRaw.split("\n")) {
-    const parts = line.split("|").map((s) => s.trim());
-    if (parts.length < 4) continue;
-    const name = parts[0];
-    const rawValue = parts[1];
-    const unit = parts[2];
-    const status = parts[3];
-
-    const numValue = parseFloat(rawValue);
-    const value: number | string = isNaN(numValue) ? rawValue : numValue;
-
-    let upperCritical: number | undefined;
-    if (parts[8]) {
-      const uc = parseFloat(parts[8]);
-      if (!isNaN(uc)) upperCritical = uc;
-    }
-
-    sensors.push({ name, value, unit, status, upper_critical: upperCritical });
-  }
-
-  // ECC errors from memory-type sensors
-  let correctable = 0;
-  let uncorrectable = 0;
-  for (const sensor of sensors) {
-    const name = sensor.name.toLowerCase();
-    if (name.includes("correctable") && typeof sensor.value === "number") {
-      correctable += sensor.value;
-    }
-    if (name.includes("uncorrectable") && typeof sensor.value === "number") {
-      uncorrectable += sensor.value;
-    }
-  }
-
-  // SEL entry count
-  let selCount = 0;
-  const selInfo = await run("ipmitool", ["sel", "info"]);
-  if (selInfo) {
-    const match = selInfo.match(/Entries\s*:\s*(\d+)/i);
-    if (match) selCount = parseInt(match[1], 10);
-  }
-
-  // SEL recent events
-  const selEvents = await collectSelEvents();
-
-  // Fan status
-  const fans = await collectFanStatus();
-
-  return {
-    available: true,
-    sensors,
-    ecc_errors: { correctable, uncorrectable },
-    sel_entries_count: selCount,
-    sel_events_recent: selEvents,
-    fans,
-  };
-}
-
-async function collectSelEvents(): Promise<SelEvent[]> {
-  const output = await run("ipmitool", ["sel", "elist"]);
-  if (!output) return [];
-
-  const events: SelEvent[] = [];
-  const lines = output.trim().split("\n");
-  const fiveMinAgo = new Date(Date.now() - 5 * 60 * 1000);
-
-  for (const line of lines) {
-    const parts = line.split("|").map((s) => s.trim());
-    if (parts.length < 5) continue;
-
-    const [idStr, date, time, sensor, event, direction] = parts;
-
-    const timestamp = parseSelTimestamp(date, time);
-    const tsDate = new Date(timestamp);
-
-    // Only include events from the last 5 minutes on subsequent runs
-    // On first run this will include everything (fiveMinAgo is always recent)
-    // We keep last 20 events max regardless
-    const sensorType = classifySensor(sensor);
-    const severity = deriveSelSeverity(event, sensorType);
-
-    events.push({
-      id: parseInt(idStr) || 0,
-      timestamp,
-      sensor,
-      sensor_type: sensorType,
-      event,
-      direction: direction || "Asserted",
-      severity,
-    });
-  }
-
-  // Return last 20 events, most recent first
-  return events.slice(-20).reverse();
-}
-
-export function parseSelTimestamp(date: string, time: string): string {
-  if (!date || !time) return new Date().toISOString();
-  // Format: "04/05/2026" and "14:23:05"
-  const parts = date.split("/");
-  if (parts.length !== 3) return new Date().toISOString();
-  const [month, day, year] = parts;
-  return `${year}-${month.padStart(2, "0")}-${day.padStart(2, "0")}T${time}Z`;
-}
-
-export function classifySensor(sensor: string): string {
-  const lower = sensor.toLowerCase();
-  if (lower.includes("memory") || lower.includes("dimm")) return "memory";
-  if (lower.includes("power supply") || lower.includes("psu")) return "power";
-  if (lower.includes("fan")) return "fan";
-  if (lower.includes("watchdog")) return "watchdog";
-  if (lower.includes("processor") || lower.includes("cpu")) return "processor";
-  if (lower.includes("temperature") || lower.includes("temp")) return "temperature";
-  if (lower.includes("voltage")) return "voltage";
-  if (lower.includes("drive") || lower.includes("disk")) return "storage";
-  if (lower.includes("chassis") || lower.includes("intrusion")) return "chassis";
-  return "other";
-}
-
-export function deriveSelSeverity(event: string, sensorType: string): string {
-  const lower = event.toLowerCase();
-
-  // Critical events
-  if (lower.includes("uncorrectable")) return "critical";
-  if (lower.includes("failure detected")) return "critical";
-  if (lower.includes("ac lost")) return "critical";
-  if (lower.includes("hard reset")) return "critical";
-  if (lower.includes("power off")) return "critical";
-  if (lower.includes("critical")) return "critical";
-  if (lower.includes("non-recoverable")) return "critical";
-  if (lower.includes("thermal trip")) return "critical";
-  if (lower.includes("processor disabled")) return "critical";
-  if (lower.includes("machine check")) return "critical";
-
-  // Warning events
-  if (lower.includes("correctable ecc")) return "warning";
-  if (lower.includes("logging limit")) return "warning";
-  if (lower.includes("lower critical going low")) return "warning";
-  if (lower.includes("upper critical going high")) return "warning";
-  if (lower.includes("redundancy lost")) return "warning";
-  if (lower.includes("predictive failure")) return "warning";
-  if (lower.includes("degraded")) return "warning";
-
-  // Info events
-  if (lower.includes("presence detected")) return "info";
-  if (lower.includes("power cycle")) return "info";
-  if (lower.includes("oem")) return "info";
-
-  if (["memory", "power", "fan", "processor"].includes(sensorType)) return "warning";
-  return "info";
-}
-
-async function collectFanStatus(): Promise<FanStatus[]> {
-  const output = await run("ipmitool", ["sdr", "type", "Fan"]);
-  if (!output) return [];
-  return parseFanStatus(output);
-}
-
-export function parseFanStatus(output: string): FanStatus[] {
-  const fans: FanStatus[] = [];
-  const lines = output.trim().split("\n");
-
-  for (const line of lines) {
-    const parts = line.split("|").map((s) => s.trim());
-    if (parts.length < 3) continue;
-
-    const name = parts[0];
-    const fullLine = parts.join(" ");
-
-    let rpm = 0;
-    let status = "ok";
-
-    // Search all fields for RPM value (format varies by BMC)
-    const rpmMatch = fullLine.match(/(\d+)\s*RPM/i);
-    if (rpmMatch) {
-      rpm = parseInt(rpmMatch[1]);
-    }
-
-    // Check status codes across all fields
-    const hasNoReading = fullLine.toLowerCase().includes("no reading");
-    const statusCodes = parts.slice(1).map((p) => p.toLowerCase());
-    const hasCritical = statusCodes.some((s) => s === "cr" || s === "nr");
-    const hasWarning = statusCodes.some((s) => s === "nc");
-    const hasAbsent = statusCodes.some((s) => s === "ns") || hasNoReading;
-    const hasOk = statusCodes.some((s) => s === "ok");
-
-    if (hasCritical) status = "critical";
-    else if (hasWarning) status = "warning";
-    else if (hasAbsent) status = "absent";
-    else if (hasOk) status = "ok";
-    else if (rpm === 0 && !hasNoReading) status = "critical";
-
-    fans.push({ name, rpm, status });
-  }
-
-  return fans;
-}