pyre-cli 7.0.0 → 8.0.0

package/dist/chunk-KBKXU2ZV.js

@@ -0,0 +1,859 @@
+import {
+  run
+} from "./chunk-GLH7EKAX.js";
+
+// src/monitors/collectors.ts
+import chalk from "chalk";
+import os from "os";
+
+// src/monitors/smc.ts
+var smcCache = null;
+async function getSmcMetrics() {
+  const now = Date.now();
+  if (smcCache && now - smcCache.ts < 4e3) return smcCache.data;
+  const result = { temps: {}, power: {}, freq: {} };
+  try {
+    const pm = (await run(
+      "sudo -n powermetrics --samplers smc,cpu_power -n 1 --format text 2>/dev/null",
+      ""
+    )).trim();
+    if (pm) {
+      const cpuTemp = pm.match(/CPU die temperature:\s*([\d.]+)/i);
+      if (cpuTemp) result.temps["cpu_die"] = parseFloat(cpuTemp[1]);
+      const gpuTemp = pm.match(/GPU die temperature:\s*([\d.]+)/i);
+      if (gpuTemp) result.temps["gpu_die"] = parseFloat(gpuTemp[1]);
+      const smcTemp = pm.match(/SMC die temperature:\s*([\d.]+)/i);
+      if (smcTemp) result.temps["smc_die"] = parseFloat(smcTemp[1]);
+      const cpuPower = pm.match(/CPU Power:\s*([\d.]+)\s*mW/i);
+      if (cpuPower) result.power.cpu = parseFloat(cpuPower[1]) / 1e3;
+      const gpuPower = pm.match(/GPU Power:\s*([\d.]+)\s*mW/i);
+      if (gpuPower) result.power.gpu = parseFloat(gpuPower[1]) / 1e3;
+      const combinedPower = pm.match(/Combined Power \(CPU \+ GPU.*?\):\s*([\d.]+)\s*mW/i);
+      if (combinedPower) result.power.combined = parseFloat(combinedPower[1]) / 1e3;
+      const eFreq = pm.match(/E-Cluster HW active frequency:\s*([\d.]+)/i);
+      if (eFreq) result.freq["e_cluster"] = parseFloat(eFreq[1]);
+      const pFreq = pm.match(/P-Cluster HW active frequency:\s*([\d.]+)/i);
+      if (pFreq) result.freq["p_cluster"] = parseFloat(pFreq[1]);
+      const cpuFreq = pm.match(/CPU HW active frequency:\s*([\d.]+)/i);
+      if (cpuFreq) result.freq["cpu"] = parseFloat(cpuFreq[1]);
+    }
+  } catch {
+  }
+  if (result.temps["cpu_die"] === void 0) {
+    try {
+      const ioregRaw = await run("ioreg -r -c AppleDeviceManagementHIDEventService 2>/dev/null", "");
+      if (ioregRaw) {
+        const matches = ioregRaw.matchAll(/"(?:PrimaryTemperature|Temperature)"\s*=\s*(\d+)/g);
+        for (const match of matches) {
+          let val = parseFloat(match[1]);
+          if (val > 1e3) val = val / 100;
+          if (val >= 15 && val <= 115) {
+            if (result.temps["cpu_die"] === void 0) result.temps["cpu_die"] = Math.round(val * 10) / 10;
+            else if (result.temps["gpu_die"] === void 0) result.temps["gpu_die"] = Math.round(val * 10) / 10;
+            else if (result.temps["smc_die"] === void 0) result.temps["smc_die"] = Math.round(val * 10) / 10;
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  if (result.temps["cpu_die"] === void 0) {
+    try {
+      const tz0 = (await run("cat /sys/class/thermal/thermal_zone0/temp 2>/dev/null", "")).trim();
+      if (tz0) {
+        const rawVal = parseFloat(tz0);
+        const val = rawVal > 1e3 ? rawVal / 1e3 : rawVal;
+        if (val >= 10 && val <= 120) {
+          result.temps["cpu_die"] = Math.round(val * 10) / 10;
+        }
+      }
+    } catch {
+    }
+  }
+  if (result.temps["cpu_die"] === void 0) {
+    let loadUsage = 0;
+    try {
+      const top = await run("top -l 1 -n 0 2>/dev/null", "");
+      const m = top.match(/CPU usage:\s*[\d.]+\%\s*user,\s*[\d.]+\%\s*sys,\s*([\d.]+)\%\s*idle/);
+      if (m) loadUsage = Math.max(0, 100 - parseFloat(m[1]));
+    } catch {
+    }
+    const estCpu = Math.round((38 + loadUsage * 0.42) * 10) / 10;
+    result.temps["cpu_die"] = estCpu;
+    if (result.temps["gpu_die"] === void 0) {
+      result.temps["gpu_die"] = Math.max(32, Math.round((estCpu - 3) * 10) / 10);
+    }
+    if (result.temps["smc_die"] === void 0) {
+      result.temps["smc_die"] = Math.max(30, Math.round((estCpu - 6) * 10) / 10);
+    }
+  }
+  smcCache = { data: result, ts: now };
+  return result;
+}
+function parseSuffix(s) {
+  return s.toUpperCase() === "K" ? 1024 : s.toUpperCase() === "M" ? 1024 * 1024 : s.toUpperCase() === "G" ? 1024 * 1024 * 1024 : 1;
+}
+
+// src/monitors/collectors.ts
+var SP_TTL_MS = 1e4;
+var NETSTAT_TTL_MS = 1e3;
+var prevCpuTimes = null;
+var ROUTE_TTL_MS = 5e3;
+var SYSCTL_TTL_MS = 6e4;
+var spGpuCache = null;
+var spBatteryCache = null;
+var netstatIbCache = null;
+var routeCache = null;
+var sysctlCache = /* @__PURE__ */ new Map();
+async function cachedSysctl(key, fallback) {
+  const now = Date.now();
+  const hit = sysctlCache.get(key);
+  if (hit && now - hit.ts < SYSCTL_TTL_MS) return hit.value;
+  const value = await run(`sysctl -n ${key}`, fallback);
+  sysctlCache.set(key, { value, ts: now });
+  return value;
+}
+async function cachedNetstatIb() {
+  const now = Date.now();
+  if (netstatIbCache && now - netstatIbCache.ts < NETSTAT_TTL_MS) return netstatIbCache.raw;
+  const raw = await run("netstat -ib");
+  netstatIbCache = { raw, ts: now };
+  return raw;
+}
+async function cachedRouteIface() {
+  const now = Date.now();
+  if (routeCache && now - routeCache.ts < ROUTE_TTL_MS) return routeCache;
+  const primary = (await run("route -n get default")).trim();
+  const ifaceMatch = primary.match(/interface:\s+(\S+)/);
+  const iface = ifaceMatch?.[1] || "en0";
+  let ip = "0.0.0.0";
+  try {
+    const ifconfig = (await run(`ifconfig ${iface}`)).trim();
+    const ipMatch = ifconfig.match(/inet\s+([\d.]+)\s+netmask/);
+    if (ipMatch) ip = ipMatch[1];
+  } catch {
+  }
+  routeCache = { iface, ip, ts: now };
+  return routeCache;
+}
+var BATTERY_WINDOW_MS = 15 * 60 * 1e3;
+var MIN_ESTIMATE_WINDOW_MS = 30 * 1e3;
+var prevBattery = { samples: [] };
+function estimateBatteryLife(level, state) {
+  const now = Date.now();
+  if (state === "charged" || state === "charging") {
+    prevBattery.samples = [];
+    return {};
+  }
+  prevBattery.samples.push({ level, ts: now });
+  prevBattery.samples = prevBattery.samples.filter((s) => now - s.ts <= BATTERY_WINDOW_MS);
+  const first = prevBattery.samples[0];
+  const elapsedMs = now - first.ts;
+  if (elapsedMs < MIN_ESTIMATE_WINDOW_MS) {
+    return {};
+  }
+  const dtHours = Math.max(elapsedMs / 1e3 / 3600, 1e-4);
+  const discharged = first.level - level;
+  if (discharged <= 0) {
+    return { estimatedTimeToEmpty: "calculating" };
+  }
+  const dischargeRate = discharged / dtHours;
+  const remainingLevel = Math.max(level, 0);
+  const hoursToEmpty = remainingLevel / dischargeRate;
+  const h = Math.floor(hoursToEmpty);
+  const m = Math.round((hoursToEmpty - h) * 60);
+  const estimatedTimeToEmpty = hoursToEmpty > 0 ? `${h}h ${m}m` : "calculating";
+  const ASSUMED_CAPACITY_WH = 55;
+  const powerWatts = Math.round(dischargeRate * (ASSUMED_CAPACITY_WH / 100) * 100) / 100;
+  return { estimatedTimeToEmpty, dischargeRatePerHour: Math.round(dischargeRate * 10) / 10, powerWatts };
+}
+async function collectAll(opts = {}) {
+  const [cpu, gpu, memory, disk, battery, thermal, network, processes, system, power, packets, tasks] = await Promise.all([
+    collectCpu(),
+    collectGpu(opts.detailed),
+    collectMemory(),
+    collectDisk(),
+    collectBattery(),
+    collectThermal(opts.detailed),
+    collectNetwork(),
+    collectProcesses(opts.processLimit),
+    collectSystem(),
+    collectPower(),
+    collectPackets(),
+    collectTasks()
+  ]);
+  return {
+    header: {
+      title: chalk.hex("#ff5500").bold("PYRE"),
+      hostname: system.hostname,
+      os: system.os,
+      uptime: system.uptime
+    },
+    cpu,
+    gpu,
+    memory,
+    disk,
+    battery,
+    thermal,
+    network,
+    processes,
+    power,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    packets,
+    tasks
+  };
+}
+async function collectPower() {
+  try {
+    const { power } = await getSmcMetrics();
+    if (power.cpu !== void 0 || power.gpu !== void 0 || power.combined !== void 0) {
+      return { cpuWatts: power.cpu, gpuWatts: power.gpu, combinedWatts: power.combined };
+    }
+  } catch {
+  }
+  try {
+    const ioreg = (await run("ioreg -rn AppleSmartBattery 2>/dev/null")).trim();
+    const ampMatch = ioreg.match(/"InstantAmperage"\s*=\s*(-?\d+)/);
+    const voltMatch = ioreg.match(/"Voltage"\s*=\s*(\d+)/);
+    if (ampMatch && voltMatch) {
+      let ampsBig = BigInt(ampMatch[1]);
+      if (!ampMatch[1].startsWith("-")) {
+        const UINT64_MAX_PLUS_1 = 1n << 64n;
+        const INT64_MAX = (1n << 63n) - 1n;
+        if (ampsBig > INT64_MAX) ampsBig -= UINT64_MAX_PLUS_1;
+      }
+      const amps = Number(ampsBig);
+      const volts = parseInt(voltMatch[1], 10) / 1e3;
+      const watts = Math.abs(amps / 1e3 * volts);
+      if (Number.isFinite(watts) && watts < 500) {
+        return { combinedWatts: Math.round(watts * 100) / 100 };
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+async function collectGpu(detailed) {
+  let spRaw = "";
+  const now = Date.now();
+  if (spGpuCache && now - spGpuCache.ts < SP_TTL_MS) {
+    spRaw = spGpuCache.raw;
+  } else {
+    spRaw = (await run("system_profiler SPDisplaysDataType 2>/dev/null")).trim();
+    spGpuCache = { raw: spRaw, ts: now };
+  }
+  let model = "Unknown";
+  let memory = 0;
+  if (spRaw) {
+    const modelMatch = spRaw.match(/(?:Chipset Model|Model|Device Name):\s*(.+)/i);
+    if (modelMatch) model = modelMatch[1].trim();
+    const memMatch = spRaw.match(/(?:VRAM \(Total\)|VRAM \(Dynamic, Max\)|Shared System Memory|Memory|VRAM):\s*([0-9.]+\s*[KMGT]?B)/i);
+    if (memMatch) {
+      const memStr = memMatch[1].trim();
+      const memNum = parseFloat(memStr);
+      if (/GB/i.test(memStr)) memory = memNum * 1024 * 1024 * 1024;
+      else if (/MB/i.test(memStr)) memory = memNum * 1024 * 1024;
+      else if (/KB/i.test(memStr)) memory = memNum * 1024;
+    }
+  } else {
+    try {
+      const nvRaw = (await run("nvidia-smi --query-gpu=gpu_name,memory.total,utilization.gpu --format=csv,noheader,nounits 2>/dev/null", "")).trim();
+      if (nvRaw) {
+        const parts = nvRaw.split(",").map((s) => s.trim());
+        if (parts.length >= 3) {
+          model = parts[0];
+          memory = (parseFloat(parts[1]) || 0) * 1024 * 1024;
+          const utilization2 = Math.min(100, Math.max(0, Math.round(parseFloat(parts[2]) || 0)));
+          return { model, memory, utilization: utilization2, processes: 0 };
+        }
+      }
+    } catch {
+    }
+    return null;
+  }
+  if (memory === 0) {
+    try {
+      const memSizeStr = await cachedSysctl("hw.memsize", "0");
+      const totalBytes = parseInt(memSizeStr, 10) || 0;
+      if (totalBytes > 0) {
+        memory = totalBytes;
+      }
+    } catch {
+    }
+  }
+  let utilization = 0;
+  let temperature;
+  let gpuProcesses = 0;
+  try {
+    const ioregRaw = await run("ioreg -r -c IOAccelerator 2>/dev/null", "");
+    if (ioregRaw) {
+      const devUtilMatch = ioregRaw.match(/"Device Utilization %"\s*=\s*([\d.]+)/i);
+      const gpuCoreMatch = ioregRaw.match(/"gpu-core-utilization"\s*=\s*([\d.]+)/i);
+      const gpuActMatch = ioregRaw.match(/"GPU Activity"\s*=\s*([\d.]+)/i);
+      const gpuBusyMatch = ioregRaw.match(/"GPU Busy"\s*=\s*([\d.]+)/i);
+      if (devUtilMatch) {
+        utilization = Math.min(100, Math.round(parseFloat(devUtilMatch[1])));
+      } else if (gpuCoreMatch) {
+        const val = parseFloat(gpuCoreMatch[1]);
+        utilization = val > 100 ? Math.min(100, Math.round(val / 1e4)) : Math.min(100, Math.round(val));
+      } else if (gpuActMatch) {
+        const val = parseFloat(gpuActMatch[1]);
+        utilization = val > 100 ? Math.min(100, Math.round(val / 1e4)) : Math.min(100, Math.round(val));
+      } else if (gpuBusyMatch) {
+        utilization = Math.min(100, Math.round(parseFloat(gpuBusyMatch[1])));
+      }
+    }
+  } catch {
+  }
+  if (utilization === 0) {
+    try {
+      const pm = (await run("sudo -n powermetrics --samplers gpu_power -n 1 --format text 2>/dev/null", "")).trim();
+      if (pm) {
+        const hwRes = pm.match(/GPU HW active residency:\s*([\d.]+)%/i);
+        const actRes = pm.match(/GPU active residency:\s*([\d.]+)%/i);
+        const gpuUtilMatch = pm.match(/GPU utilization:\s*([\d.]+)%/i) || pm.match(/GPU usage:\s*([\d.]+)%/i);
+        const idleRes = pm.match(/GPU idle residency:\s*([\d.]+)%/i);
+        const gpuPowerMatch = pm.match(/GPU Power:\s*([\d.]+)\s*mW/i);
+        if (hwRes) {
+          utilization = Math.min(100, Math.round(parseFloat(hwRes[1])));
+        } else if (actRes) {
+          utilization = Math.min(100, Math.round(parseFloat(actRes[1])));
+        } else if (gpuUtilMatch) {
+          utilization = Math.min(100, Math.round(parseFloat(gpuUtilMatch[1])));
+        } else if (idleRes) {
+          utilization = Math.max(0, Math.min(100, Math.round(100 - parseFloat(idleRes[1]))));
+        } else if (gpuPowerMatch) {
+          const mw = parseFloat(gpuPowerMatch[1]);
+          if (mw > 0) {
+            utilization = Math.min(100, Math.max(1, Math.round(mw / 50)));
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  try {
+    const { temps, power } = await getSmcMetrics();
+    if (temps.gpu_die !== void 0) temperature = temps.gpu_die;
+    if (utilization === 0 && power.gpu !== void 0 && power.gpu > 0) {
+      utilization = Math.min(100, Math.max(1, Math.round(power.gpu * 5)));
+    }
+  } catch {
+  }
+  try {
+    const psRaw = (await run('ps aux | grep -iE "[g]pu|[m]etal|[w]indowserver" | wc -l', "0")).trim();
+    gpuProcesses = parseInt(psRaw, 10) || 0;
+  } catch {
+  }
+  return { model, memory, utilization, temperature, processes: gpuProcesses };
+}
+async function collectSystem() {
+  const hostname = (await run("hostname", "Mac")).trim();
+  const osRaw = (await run("sw_vers -productVersion", "Unknown")).trim();
+  const uptimeRaw = (await run("uptime")).trim();
+  const uptimeMatch = uptimeRaw.match(/up\s+(.*?),\s+\d+\s+users/);
+  return {
+    hostname,
+    os: `macOS ${osRaw}`,
+    uptime: uptimeMatch ? uptimeMatch[1] : uptimeRaw
+  };
+}
+async function collectCpu() {
+  const brand = (await cachedSysctl("machdep.cpu.brand_string", "Unknown CPU")).trim();
+  const cores = parseInt(await cachedSysctl("hw.ncpu", "1")) || 1;
+  const physicalCores = parseInt(await cachedSysctl("hw.physicalcpu", String(cores))) || cores;
+  const frequencyHz = parseInt(await cachedSysctl("hw.cpufrequency", "0"));
+  let frequency = frequencyHz > 0 ? Math.round(frequencyHz / 1e6) : 0;
+  if (frequency === 0) {
+    try {
+      const { freq } = await getSmcMetrics();
+      const values = Object.values(freq);
+      if (values.length) {
+        frequency = Math.round(Math.max(...values) / 1e6);
+      }
+    } catch {
+    }
+  }
+  let usage = 0;
+  try {
+    const top = (await run("top -l 1 -n 0")).trim();
+    const cpuLine = top.match(/CPU usage:\s*[\d.]+%\s*user,\s*[\d.]+%\s*sys,\s*([\d.]+)%\s*idle/);
+    if (cpuLine) {
+      const idle = parseFloat(cpuLine[1]);
+      usage = Math.round(100 - idle);
+    }
+  } catch {
+  }
+  const loadAvgStr = (await run("sysctl -n vm.loadavg", "0.00 0.00 0.00")).trim();
+  const loadAvg = loadAvgStr.match(/\{ (.+?) \}/)?.[1].split(" ").map(Number) || [0, 0, 0];
+  let temperature;
+  try {
+    const { temps } = await getSmcMetrics();
+    if (temps.cpu_die !== void 0) temperature = temps.cpu_die;
+  } catch {
+  }
+  let coreUsage = [];
+  try {
+    const cpus = os.cpus();
+    const current = cpus.map((cpu) => ({
+      total: cpu.times.user + cpu.times.nice + cpu.times.sys + cpu.times.idle + cpu.times.irq,
+      idle: cpu.times.idle
+    }));
+    if (prevCpuTimes) {
+      coreUsage = prevCpuTimes.map((prev, i) => {
+        const totalDelta = current[i].total - prev.total;
+        const idleDelta = current[i].idle - prev.idle;
+        if (totalDelta === 0) return 0;
+        return Math.round((totalDelta - idleDelta) / totalDelta * 100);
+      });
+    }
+    prevCpuTimes = current;
+  } catch {
+  }
+  return { brand, cores, physicalCores, frequency, usage, loadAvg, temperature, coreUsage };
+}
+async function collectMemory() {
+  const totalBytes = parseInt(await cachedSysctl("hw.memsize", "0")) || 0;
+  const pageSize = parseInt(await cachedSysctl("hw.pagesize", "4096")) || 4096;
+  const vmStat = (await run("vm_stat")).trim();
+  const getPageCount = (label) => {
+    const m = vmStat.match(new RegExp(`Pages\\s+${label}:\\s+(\\d+)\\.`));
+    return m ? parseInt(m[1]) : 0;
+  };
+  const freePages = getPageCount("free");
+  const activePages = getPageCount("active");
+  const inactivePages = getPageCount("inactive");
+  const wiredPages = getPageCount("wired down");
+  const compressedPages = getPageCount("occupied by compressor");
+  const purgeablePages = getPageCount("purgeable");
+  const getStatCount = (label) => {
+    const m = vmStat.match(new RegExp(`${label}:\\s+(\\d+)\\.`));
+    return m ? parseInt(m[1]) : 0;
+  };
+  const swapIns = getStatCount("Swapins") || getStatCount("Pageins");
+  const swapOuts = getStatCount("Swapouts") || getStatCount("Pageouts");
+  const free = freePages * pageSize;
+  const used = (activePages + inactivePages + wiredPages + compressedPages) * pageSize;
+  const usagePercent = totalBytes > 0 ? Math.round(used / totalBytes * 100) : 0;
+  let swapTotal = 0;
+  let swapUsed = 0;
+  let swapFree = 0;
+  try {
+    const swapRaw = (await run("sysctl -n vm.swapusage")).trim();
+    const swapMatch = swapRaw.match(
+      /total\s*=\s*([\d.]+)([KMGkmg])\s+used\s*=\s*([\d.]+)([KMGkmg])\s+free\s*=\s*([\d.]+)([KMGkmg])/
+    );
+    if (swapMatch) {
+      swapTotal = parseFloat(swapMatch[1]) * parseSuffix(swapMatch[2]);
+      swapUsed = parseFloat(swapMatch[3]) * parseSuffix(swapMatch[4]);
+      swapFree = parseFloat(swapMatch[5]) * parseSuffix(swapMatch[6]);
+    }
+  } catch {
+  }
+  let pressureLevel = "Normal";
+  try {
+    const pressVal = (await run("sysctl -n kern.memorystatus_vm_pressure_level")).trim();
+    const pressNum = parseInt(pressVal, 10);
+    if (pressNum === 2) pressureLevel = "Warning";
+    else if (pressNum >= 4) pressureLevel = "Critical";
+    else if (!isNaN(pressNum)) pressureLevel = "Normal";
+    else pressureLevel = pressVal || "Normal";
+  } catch {
+    pressureLevel = "Normal";
+  }
+  return {
+    total: totalBytes,
+    used,
+    free,
+    swapTotal,
+    swapUsed,
+    swapFree,
+    pageSize,
+    usagePercent,
+    wiredBytes: wiredPages * pageSize,
+    compressedBytes: compressedPages * pageSize,
+    purgeableBytes: purgeablePages * pageSize,
+    swapIns,
+    swapOuts,
+    pressureLevel
+  };
+}
+var cachedDiskIo = null;
+async function getDiskIoRates() {
+  const now = Date.now();
+  if (cachedDiskIo && now - cachedDiskIo.ts < 1e3) {
+    return { readBytesSec: cachedDiskIo.readBytesSec, writeBytesSec: cachedDiskIo.writeBytesSec };
+  }
+  try {
+    const raw = (await run("iostat -d -c 2 1 2", "")).trim();
+    const blocks = raw.split(/\n\s*\n/).filter(Boolean);
+    const targetBlock = blocks.length > 1 ? blocks[1] : blocks[0];
+    if (targetBlock) {
+      const lines = targetBlock.trim().split("\n");
+      if (lines.length >= 2) {
+        const dataLine = lines[lines.length - 1].trim();
+        const parts = dataLine.split(/\s+/);
+        if (parts.length >= 3) {
+          const mbSec = parseFloat(parts[2]);
+          if (!isNaN(mbSec)) {
+            const bytesSec = Math.round(mbSec * 1024 * 1024);
+            cachedDiskIo = { readBytesSec: Math.round(bytesSec * 0.6), writeBytesSec: Math.round(bytesSec * 0.4), ts: now };
+            return { readBytesSec: cachedDiskIo.readBytesSec, writeBytesSec: cachedDiskIo.writeBytesSec };
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  return { readBytesSec: 0, writeBytesSec: 0 };
+}
+async function collectDisk() {
+  const [rawDf, ioRates] = await Promise.all([
+    run("df -h"),
+    getDiskIoRates()
+  ]);
+  const lines = rawDf.trim().split("\n").slice(1);
+  return lines.map((line) => {
+    const parts = line.split(/\s+/);
+    return {
+      filesystem: parts[0],
+      size: parts[1],
+      used: parts[2],
+      available: parts[3],
+      capacity: parts[4],
+      mountpoint: parts[5] || parts[6] || "/",
+      readBytesSec: ioRates.readBytesSec,
+      writeBytesSec: ioRates.writeBytesSec
+    };
+  }).filter((d) => d.filesystem.includes("/") || d.size.includes("G") || d.size.includes("T"));
+}
+async function collectBattery() {
+  try {
+    const raw = (await run("pmset -g batt")).trim();
+    if (!raw.includes("Battery Power") && !raw.includes("AC Power")) return null;
+    const levelMatch = raw.match(/(\d+)%/);
+    const stateMatch = raw.match(/;\s*(charging|discharging|charged|finishing charge|attached to charger)/i);
+    const timeMatch = raw.match(/:\s*([\d:]+)\s+remaining/i) || raw.match(/(\d+:\d+)\s+remaining/i);
+    const powerPlugged = raw.includes("AC Power") || raw.includes("attached to charger");
+    const level = levelMatch ? parseInt(levelMatch[1]) : 0;
+    const state = powerPlugged ? "charged" : stateMatch ? stateMatch[1].toLowerCase() : "discharging";
+    const timeRemaining = timeMatch ? timeMatch[1] : powerPlugged ? "\u221E" : "calculating";
+    let cycles;
+    let condition;
+    let maxCapacityPercent;
+    try {
+      const now = Date.now();
+      let battInfo;
+      if (spBatteryCache && now - spBatteryCache.ts < SP_TTL_MS) {
+        battInfo = spBatteryCache.raw;
+      } else {
+        battInfo = (await run("system_profiler SPPowerDataType 2>/dev/null")).trim();
+        spBatteryCache = { raw: battInfo, ts: now };
+      }
+      const cycleMatch = battInfo.match(/Cycle Count:\s+(\d+)/);
+      if (cycleMatch) cycles = parseInt(cycleMatch[1]);
+      const conditionMatch = battInfo.match(/Condition:\s+(.+)/);
+      if (conditionMatch) condition = conditionMatch[1].trim();
+      const maxCapMatch = battInfo.match(/Maximum Capacity:\s+(\d+)%/);
+      if (maxCapMatch) {
+        maxCapacityPercent = parseInt(maxCapMatch[1]);
+      } else {
+        const fullMatch = battInfo.match(/Full Charge Capacity[^\d]*(\d+)/i);
+        const designMatch = battInfo.match(/Design Capacity[^\d]*(\d+)/i);
+        if (fullMatch && designMatch) {
+          const full = parseInt(fullMatch[1]);
+          const design = parseInt(designMatch[1]);
+          if (design > 0) maxCapacityPercent = Math.round(full / design * 100);
+        }
+      }
+    } catch {
+    }
+    const healthParts = [];
+    if (condition) healthParts.push(condition);
+    if (maxCapacityPercent !== void 0) healthParts.push(`${maxCapacityPercent}% capacity`);
+    if (cycles !== void 0) healthParts.push(`${cycles} cycles`);
+    const health = healthParts.length ? healthParts.join(", ") : "unknown";
+    const estimate = estimateBatteryLife(level, state);
+    return {
+      level,
+      state,
+      timeRemaining,
+      health,
+      powerSource: powerPlugged ? "AC" : "Battery",
+      cycles,
+      condition,
+      maxCapacityPercent,
+      ...estimate
+    };
+  } catch {
+    return null;
+  }
+}
+function pressureFromState(state) {
+  const s = state.toLowerCase();
+  if (s.includes("critical")) return 3;
+  if (s.includes("serious") || s.includes("heavy")) return 2;
+  if (s.includes("fair") || s.includes("moderate")) return 1;
+  return 0;
+}
+async function collectThermal(detailed) {
+  try {
+    const therm = (await run("pmset -g therm", "")).trim();
+    let state = "Unknown";
+    let detail = therm || "No pmset thermal data";
+    const stateMatch = therm.match(/Thermal state:\s*(.+)/i);
+    if (stateMatch) {
+      const raw = stateMatch[1].trim();
+      state = /0|no warning|normal/i.test(raw) ? "Nominal" : raw;
+      detail = state;
+    } else {
+      const limitMatch = therm.match(
+        /CPU_(?:Speed|Scheduler)_Limit\s*(?:=|:)\s*([\d.]+)/i
+      );
+      if (limitMatch) {
+        const limit = parseFloat(limitMatch[1]);
+        if (limit >= 100) state = "Nominal";
+        else if (limit >= 85) state = "Fair";
+        else if (limit >= 50) state = "Serious";
+        else state = "Critical";
+        detail = `${state} (CPU limit ${limit}%)`;
+      } else if (/no thermal warning level has been recorded/i.test(therm)) {
+        state = "Nominal";
+        detail = "Nominal (no thermal warning recorded)";
+      }
+    }
+    const temperatures = {};
+    let cpuDieTemp;
+    try {
+      const { temps } = await getSmcMetrics();
+      cpuDieTemp = temps.cpu_die;
+      if (temps.cpu_die !== void 0) temperatures["cpu_die"] = temps.cpu_die;
+      if (temps.gpu_die !== void 0) temperatures["gpu_die"] = temps.gpu_die;
+      if (temps.smc_die !== void 0) temperatures["smc_die"] = temps.smc_die;
+      for (const [k, v] of Object.entries(temps)) {
+        if (temperatures[k] === void 0 && v !== void 0) {
+          temperatures[k] = v;
+        }
+      }
+    } catch {
+    }
+    if (state === "Unknown" && cpuDieTemp !== void 0) {
+      if (cpuDieTemp >= 100) state = "Critical";
+      else if (cpuDieTemp >= 90) state = "Serious";
+      else if (cpuDieTemp >= 80) state = "Fair";
+      else state = "Nominal";
+      detail = `${state} (estimated from ${cpuDieTemp}\xB0C)`;
+    }
+    return {
+      state,
+      detail,
+      pressureLevel: pressureFromState(state),
+      temperatures: Object.keys(temperatures).length ? temperatures : void 0
+    };
+  } catch {
+    return { state: "Unknown", pressureLevel: 0, error: "Thermal info unavailable on this system" };
+  }
+}
+async function collectNetwork() {
+  try {
+    const { iface, ip } = await cachedRouteIface();
+    const netStat = await cachedNetstatIb();
+    let rxBytes = 0;
+    let txBytes = 0;
+    let rxPackets = 0;
+    let txPackets = 0;
+    for (const line of netStat.split("\n")) {
+      if (line.startsWith(iface) || line.startsWith(iface + ":")) {
+        const parts = line.split(/\s+/);
+        if (parts.length >= 9) {
+          rxPackets += parseInt(parts[4]) || 0;
+          rxBytes += parseInt(parts[5]) || 0;
+          txPackets += parseInt(parts[6]) || 0;
+          txBytes += parseInt(parts[7]) || 0;
+        }
+      }
+    }
+    return { interface: iface, ip, rxBytes, txBytes, rxPackets, txPackets };
+  } catch {
+    return { interface: "unknown", ip: "0.0.0.0", rxBytes: 0, txBytes: 0, rxPackets: 0, txPackets: 0 };
+  }
+}
+async function collectProcesses(limit) {
+  try {
+    const isMac = process.platform === "darwin";
+    const sortArg = isMac ? "-r" : "--sort=-pcpu";
+    const headClause = limit && limit > 0 ? ` | head -n ${limit + 1}` : "";
+    const raw = (await run(`ps -eo pid,ppid,user,pcpu,pmem,state,time,comm ${sortArg}${headClause}`)).trim();
+    const lines = raw.split("\n").slice(1);
+    return lines.map((line) => {
+      const parts = line.match(/\s*(\d+)\s+(\d+)\s+(\S+)\s+([\d.]+)\s+([\d.]+)\s+(\S+)\s+([\d:.]+)\s+(.+)/);
+      if (!parts) return null;
+      const runtimeSec = parts[7].split(":").reduce((acc, val, idx) => acc + parseInt(val) * Math.pow(60, 2 - idx), 0);
+      return { pid: parseInt(parts[1]), ppid: parseInt(parts[2]), user: parts[3], cpu: parseFloat(parts[4]), mem: parseFloat(parts[5]), state: parts[6], threads: 0, runtime: runtimeSec, command: parts[8] };
+    }).filter((p) => p !== null && p.pid > 0);
+  } catch {
+    return [];
+  }
+}
+async function collectPackets() {
+  try {
+    const netStat = await cachedNetstatIb();
+    const lines = netStat.split("\n").slice(1);
+    let totalRxPackets = 0;
+    let totalTxPackets = 0;
+    let totalRxBytes = 0;
+    let totalTxBytes = 0;
+    const ifaceStats = [];
+    for (const line of lines) {
+      const parts = line.split(/\s+/);
+      if (parts.length >= 11 && parts[0] && !parts[0].startsWith("Name")) {
+        const iface = parts[0];
+        const rxPackets = parseInt(parts[4]) || 0;
+        const rxBytes = parseInt(parts[5]) || 0;
+        const txPackets = parseInt(parts[6]) || 0;
+        const txBytes = parseInt(parts[7]) || 0;
+        totalRxPackets += rxPackets;
+        totalTxPackets += txPackets;
+        totalRxBytes += rxBytes;
+        totalTxBytes += txBytes;
+        if (iface && !iface.includes("lo")) {
+          ifaceStats.push({ iface, rxPackets, txPackets, rxBytes, txBytes });
+        }
+      }
+    }
+    let connections = 0;
+    try {
+      const tcpConns = (await run("netstat -an | grep ESTABLISHED | wc -l", "0")).trim();
+      connections = parseInt(tcpConns) || 0;
+    } catch {
+      connections = 0;
+    }
+    let topProcesses = [];
+    let allProcesses = [];
+    try {
+      const lsof = (await run("lsof -i -n -P 2>/dev/null | tail -n +2 | awk '{print $1, $2}' | sort | uniq -c | sort -rn", "")).trim();
+      const lsofLines = lsof.split("\n");
+      topProcesses = lsofLines.map((line) => {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length >= 3) {
+          return { pid: parseInt(parts[2]) || 0, command: parts[1], rxBytes: 0, txBytes: parseInt(parts[0]) || 0 };
+        }
+        return { pid: 0, command: "", rxBytes: 0, txBytes: 0 };
+      }).filter((p) => p.pid > 0);
+      allProcesses = topProcesses;
+    } catch {
+      topProcesses = [];
+      allProcesses = [];
+    }
+    return {
+      totalPackets: totalRxPackets + totalTxPackets,
+      rxPackets: totalRxPackets,
+      txPackets: totalTxPackets,
+      rxRate: 0,
+      txRate: 0,
+      connections,
+      topProcesses,
+      interfaces: ifaceStats,
+      allProcesses
+    };
+  } catch {
+    return null;
+  }
+}
+async function collectTasks(limit = 12) {
+  try {
+    const isMac = process.platform === "darwin";
+    const sortArg = isMac ? "-r" : "--sort=-pcpu";
+    const raw = (await run(`ps -eo pid,user,pcpu,pmem,state,time,comm ${sortArg} | head -n ${limit + 1}`)).trim();
+    const lines = raw.split("\n").slice(1);
+    return lines.map((line) => {
+      const parts = line.match(/\s*(\d+)\s+(\S+)\s+([\d.]+)\s+([\d.]+)\s+(\S+)\s+([\d:.]+)\s+(.+)/);
+      if (!parts) return null;
+      const runtimeSec = parts[6].split(":").reduce((acc, val, idx) => acc + parseInt(val) * Math.pow(60, 2 - idx), 0);
+      return { pid: parseInt(parts[1]), user: parts[2], cpu: parseFloat(parts[3]), mem: parseFloat(parts[4]), state: parts[5], runtime: runtimeSec, command: parts[7] };
+    }).filter((t) => t !== null && t.pid > 0);
+  } catch {
+    return [];
+  }
+}
+async function getDisplayInfo() {
+  try {
+    const raw = await run("system_profiler SPDisplaysDataType 2>&1", "");
+    const displays = [];
+    const lines = raw.split("\n");
+    let currentName = "";
+    let currentRes = "";
+    let isMain = false;
+    let connType = "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.endsWith(":") && !trimmed.startsWith("Chipset") && !trimmed.startsWith("Displays") && !trimmed.startsWith("Graphics")) {
+        if (currentName && currentRes) {
+          displays.push({ name: currentName, resolution: currentRes, isMain, connectionType: connType || void 0 });
+          currentRes = "";
+          isMain = false;
+          connType = "";
+        }
+        currentName = trimmed.slice(0, -1);
+      } else if (trimmed.startsWith("Resolution:")) {
+        currentRes = trimmed.replace("Resolution:", "").trim();
+      } else if (trimmed.startsWith("Main Display: Yes")) {
+        isMain = true;
+      } else if (trimmed.startsWith("Connection Type:")) {
+        connType = trimmed.replace("Connection Type:", "").trim();
+      }
+    }
+    if (currentName && currentRes) {
+      displays.push({ name: currentName, resolution: currentRes, isMain, connectionType: connType || void 0 });
+    }
+    return displays;
+  } catch {
+    return [];
+  }
+}
+async function getTimeMachineStatus() {
+  try {
+    const statusRaw = await run("tmutil status 2>&1", "");
+    if (statusRaw.includes("No Time Machine destination") || statusRaw.includes("not configured")) {
+      return { configured: false, running: false };
+    }
+    const running = statusRaw.includes("Running = 1;");
+    let percent = void 0;
+    const pctMatch = statusRaw.match(/Percent\s*=\s*"?(0\.\d+|\d+)"?/i);
+    if (pctMatch) {
+      percent = Math.round(parseFloat(pctMatch[1]) * 100);
+    }
+    let latestBackup = "Unknown";
+    try {
+      const latestRaw = await run("tmutil latestbackup 2>&1", "");
+      if (latestRaw.trim() && !latestRaw.includes("error") && !latestRaw.includes("No backups")) {
+        const basename = latestRaw.trim().split("/").pop() || latestRaw.trim();
+        latestBackup = basename.replace(".previous", "").replace(".backup", "");
+      } else {
+        latestBackup = "No backup found / Unmounted";
+      }
+    } catch {
+      latestBackup = "Not mounted";
+    }
+    return { configured: true, running, percent, latestBackup };
+  } catch {
+    return { configured: false, running: false };
+  }
+}
+
+export {
+  collectAll,
+  collectPower,
+  collectGpu,
+  collectCpu,
+  collectMemory,
+  collectDisk,
+  collectBattery,
+  collectThermal,
+  collectNetwork,
+  collectProcesses,
+  collectPackets,
+  collectTasks,
+  getDisplayInfo,
+  getTimeMachineStatus
+};