@glassmkr/crucible 0.7.1 → 0.8.1

package/src/alerts/state.ts

@@ -1,92 +0,0 @@
-import { readFileSync, writeFileSync, mkdirSync } from "fs";
-import type { AlertResult } from "../lib/types.js";
-
-const STATE_FILE = "/var/lib/glassmkr/alert-state.json";
-
-interface AlertState {
-  type: string;
-  first_seen: string;
-  last_seen: string;
-  notified: boolean;
-}
-
-let state: Map<string, AlertState> = new Map();
-
-function load() {
-  try {
-    const raw = readFileSync(STATE_FILE, "utf-8");
-    const data: Record<string, AlertState> = JSON.parse(raw);
-    state = new Map(Object.entries(data));
-  } catch {
-    state = new Map();
-  }
-}
-
-function save() {
-  try {
-    mkdirSync("/var/lib/glassmkr", { recursive: true });
-    const obj: Record<string, AlertState> = {};
-    for (const [k, v] of state) obj[k] = v;
-    writeFileSync(STATE_FILE, JSON.stringify(obj, null, 2));
-  } catch (err) {
-    console.error("[state] Failed to save alert state:", err);
-  }
-}
-
-// Initialize on import
-load();
-
-export function updateAlertState(currentAlerts: AlertResult[]): {
-  newAlerts: AlertResult[];
-  resolvedAlerts: AlertResult[];
-} {
-  const now = new Date().toISOString();
-  const currentTypes = new Set(currentAlerts.map((a) => a.type));
-  const newAlerts: AlertResult[] = [];
-  const resolvedAlerts: AlertResult[] = [];
-
-  // Check for new alerts
-  for (const alert of currentAlerts) {
-    const existing = state.get(alert.type);
-    if (!existing) {
-      // New alert
-      state.set(alert.type, { type: alert.type, first_seen: now, last_seen: now, notified: false });
-      newAlerts.push(alert);
-    } else {
-      // Existing alert, update last_seen
-      existing.last_seen = now;
-    }
-  }
-
-  // Check for resolved alerts
-  for (const [type, alertState] of state) {
-    if (!currentTypes.has(type)) {
-      resolvedAlerts.push({
-        type,
-        severity: "warning",
-        title: `Resolved: ${type}`,
-        message: `Condition cleared. Active for ${timeSince(alertState.first_seen)}.`,
-        evidence: {},
-        recommendation: "",
-      });
-      state.delete(type);
-    }
-  }
-
-  save();
-  return { newAlerts, resolvedAlerts };
-}
-
-function timeSince(isoDate: string): string {
-  const ms = Date.now() - new Date(isoDate).getTime();
-  const minutes = Math.floor(ms / 60000);
-  if (minutes < 60) return `${minutes} minute(s)`;
-  const hours = Math.floor(minutes / 60);
-  if (hours < 24) return `${hours} hour(s) ${minutes % 60} minute(s)`;
-  const days = Math.floor(hours / 24);
-  return `${days} day(s)`;
-}
-
-export function getActiveAlerts(): string[] {
-  return Array.from(state.keys());
-}

package/src/cli.ts

@@ -1,112 +0,0 @@
-// CLI argument handling for the Crucible binary. Runs before any config load
-// or collector initialization so --version and --help exit cleanly even when
-// the config file is missing or the host lacks the tools the collectors need.
-
-export type CliMode = "version" | "help" | "run" | "mark-reboot" | "reboot";
-
-export interface CliArgs {
-  mode: CliMode;
-  configPath: string;
-  reason?: string;
-  ttl?: string; // raw duration string, parsed by caller
-}
-
-export const DEFAULT_CONFIG_PATH = "/etc/glassmkr/collector.yaml";
-
-export function parseCliArgs(argv: string[], version: string): { result: CliArgs; output: string | null } {
-  // argv is typically process.argv.slice(2)
-  let configPath = DEFAULT_CONFIG_PATH;
-
-  // Subcommand dispatch: `mark-reboot` and `reboot` take their own flags
-  // (--reason, --ttl) but re-use --help.
-  if (argv[0] === "mark-reboot" || argv[0] === "reboot") {
-    const mode: "mark-reboot" | "reboot" = argv[0];
-    let reason: string | undefined;
-    let ttl: string | undefined;
-    for (let i = 1; i < argv.length; i++) {
-      const a = argv[i];
-      if (a === "--help" || a === "-h") {
-        return { result: { mode: "help", configPath: "" }, output: subcommandHelp(mode, version) };
-      }
-      if (a === "--reason") { reason = argv[++i]; continue; }
-      if (a.startsWith("--reason=")) { reason = a.slice("--reason=".length); continue; }
-      if (a === "--ttl") { ttl = argv[++i]; continue; }
-      if (a.startsWith("--ttl=")) { ttl = a.slice("--ttl=".length); continue; }
-    }
-    return { result: { mode, configPath: "", reason, ttl }, output: null };
-  }
-
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i];
-    if (arg === "--version" || arg === "-v") {
-      return { result: { mode: "version", configPath: "" }, output: `glassmkr-crucible v${version}` };
-    }
-    if (arg === "--help" || arg === "-h") {
-      return { result: { mode: "help", configPath: "" }, output: helpText(version) };
-    }
-    // -c <path> or --config <path>
-    if (arg === "-c" || arg === "--config") {
-      const next = argv[i + 1];
-      if (next) {
-        configPath = next;
-        i++;
-      }
-      continue;
-    }
-    // --config=<path>
-    if (arg.startsWith("--config=")) {
-      configPath = arg.slice("--config=".length);
-      continue;
-    }
-    // Legacy positional argument: first non-flag token
-    if (!arg.startsWith("-")) {
-      configPath = arg;
-    }
-  }
-
-  return { result: { mode: "run", configPath }, output: null };
-}
-
-export function helpText(version: string): string {
-  return [
-    `glassmkr-crucible v${version} - Bare metal server monitoring agent`,
-    "",
-    "Usage:",
-    "  glassmkr-crucible [options]",
-    "  glassmkr-crucible mark-reboot [--reason TEXT] [--ttl DURATION]",
-    "  glassmkr-crucible reboot      [--reason TEXT] [--ttl DURATION]",
-    "",
-    "Options:",
-    "  -v, --version    Print version and exit",
-    "  -h, --help       Print this help and exit",
-    `  -c, --config     Path to config file (default: ${DEFAULT_CONFIG_PATH})`,
-    "",
-    "Subcommands:",
-    "  mark-reboot      Write a planned-reboot marker so the next boot",
-    "                   does not fire `server_rebooted_unexpectedly`.",
-    "                   You run the reboot yourself afterwards.",
-    "  reboot           Write the marker, then invoke `systemctl reboot`.",
-    "",
-    "Without options, starts the collector daemon using the config file.",
-    "Docs: https://github.com/glassmkr/crucible",
-  ].join("\n");
-}
-
-function subcommandHelp(mode: "mark-reboot" | "reboot", version: string): string {
-  const action = mode === "reboot"
-    ? "Write a planned-reboot marker and invoke `systemctl reboot`."
-    : "Write a planned-reboot marker; operator triggers the reboot.";
-  return [
-    `glassmkr-crucible ${mode} - ${action}`,
-    "",
-    "Usage:",
-    `  glassmkr-crucible ${mode} [--reason TEXT] [--ttl DURATION]`,
-    "",
-    "Options:",
-    '  --reason TEXT    Free-text reason (e.g. "kernel update")',
-    "  --ttl DURATION   Expiry window; e.g. 5m, 10m, 1h (default 10m)",
-    "",
-    `Marker path: /var/lib/crucible/reboot-expected (requires root).`,
-    `v${version}`,
-  ].join("\n");
-}

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

@@ -1,96 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { classifySensor, deriveSelSeverity, parseSelTimestamp, parseFanStatus } from "../ipmi.js";
-
-describe("classifySensor", () => {
-  it("recognizes memory sensors", () => {
-    expect(classifySensor("DIMM_A1")).toBe("memory");
-    expect(classifySensor("Memory ECC")).toBe("memory");
-  });
-  it("recognizes power supplies", () => {
-    expect(classifySensor("PSU1 Status")).toBe("power");
-    expect(classifySensor("Power Supply 1")).toBe("power");
-  });
-  it("recognizes fans, watchdog, processors, temps, voltage, storage, chassis", () => {
-    expect(classifySensor("Fan1")).toBe("fan");
-    expect(classifySensor("Watchdog")).toBe("watchdog");
-    expect(classifySensor("Processor 0")).toBe("processor");
-    // CPU-named temperature sensors classify as processor (cpu check wins over temp).
-    expect(classifySensor("CPU1 Temp")).toBe("processor");
-    expect(classifySensor("Inlet Temp")).toBe("temperature");
-    expect(classifySensor("VCore Voltage")).toBe("voltage");
-    expect(classifySensor("Drive Slot 1")).toBe("storage");
-    expect(classifySensor("Chassis Intrusion")).toBe("chassis");
-  });
-  it("falls back to 'other'", () => {
-    expect(classifySensor("Weird Sensor")).toBe("other");
-  });
-});
-
-describe("deriveSelSeverity", () => {
-  it("treats uncorrectable, thermal trip, AC lost as critical", () => {
-    expect(deriveSelSeverity("Uncorrectable ECC", "memory")).toBe("critical");
-    expect(deriveSelSeverity("Thermal trip", "processor")).toBe("critical");
-    expect(deriveSelSeverity("AC lost", "power")).toBe("critical");
-    expect(deriveSelSeverity("Machine check", "processor")).toBe("critical");
-  });
-  it("treats correctable ECC and redundancy lost as warning", () => {
-    expect(deriveSelSeverity("Correctable ECC", "memory")).toBe("warning");
-    expect(deriveSelSeverity("Redundancy lost", "power")).toBe("warning");
-  });
-  it("treats presence detected as info", () => {
-    expect(deriveSelSeverity("Presence detected", "memory")).toBe("info");
-  });
-  it("defaults to warning for memory/power/fan/processor sensor types", () => {
-    expect(deriveSelSeverity("Some odd event", "memory")).toBe("warning");
-    expect(deriveSelSeverity("Some odd event", "fan")).toBe("warning");
-  });
-  it("defaults to info for other sensor types", () => {
-    expect(deriveSelSeverity("Some odd event", "other")).toBe("info");
-  });
-});
-
-describe("parseSelTimestamp", () => {
-  it("formats a known date/time", () => {
-    expect(parseSelTimestamp("04/05/2026", "14:23:05")).toBe("2026-04-05T14:23:05Z");
-  });
-  it("pads single digit month/day", () => {
-    expect(parseSelTimestamp("4/5/2026", "09:00:00")).toBe("2026-04-05T09:00:00Z");
-  });
-  it("returns an ISO string for bad input (does not crash)", () => {
-    const out = parseSelTimestamp("", "");
-    expect(typeof out).toBe("string");
-    expect(out.length).toBeGreaterThan(10);
-  });
-});
-
-describe("parseFanStatus", () => {
-  it("parses healthy fan output", () => {
-    const raw = [
-      "FAN1       | 30h | ok  |  7.1 | 5000 RPM",
-      "FAN2       | 31h | ok  |  7.2 | 5100 RPM",
-    ].join("\n");
-    const fans = parseFanStatus(raw);
-    expect(fans).toHaveLength(2);
-    expect(fans[0]).toMatchObject({ name: "FAN1", rpm: 5000, status: "ok" });
-    expect(fans[1].rpm).toBe(5100);
-  });
-
-  it("marks critical fans (cr/nr) as critical", () => {
-    const raw = "FAN1 | 30h | cr  | 7.1 | 0 RPM";
-    const fans = parseFanStatus(raw);
-    expect(fans[0].status).toBe("critical");
-  });
-
-  it("marks absent/no-reading fans as absent", () => {
-    const raw = "FAN3 | 30h | ns  | 7.1 | no reading";
-    const fans = parseFanStatus(raw);
-    expect(fans[0].status).toBe("absent");
-    expect(fans[0].rpm).toBe(0);
-  });
-
-  it("treats 0 RPM with no explicit status as critical", () => {
-    const raw = "FAN1 | 30h | 7.1 | 0 RPM";
-    const fans = parseFanStatus(raw);
-    expect(fans[0].status).toBe("critical");
-  });
-});

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

@@ -1,68 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { parseSmartctlJson } from "../smart.js";
-
-describe("parseSmartctlJson", () => {
-  it("parses a healthy SATA SSD", () => {
-    const data = {
-      model_name: "Samsung SSD 970 EVO 1TB",
-      smart_status: { passed: true },
-      temperature: { current: 38 },
-      power_on_time: { hours: 9000 },
-      ata_smart_attributes: {
-        table: [
-          { id: 5, name: "Reallocated_Sector_Ct", raw: { value: 0 } },
-          { id: 197, name: "Current_Pending_Sector", raw: { value: 0 } },
-        ],
-      },
-    };
-    const info = parseSmartctlJson(data, "/dev/sda");
-    expect(info).toMatchObject({
-      device: "/dev/sda",
-      model: "Samsung SSD 970 EVO 1TB",
-      health: "PASSED",
-      temperature_c: 38,
-      power_on_hours: 9000,
-      reallocated_sectors: 0,
-      pending_sectors: 0,
-    });
-  });
-
-  it("parses a failing SATA drive with reallocated sectors", () => {
-    const data = {
-      model_name: "WD Red 4TB",
-      smart_status: { passed: false },
-      ata_smart_attributes: {
-        table: [
-          { id: 5, raw: { value: 12 } },
-          { id: 197, raw: { value: 3 } },
-        ],
-      },
-    };
-    const info = parseSmartctlJson(data, "/dev/sdb");
-    expect(info.health).toBe("FAILED");
-    expect(info.reallocated_sectors).toBe(12);
-    expect(info.pending_sectors).toBe(3);
-  });
-
-  it("parses an NVMe drive with percentage_used", () => {
-    const data = {
-      model_name: "Samsung 980 PRO",
-      smart_status: { passed: true },
-      nvme_smart_health_information_log: { percentage_used: 22, temperature: 41 },
-    };
-    const info = parseSmartctlJson(data, "/dev/nvme0n1");
-    expect(info.percentage_used).toBe(22);
-    expect(info.temperature_c).toBe(41);
-    expect(info.health).toBe("PASSED");
-  });
-
-  it("falls back to 'unknown' model when absent", () => {
-    const info = parseSmartctlJson({ smart_status: { passed: true } }, "/dev/sdc");
-    expect(info.model).toBe("unknown");
-  });
-
-  it("treats missing smart_status as FAILED (safer default)", () => {
-    const info = parseSmartctlJson({}, "/dev/sdd");
-    expect(info.health).toBe("FAILED");
-  });
-});

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;
-}