pyre-cli 9.5.2 → 10.0.0

package/dist/chunk-GHRDW646.js

@@ -0,0 +1,2506 @@
+import {
+  collectBuilds
+} from "./chunk-M73HCQD2.js";
+import {
+  collectBlenderRenders
+} from "./chunk-VIACN2RU.js";
+import {
+  run
+} from "./chunk-MZO5QKUR.js";
+
+// src/monitors/collectors.ts
+import chalk from "chalk";
+import os3 from "os";
+import path3 from "path";
+import { fileURLToPath } from "url";
+import fs3 from "fs";
+
+// 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: {}, fans: [] };
+  try {
+    const pm = (await run(
+      "sudo -n powermetrics --samplers smc,cpu_power -n 1 --format text 2>/dev/null",
+      "",
+      2e3
+    )).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]);
+      const fanMatches = pm.matchAll(/Fan\s+(\d+)\s+speed:\s*(\d+)\s*rpm/gi);
+      for (const m of fanMatches) {
+        const id = parseInt(m[1], 10);
+        const rpm = parseInt(m[2], 10);
+        if (!isNaN(id) && !isNaN(rpm)) {
+          result.fans.push({ id, rpm });
+        }
+      }
+      if (result.fans.length === 0) {
+        const fanMatches2 = pm.matchAll(/Fan\s+(\d+):\s*(\d+)\s*rpm/gi);
+        for (const m of fanMatches2) {
+          const id = parseInt(m[1], 10);
+          const rpm = parseInt(m[2], 10);
+          if (!isNaN(id) && !isNaN(rpm)) result.fans.push({ id, rpm });
+        }
+      }
+    }
+  } 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 battRaw = await run("ioreg -r -n AppleSmartBattery 2>/dev/null", "");
+      if (battRaw) {
+        const virtMatch = battRaw.match(/"VirtualTemperature"\s*=\s*(\d+)/);
+        const cellMatch = battRaw.match(/"Temperature"\s*=\s*(\d+)/);
+        const rawVirt = virtMatch ? parseFloat(virtMatch[1]) : void 0;
+        const rawCell = cellMatch ? parseFloat(cellMatch[1]) : void 0;
+        const virtC = rawVirt !== void 0 ? Math.round(rawVirt / 10) / 10 : void 0;
+        const cellC = rawCell !== void 0 ? Math.round(rawCell / 10) / 10 : void 0;
+        if (virtC !== void 0 && virtC >= 15 && virtC <= 115) {
+          result.temps["cpu_die"] = virtC;
+        } else if (cellC !== void 0 && cellC >= 15 && cellC <= 115) {
+          result.temps["cpu_die"] = cellC;
+        }
+      }
+    } 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) {
+    const loadAvg = (await import("os")).loadavg();
+    const ncpus = (await import("os")).cpus().length || 1;
+    const loadUsage = Math.min(100, loadAvg[0] / ncpus * 100);
+    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/dns_cache.ts
+import dns from "dns";
+var cache = /* @__PURE__ */ new Map();
+var pending = /* @__PURE__ */ new Set();
+function resolveIp(ip) {
+  let cleanIp = ip;
+  if (cleanIp.includes("]:")) {
+    cleanIp = cleanIp.substring(1, cleanIp.indexOf("]"));
+  } else if (cleanIp.includes(":") && cleanIp.split(":").length === 2) {
+    cleanIp = cleanIp.split(":")[0];
+  } else if (cleanIp.includes(":") && !cleanIp.includes("]")) {
+    const lastColon = cleanIp.lastIndexOf(":");
+    const isPort = !cleanIp.includes(":", cleanIp.indexOf(":") + 1);
+  }
+  if (cleanIp.includes(":") && cleanIp.includes(".")) {
+    const lastDot = cleanIp.lastIndexOf(".");
+    if (lastDot > cleanIp.lastIndexOf(":")) {
+      cleanIp = cleanIp.substring(0, lastDot);
+    }
+  }
+  if (cache.has(cleanIp)) return cache.get(cleanIp);
+  if (pending.has(cleanIp)) return ip;
+  if (cleanIp.startsWith("127.") || cleanIp.startsWith("192.168.") || cleanIp.startsWith("10.") || cleanIp.startsWith("172.16.") || cleanIp.startsWith("ff02:") || cleanIp === "*:*" || cleanIp === "*" || cleanIp.startsWith("fe80:")) {
+    return ip;
+  }
+  pending.add(cleanIp);
+  dns.reverse(cleanIp, (err, hostnames) => {
+    if (!err && hostnames && hostnames.length > 0) {
+      cache.set(cleanIp, hostnames[0]);
+    } else {
+      cache.set(cleanIp, cleanIp);
+    }
+    pending.delete(cleanIp);
+  });
+  return ip;
+}
+
+// src/monitors/platform/linux.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+var prevNetSample = null;
+var prevDiskIoSample = null;
+var cachedDiskIo = null;
+function safeReadFile(filePath) {
+  try {
+    return fs.readFileSync(filePath, "utf8");
+  } catch {
+    return "";
+  }
+}
+async function collectLinuxSystem() {
+  const hostname = os.hostname();
+  let osName = "Linux";
+  const osRelease = safeReadFile("/etc/os-release");
+  if (osRelease) {
+    const prettyMatch = osRelease.match(/PRETTY_NAME="?([^"\n]+)"?/);
+    if (prettyMatch) {
+      osName = prettyMatch[1];
+    } else {
+      const nameMatch = osRelease.match(/NAME="?([^"\n]+)"?/);
+      const verMatch = osRelease.match(/VERSION="?([^"\n]+)"?/);
+      if (nameMatch) {
+        osName = verMatch ? `${nameMatch[1]} ${verMatch[1]}` : nameMatch[1];
+      }
+    }
+  } else {
+    osName = `Linux ${os.release()}`;
+  }
+  const uptimeSec = Math.floor(os.uptime());
+  const days = Math.floor(uptimeSec / 86400);
+  const hours = Math.floor(uptimeSec % 86400 / 3600);
+  const minutes = Math.floor(uptimeSec % 3600 / 60);
+  let uptime = "";
+  if (days > 0) uptime += `${days} ${days === 1 ? "day" : "days"}, `;
+  uptime += `${hours.toString().padStart(2, "0")}:${minutes.toString().padStart(2, "0")}`;
+  return { hostname, os: osName, uptime };
+}
+async function collectLinuxCpu(prevCpuTimesRef) {
+  const cpus = os.cpus();
+  const cores = cpus.length || 1;
+  let brand = cpus[0]?.model || "Linux CPU";
+  let frequency = cpus[0]?.speed || 0;
+  const cpuInfo = safeReadFile("/proc/cpuinfo");
+  if (cpuInfo) {
+    const brandMatch = cpuInfo.match(/model name\s*:\s*(.+)/i);
+    if (brandMatch) brand = brandMatch[1].trim();
+    const mhzMatch = cpuInfo.match(/cpu MHz\s*:\s*([\d.]+)/i);
+    if (mhzMatch) frequency = Math.round(parseFloat(mhzMatch[1]));
+  }
+  if (frequency === 0) {
+    const curFreq = safeReadFile("/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq").trim();
+    if (curFreq) {
+      frequency = Math.round(parseInt(curFreq, 10) / 1e3);
+    }
+  }
+  let physicalCores = cores;
+  if (cpuInfo) {
+    const coreIds = /* @__PURE__ */ new Set();
+    const blocks = cpuInfo.split(/\n\s*\n/);
+    for (const b of blocks) {
+      const physMatch = b.match(/physical id\s*:\s*(\d+)/);
+      const coreMatch = b.match(/core id\s*:\s*(\d+)/);
+      if (physMatch && coreMatch) {
+        coreIds.add(`${physMatch[1]}:${coreMatch[1]}`);
+      }
+    }
+    if (coreIds.size > 0) physicalCores = coreIds.size;
+  }
+  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
+  }));
+  let coreUsage = [];
+  let usage = 0;
+  if (prevCpuTimesRef.current && prevCpuTimesRef.current.length === current.length) {
+    coreUsage = current.map((c, i) => {
+      const prev = prevCpuTimesRef.current[i];
+      const totalDelta = c.total - prev.total;
+      const idleDelta = c.idle - prev.idle;
+      if (totalDelta <= 0) return 0;
+      return Math.min(100, Math.max(0, Math.round((totalDelta - idleDelta) / totalDelta * 100)));
+    });
+    if (coreUsage.length > 0) {
+      usage = Math.round(coreUsage.reduce((a, b) => a + b, 0) / coreUsage.length);
+    }
+  }
+  prevCpuTimesRef.current = current;
+  let temperature;
+  const thermZone = safeReadFile("/sys/class/thermal/thermal_zone0/temp").trim();
+  if (thermZone) {
+    const rawVal = parseFloat(thermZone);
+    const val = rawVal > 1e3 ? rawVal / 1e3 : rawVal;
+    if (val >= 10 && val <= 125) temperature = Math.round(val * 10) / 10;
+  }
+  if (temperature === void 0) {
+    try {
+      const hwmonDirs = fs.readdirSync("/sys/class/hwmon");
+      for (const d of hwmonDirs) {
+        const tempFile = path.join("/sys/class/hwmon", d, "temp1_input");
+        if (fs.existsSync(tempFile)) {
+          const raw = parseFloat(safeReadFile(tempFile).trim());
+          const val = raw > 1e3 ? raw / 1e3 : raw;
+          if (val >= 10 && val <= 125) {
+            temperature = Math.round(val * 10) / 10;
+            break;
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  const loadAvg = os.loadavg();
+  return {
+    brand,
+    cores,
+    physicalCores,
+    frequency,
+    usage,
+    loadAvg,
+    temperature,
+    coreUsage
+  };
+}
+async function collectLinuxMemory() {
+  const meminfo = safeReadFile("/proc/meminfo");
+  let total = os.totalmem();
+  let free = os.freemem();
+  let available = free;
+  let swapTotal = 0;
+  let swapFree = 0;
+  let buffers = 0;
+  let cached = 0;
+  let shmem = 0;
+  let sreclaimable = 0;
+  if (meminfo) {
+    const parseKb = (key) => {
+      const m = meminfo.match(new RegExp(`^${key}:\\s+(\\d+)\\s+kB`, "m"));
+      return m ? parseInt(m[1], 10) * 1024 : 0;
+    };
+    const t = parseKb("MemTotal");
+    if (t > 0) total = t;
+    free = parseKb("MemFree");
+    const a = parseKb("MemAvailable");
+    if (a > 0) available = a;
+    else available = free;
+    buffers = parseKb("Buffers");
+    cached = parseKb("Cached");
+    shmem = parseKb("Shmem");
+    sreclaimable = parseKb("SReclaimable");
+    swapTotal = parseKb("SwapTotal");
+    swapFree = parseKb("SwapFree");
+  }
+  const used = Math.max(0, total - available);
+  const usagePercent = total > 0 ? Math.round(used / total * 100) : 0;
+  const swapUsed = Math.max(0, swapTotal - swapFree);
+  let pressureLevel = "Normal";
+  if (usagePercent > 92) pressureLevel = "Critical";
+  else if (usagePercent > 82) pressureLevel = "Warning";
+  return {
+    total,
+    used,
+    free,
+    swapTotal,
+    swapUsed,
+    swapFree,
+    pageSize: 4096,
+    usagePercent,
+    wiredBytes: buffers,
+    compressedBytes: cached + sreclaimable,
+    purgeableBytes: shmem,
+    pressureLevel
+  };
+}
+async function collectLinuxDisk() {
+  const rawDf = await run("df -k -P 2>/dev/null", "");
+  const lines = rawDf.trim().split("\n").slice(1);
+  const result = [];
+  for (const line of lines) {
+    const parts = line.split(/\s+/);
+    if (parts.length >= 6) {
+      const filesystem = parts[0];
+      const totalKb = parseInt(parts[1], 10);
+      const usedKb = parseInt(parts[2], 10);
+      const availKb = parseInt(parts[3], 10);
+      const capacity = parts[4];
+      const mountpoint = parts[5];
+      if (filesystem.startsWith("/dev/") || mountpoint === "/" || totalKb > 1024 * 1024) {
+        if (!filesystem.includes("loop")) {
+          result.push({
+            filesystem,
+            size: formatKb(totalKb),
+            used: formatKb(usedKb),
+            available: formatKb(availKb),
+            capacity,
+            mountpoint,
+            readBytesSec: 0,
+            writeBytesSec: 0
+          });
+        }
+      }
+    }
+  }
+  const diskstats = safeReadFile("/proc/diskstats");
+  if (diskstats) {
+    const now = Date.now();
+    let totalSectors = 0;
+    for (const line of diskstats.split("\n")) {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length >= 10 && (parts[2].startsWith("sd") || parts[2].startsWith("nvme") || parts[2].startsWith("vd"))) {
+        const readSectors = parseInt(parts[5], 10) || 0;
+        const writeSectors = parseInt(parts[9], 10) || 0;
+        totalSectors += readSectors + writeSectors;
+      }
+    }
+    const totalBytes = totalSectors * 512;
+    if (prevDiskIoSample && prevDiskIoSample.ts > 0) {
+      const dt = Math.max((now - prevDiskIoSample.ts) / 1e3, 1e-3);
+      const bytesSec = Math.max(0, (totalBytes - prevDiskIoSample.totalBytes) / dt);
+      cachedDiskIo = {
+        readBytesSec: Math.round(bytesSec * 0.6),
+        writeBytesSec: Math.round(bytesSec * 0.4),
+        ts: now
+      };
+    }
+    prevDiskIoSample = { totalBytes, ts: now };
+    if (cachedDiskIo && result.length > 0) {
+      result[0].readBytesSec = cachedDiskIo.readBytesSec;
+      result[0].writeBytesSec = cachedDiskIo.writeBytesSec;
+    }
+  }
+  return result.length > 0 ? result : [
+    {
+      filesystem: "/dev/root",
+      size: "50G",
+      used: "10G",
+      available: "40G",
+      capacity: "20%",
+      mountpoint: "/",
+      readBytesSec: 0,
+      writeBytesSec: 0
+    }
+  ];
+}
+function formatKb(kb) {
+  if (isNaN(kb)) return "0B";
+  const bytes = kb * 1024;
+  if (bytes >= 1024 * 1024 * 1024 * 1024) return (bytes / (1024 * 1024 * 1024 * 1024)).toFixed(1) + "T";
+  if (bytes >= 1024 * 1024 * 1024) return (bytes / (1024 * 1024 * 1024)).toFixed(1) + "G";
+  if (bytes >= 1024 * 1024) return (bytes / (1024 * 1024)).toFixed(1) + "M";
+  return (bytes / 1024).toFixed(0) + "K";
+}
+async function collectLinuxBattery() {
+  const baseDir = "/sys/class/power_supply";
+  if (!fs.existsSync(baseDir)) return null;
+  try {
+    const entries = fs.readdirSync(baseDir);
+    const batDir = entries.find((e) => /^BAT\d*$/i.test(e));
+    if (!batDir) return null;
+    const batPath = path.join(baseDir, batDir);
+    const capStr = safeReadFile(path.join(batPath, "capacity")).trim();
+    if (!capStr) return null;
+    const level = parseInt(capStr, 10) || 0;
+    const status = safeReadFile(path.join(batPath, "status")).trim().toLowerCase();
+    const isCharging = status === "charging";
+    const isFull = status === "full";
+    const state = isFull ? "charged" : isCharging ? "charging" : "discharging";
+    const acDir = entries.find((e) => /^AC|^ADP/i.test(e));
+    let powerSource = "Battery";
+    if (acDir) {
+      const online = safeReadFile(path.join(baseDir, acDir, "online")).trim();
+      if (online === "1") powerSource = "AC";
+    }
+    let powerWatts;
+    const powerNowStr = safeReadFile(path.join(batPath, "power_now")).trim();
+    if (powerNowStr) {
+      const uW = parseInt(powerNowStr, 10);
+      if (uW > 0) powerWatts = Math.round(uW / 1e6 * 100) / 100;
+    } else {
+      const curNowStr = safeReadFile(path.join(batPath, "current_now")).trim();
+      const voltNowStr = safeReadFile(path.join(batPath, "voltage_now")).trim();
+      if (curNowStr && voltNowStr) {
+        const uA = parseInt(curNowStr, 10);
+        const uV = parseInt(voltNowStr, 10);
+        if (uA > 0 && uV > 0) {
+          powerWatts = Math.round(uA / 1e6 * (uV / 1e6) * 100) / 100;
+        }
+      }
+    }
+    let cycles;
+    const cycleStr = safeReadFile(path.join(batPath, "cycle_count")).trim();
+    if (cycleStr) cycles = parseInt(cycleStr, 10) || void 0;
+    return {
+      level,
+      state,
+      timeRemaining: state === "discharging" ? "calculating" : "\u221E",
+      health: "Good",
+      powerSource,
+      cycles,
+      powerWatts
+    };
+  } catch {
+    return null;
+  }
+}
+async function collectLinuxThermal() {
+  const temperatures = {};
+  const fans = [];
+  try {
+    const thermalDirs = fs.readdirSync("/sys/class/thermal");
+    for (const d of thermalDirs) {
+      if (d.startsWith("thermal_zone")) {
+        const typeStr = safeReadFile(`/sys/class/thermal/${d}/type`).trim() || d;
+        const tempStr = safeReadFile(`/sys/class/thermal/${d}/temp`).trim();
+        if (tempStr) {
+          const raw = parseFloat(tempStr);
+          const c = raw > 1e3 ? Math.round(raw / 1e3 * 10) / 10 : Math.round(raw * 10) / 10;
+          if (c >= 10 && c <= 125) {
+            temperatures[typeStr] = c;
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  try {
+    const hwmonDirs = fs.readdirSync("/sys/class/hwmon");
+    for (const d of hwmonDirs) {
+      const dirPath = path.join("/sys/class/hwmon", d);
+      const files = fs.readdirSync(dirPath);
+      for (const f of files) {
+        if (/^temp\d+_input$/.test(f)) {
+          const idx = f.match(/\d+/)?.[0] || "1";
+          const labelFile = path.join(dirPath, `temp${idx}_label`);
+          const label = safeReadFile(labelFile).trim() || `sensor_${idx}`;
+          const raw = parseFloat(safeReadFile(path.join(dirPath, f)).trim());
+          const c = raw > 1e3 ? Math.round(raw / 1e3 * 10) / 10 : Math.round(raw * 10) / 10;
+          if (c >= 10 && c <= 125) temperatures[label] = c;
+        } else if (/^fan\d+_input$/.test(f)) {
+          const idx = parseInt(f.match(/\d+/)?.[0] || "0", 10);
+          const rpm = parseInt(safeReadFile(path.join(dirPath, f)).trim(), 10);
+          if (!isNaN(rpm)) fans.push({ id: idx, rpm });
+        }
+      }
+    }
+  } catch {
+  }
+  const temps = Object.values(temperatures).filter((t) => typeof t === "number");
+  const maxTemp = temps.length > 0 ? Math.max(...temps) : 45;
+  let state = "Nominal";
+  let pressureLevel = 0;
+  if (maxTemp >= 100) {
+    state = "Critical";
+    pressureLevel = 3;
+  } else if (maxTemp >= 90) {
+    state = "Serious";
+    pressureLevel = 2;
+  } else if (maxTemp >= 80) {
+    state = "Fair";
+    pressureLevel = 1;
+  }
+  return {
+    state,
+    detail: `${state} (${maxTemp}\xB0C)`,
+    pressureLevel,
+    temperatures: Object.keys(temperatures).length ? temperatures : void 0,
+    fans: fans.length ? fans : void 0
+  };
+}
+async function collectLinuxPower() {
+  const raplDir = "/sys/class/powercap/intel-rapl/intel-rapl:0";
+  if (fs.existsSync(raplDir)) {
+    try {
+      const e1Str = safeReadFile(path.join(raplDir, "energy_uj")).trim();
+      const t1 = Date.now();
+      await new Promise((r) => setTimeout(r, 100));
+      const e2Str = safeReadFile(path.join(raplDir, "energy_uj")).trim();
+      const t2 = Date.now();
+      const e1 = parseInt(e1Str, 10);
+      const e2 = parseInt(e2Str, 10);
+      if (e2 > e1 && t2 > t1) {
+        const dtSec = (t2 - t1) / 1e3;
+        const watts = Math.round((e2 - e1) / 1e6 / dtSec * 100) / 100;
+        if (watts > 0 && watts < 500) {
+          return { cpuWatts: watts, combinedWatts: watts };
+        }
+      }
+    } catch {
+    }
+  }
+  try {
+    const batt = await collectLinuxBattery();
+    if (batt && batt.powerWatts) {
+      return { combinedWatts: batt.powerWatts };
+    }
+  } catch {
+  }
+  return null;
+}
+async function collectLinuxGpu() {
+  const nvRaw = (await run("nvidia-smi --query-gpu=gpu_name,memory.total,utilization.gpu,temperature.gpu --format=csv,noheader,nounits 2>/dev/null", "")).trim();
+  if (nvRaw) {
+    const parts = nvRaw.split(",").map((s) => s.trim());
+    if (parts.length >= 3) {
+      const model = parts[0];
+      const memory = (parseFloat(parts[1]) || 0) * 1024 * 1024;
+      const utilization = Math.min(100, Math.max(0, Math.round(parseFloat(parts[2]) || 0)));
+      const temperature = parts[3] ? parseFloat(parts[3]) : void 0;
+      return { model, memory, utilization, temperature, processes: 0 };
+    }
+  }
+  try {
+    const drmDir = "/sys/class/drm";
+    if (fs.existsSync(drmDir)) {
+      const cards = fs.readdirSync(drmDir).filter((c) => /^card\d+$/i.test(c));
+      for (const card of cards) {
+        const busyFile = path.join(drmDir, card, "device", "gpu_busy_percent");
+        if (fs.existsSync(busyFile)) {
+          const util = parseInt(safeReadFile(busyFile).trim(), 10) || 0;
+          return { model: "Linux DRM GPU", memory: 0, utilization: util, processes: 0 };
+        }
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+async function collectLinuxNetwork() {
+  const netDev = safeReadFile("/proc/net/dev");
+  let iface = "eth0";
+  let rxBytes = 0;
+  let txBytes = 0;
+  let rxPackets = 0;
+  let txPackets = 0;
+  const route = safeReadFile("/proc/net/route");
+  if (route) {
+    for (const line of route.split("\n").slice(1)) {
+      const parts = line.trim().split(/\s+/);
+      if (parts[1] === "00000000" && parts[0]) {
+        iface = parts[0];
+        break;
+      }
+    }
+  }
+  let ip = "127.0.0.1";
+  const interfaces = os.networkInterfaces();
+  if (interfaces[iface]) {
+    const addr = interfaces[iface]?.find((a) => a.family === "IPv4" && !a.internal);
+    if (addr) ip = addr.address;
+  }
+  if (ip === "127.0.0.1") {
+    for (const [name, addrs] of Object.entries(interfaces)) {
+      const addr = addrs?.find((a) => a.family === "IPv4" && !a.internal);
+      if (addr) {
+        iface = name;
+        ip = addr.address;
+        break;
+      }
+    }
+  }
+  if (netDev) {
+    for (const line of netDev.split("\n").slice(2)) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      const colonIdx = trimmed.indexOf(":");
+      if (colonIdx === -1) continue;
+      const devName = trimmed.slice(0, colonIdx).trim();
+      const stats = trimmed.slice(colonIdx + 1).trim().split(/\s+/);
+      if (stats.length >= 16) {
+        const rxB = parseInt(stats[0], 10) || 0;
+        const rxP = parseInt(stats[1], 10) || 0;
+        const txB = parseInt(stats[8], 10) || 0;
+        const txP = parseInt(stats[9], 10) || 0;
+        if (devName === iface || !iface && devName !== "lo") {
+          rxBytes = rxB;
+          rxPackets = rxP;
+          txBytes = txB;
+          txPackets = txP;
+        }
+      }
+    }
+  }
+  const now = Date.now();
+  let rxRate = 0;
+  let txRate = 0;
+  if (prevNetSample && prevNetSample.ts > 0) {
+    const dt = Math.max((now - prevNetSample.ts) / 1e3, 1e-3);
+    rxRate = Math.max(0, (rxBytes - prevNetSample.rxBytes) / dt);
+    txRate = Math.max(0, (txBytes - prevNetSample.txBytes) / dt);
+  }
+  prevNetSample = { rxBytes, txBytes, rxPackets, txPackets, ts: now };
+  const connectionStates = await getLinuxConnectionStates();
+  return {
+    interface: iface,
+    ip,
+    rxBytes,
+    txBytes,
+    rxPackets,
+    txPackets,
+    rxRate,
+    txRate,
+    connections: connectionStates.established,
+    protocols: {
+      tcp: { connections: connectionStates.established, rxBytes: 0, txBytes: 0 },
+      udp: { connections: 0, rxBytes: 0, txBytes: 0 }
+    },
+    connectionStates,
+    listeningPorts: [],
+    establishedConnections: connectionStates.established,
+    topRemoteHosts: []
+  };
+}
+async function getLinuxConnectionStates() {
+  const stats = { established: 0, listening: 0, timeWait: 0, closeWait: 0, other: 0 };
+  const tcpFile = safeReadFile("/proc/net/tcp");
+  if (tcpFile) {
+    for (const line of tcpFile.split("\n").slice(1)) {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length >= 4) {
+        const stateHex = parts[3];
+        if (stateHex === "01") stats.established++;
+        else if (stateHex === "0A") stats.listening++;
+        else if (stateHex === "06") stats.timeWait++;
+        else if (stateHex === "08") stats.closeWait++;
+        else stats.other++;
+      }
+    }
+  }
+  return stats;
+}
+async function collectLinuxPackets() {
+  const netDev = safeReadFile("/proc/net/dev");
+  let totalRxPackets = 0;
+  let totalTxPackets = 0;
+  const ifaceStats = [];
+  if (netDev) {
+    for (const line of netDev.split("\n").slice(2)) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      const colonIdx = trimmed.indexOf(":");
+      if (colonIdx === -1) continue;
+      const devName = trimmed.slice(0, colonIdx).trim();
+      const stats = trimmed.slice(colonIdx + 1).trim().split(/\s+/);
+      if (stats.length >= 16) {
+        const rxB = parseInt(stats[0], 10) || 0;
+        const rxP = parseInt(stats[1], 10) || 0;
+        const txB = parseInt(stats[8], 10) || 0;
+        const txP = parseInt(stats[9], 10) || 0;
+        totalRxPackets += rxP;
+        totalTxPackets += txP;
+        if (!devName.includes("lo")) {
+          ifaceStats.push({ iface: devName, rxPackets: rxP, txPackets: txP, rxBytes: rxB, txBytes: txB });
+        }
+      }
+    }
+  }
+  const connectionStates = await getLinuxConnectionStates();
+  return {
+    totalPackets: totalRxPackets + totalTxPackets,
+    rxPackets: totalRxPackets,
+    txPackets: totalTxPackets,
+    rxRate: 0,
+    txRate: 0,
+    connections: connectionStates.established,
+    topProcesses: [],
+    interfaces: ifaceStats,
+    allProcesses: [],
+    connectionStates,
+    listeningPorts: []
+  };
+}
+async function collectLinuxProcesses(limit) {
+  try {
+    const headClause = limit && limit > 0 ? ` | head -n ${limit + 1}` : "";
+    const raw = (await run(`ps -eo pid,ppid,user,pcpu,pmem,state,time,comm --sort=-pcpu 2>/dev/null${headClause}`, "")).trim();
+    if (!raw) return [];
+    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, 10) * Math.pow(60, 2 - idx), 0);
+      const command = parts[8];
+      const isGpuOrMl = /gpu|vulkan|cuda|ollama|llama|torch|python/i.test(command);
+      return {
+        pid: parseInt(parts[1], 10),
+        ppid: parseInt(parts[2], 10),
+        user: parts[3],
+        cpu: parseFloat(parts[4]),
+        mem: parseFloat(parts[5]),
+        state: parts[6],
+        threads: 0,
+        runtime: runtimeSec,
+        command,
+        isGpuOrMlAttributed: isGpuOrMl
+      };
+    }).filter((p) => p !== null && p.pid > 0);
+  } catch {
+    return [];
+  }
+}
+async function collectLinuxTasks(limit = 12) {
+  try {
+    const raw = (await run(`ps -eo pid,user,pcpu,pmem,state,time,comm --sort=-pcpu 2>/dev/null | head -n ${limit + 1}`, "")).trim();
+    if (!raw) return [];
+    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, 10) * Math.pow(60, 2 - idx), 0);
+      return {
+        pid: parseInt(parts[1], 10),
+        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 getLinuxDisplayInfo() {
+  const xrandr = await run("xrandr --query 2>/dev/null", "");
+  if (!xrandr) return [];
+  const displays = [];
+  for (const line of xrandr.split("\n")) {
+    const match = line.match(/^(\S+)\s+(connected)\s+(primary\s+)?(\d+x\d+)/);
+    if (match) {
+      displays.push({
+        name: match[1],
+        resolution: match[4],
+        isMain: !!match[3]
+      });
+    }
+  }
+  return displays;
+}
+
+// src/monitors/platform/windows.ts
+import os2 from "os";
+var prevNetSample2 = null;
+async function collectWindowsSystem() {
+  const hostname = os2.hostname();
+  const rel = os2.release();
+  const build = parseInt(rel.split(".")[2] || "0", 10);
+  let osName = "Windows";
+  if (build >= 22e3) {
+    osName = `Windows 11 (${rel})`;
+  } else if (rel.startsWith("10.0")) {
+    osName = `Windows 10 (${rel})`;
+  } else {
+    osName = `Windows (${rel})`;
+  }
+  const uptimeSec = Math.floor(os2.uptime());
+  const days = Math.floor(uptimeSec / 86400);
+  const hours = Math.floor(uptimeSec % 86400 / 3600);
+  const minutes = Math.floor(uptimeSec % 3600 / 60);
+  let uptime = "";
+  if (days > 0) uptime += `${days} ${days === 1 ? "day" : "days"}, `;
+  uptime += `${hours.toString().padStart(2, "0")}:${minutes.toString().padStart(2, "0")}`;
+  return { hostname, os: osName, uptime };
+}
+async function collectWindowsCpu(prevCpuTimesRef) {
+  const cpus = os2.cpus();
+  const cores = cpus.length || 1;
+  const brand = cpus[0]?.model || "Windows CPU";
+  const frequency = cpus[0]?.speed || 0;
+  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
+  }));
+  let coreUsage = [];
+  let usage = 0;
+  if (prevCpuTimesRef.current && prevCpuTimesRef.current.length === current.length) {
+    coreUsage = current.map((c, i) => {
+      const prev = prevCpuTimesRef.current[i];
+      const totalDelta = c.total - prev.total;
+      const idleDelta = c.idle - prev.idle;
+      if (totalDelta <= 0) return 0;
+      return Math.min(100, Math.max(0, Math.round((totalDelta - idleDelta) / totalDelta * 100)));
+    });
+    if (coreUsage.length > 0) {
+      usage = Math.round(coreUsage.reduce((a, b) => a + b, 0) / coreUsage.length);
+    }
+  }
+  prevCpuTimesRef.current = current;
+  const activeLoad = Math.round(usage / 100 * cores * 100) / 100;
+  const loadAvg = [activeLoad, activeLoad, activeLoad];
+  let temperature;
+  try {
+    const rawWmi = (await run("wmic /namespace:\\\\root\\wmi PATH MSAcpi_ThermalZoneTemperature get CurrentTemperature 2>nul", "", 1500)).trim();
+    const match = rawWmi.match(/(\d{3,4})/);
+    if (match) {
+      const kelvinTenths = parseInt(match[1], 10);
+      const c = Math.round((kelvinTenths - 2732) / 10 * 10) / 10;
+      if (c >= 15 && c <= 115) temperature = c;
+    }
+  } catch {
+  }
+  if (temperature === void 0) {
+    temperature = Math.round((38 + usage * 0.42) * 10) / 10;
+  }
+  return {
+    brand,
+    cores,
+    physicalCores: cores,
+    frequency,
+    usage,
+    loadAvg,
+    temperature,
+    coreUsage
+  };
+}
+async function collectWindowsMemory() {
+  const total = os2.totalmem();
+  const free = os2.freemem();
+  const used = Math.max(0, total - free);
+  const usagePercent = total > 0 ? Math.round(used / total * 100) : 0;
+  let swapTotal = 0;
+  let swapUsed = 0;
+  let swapFree = 0;
+  try {
+    const rawPage = (await run("wmic pagefile get AllocatedBaseSize,CurrentUsage 2>nul", "", 1500)).trim();
+    const lines = rawPage.split("\n").filter((l) => l.trim().length > 0);
+    if (lines.length >= 2) {
+      const parts = lines[1].trim().split(/\s+/);
+      if (parts.length >= 2) {
+        const allocMb = parseInt(parts[0], 10) || 0;
+        const usedMb = parseInt(parts[1], 10) || 0;
+        swapTotal = allocMb * 1024 * 1024;
+        swapUsed = usedMb * 1024 * 1024;
+        swapFree = Math.max(0, swapTotal - swapUsed);
+      }
+    }
+  } catch {
+  }
+  let pressureLevel = "Normal";
+  if (usagePercent > 92) pressureLevel = "Critical";
+  else if (usagePercent > 82) pressureLevel = "Warning";
+  return {
+    total,
+    used,
+    free,
+    swapTotal,
+    swapUsed,
+    swapFree,
+    pageSize: 4096,
+    usagePercent,
+    pressureLevel
+  };
+}
+async function collectWindowsDisk() {
+  try {
+    const raw = (await run("wmic logicaldisk get Caption,FileSystem,FreeSpace,Size 2>nul", "", 2500)).trim();
+    const lines = raw.split("\n").slice(1);
+    const disks = [];
+    for (const line of lines) {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length >= 4) {
+        const drive = parts[0];
+        const freeBytes = parseInt(parts[2], 10) || 0;
+        const totalBytes = parseInt(parts[3], 10) || 0;
+        if (totalBytes > 0) {
+          const usedBytes = Math.max(0, totalBytes - freeBytes);
+          const capPct = Math.round(usedBytes / totalBytes * 100);
+          disks.push({
+            filesystem: drive,
+            size: formatBytesStr(totalBytes),
+            used: formatBytesStr(usedBytes),
+            available: formatBytesStr(freeBytes),
+            capacity: `${capPct}%`,
+            mountpoint: drive,
+            readBytesSec: 0,
+            writeBytesSec: 0
+          });
+        }
+      }
+    }
+    if (disks.length > 0) return disks;
+  } catch {
+  }
+  return [
+    {
+      filesystem: "C:",
+      size: "500G",
+      used: "150G",
+      available: "350G",
+      capacity: "30%",
+      mountpoint: "C:",
+      readBytesSec: 0,
+      writeBytesSec: 0
+    }
+  ];
+}
+function formatBytesStr(bytes) {
+  if (bytes >= 1024 * 1024 * 1024 * 1024) return (bytes / (1024 * 1024 * 1024 * 1024)).toFixed(1) + "T";
+  if (bytes >= 1024 * 1024 * 1024) return (bytes / (1024 * 1024 * 1024)).toFixed(1) + "G";
+  if (bytes >= 1024 * 1024) return (bytes / (1024 * 1024)).toFixed(1) + "M";
+  return (bytes / 1024).toFixed(0) + "K";
+}
+async function collectWindowsBattery() {
+  try {
+    const raw = (await run("wmic path win32_battery get BatteryStatus,EstimatedChargeRemaining,EstimatedRunTime 2>nul", "", 2e3)).trim();
+    const lines = raw.split("\n").filter((l) => l.trim().length > 0);
+    if (lines.length >= 2) {
+      const parts = lines[1].trim().split(/\s+/);
+      if (parts.length >= 2) {
+        const statusCode = parseInt(parts[0], 10) || 1;
+        const level = parseInt(parts[1], 10) || 0;
+        const runTimeMinutes = parseInt(parts[2], 10);
+        const powerSource = statusCode === 2 || statusCode === 3 || statusCode === 6 ? "AC" : "Battery";
+        const state = statusCode === 3 ? "charged" : statusCode === 6 || statusCode === 2 ? "charging" : "discharging";
+        let timeRemaining = "calculating";
+        if (state === "charged") timeRemaining = "\u221E";
+        else if (runTimeMinutes && runTimeMinutes > 0 && runTimeMinutes < 7e4) {
+          const h = Math.floor(runTimeMinutes / 60);
+          const m = runTimeMinutes % 60;
+          timeRemaining = `${h}:${m.toString().padStart(2, "0")}`;
+        }
+        return {
+          level,
+          state,
+          timeRemaining,
+          health: "Good",
+          powerSource
+        };
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+async function collectWindowsThermal() {
+  let tempC;
+  try {
+    const rawWmi = (await run("wmic /namespace:\\\\root\\wmi PATH MSAcpi_ThermalZoneTemperature get CurrentTemperature 2>nul", "", 1500)).trim();
+    const match = rawWmi.match(/(\d{3,4})/);
+    if (match) {
+      const kelvinTenths = parseInt(match[1], 10);
+      const c = Math.round((kelvinTenths - 2732) / 10 * 10) / 10;
+      if (c >= 15 && c <= 115) tempC = c;
+    }
+  } catch {
+  }
+  if (tempC === void 0) {
+    const cpus = os2.cpus();
+    const loadUsage = os2.loadavg()[0] || 15;
+    tempC = Math.round((38 + loadUsage * 0.42) * 10) / 10;
+  }
+  let state = "Nominal";
+  let pressureLevel = 0;
+  if (tempC >= 100) {
+    state = "Critical";
+    pressureLevel = 3;
+  } else if (tempC >= 90) {
+    state = "Serious";
+    pressureLevel = 2;
+  } else if (tempC >= 80) {
+    state = "Fair";
+    pressureLevel = 1;
+  }
+  return {
+    state,
+    detail: `${state} (${tempC}\xB0C)`,
+    pressureLevel,
+    temperatures: { cpu: tempC }
+  };
+}
+async function collectWindowsPower() {
+  return null;
+}
+async function collectWindowsGpu() {
+  const nvRaw = (await run("nvidia-smi --query-gpu=gpu_name,memory.total,utilization.gpu,temperature.gpu --format=csv,noheader,nounits 2>nul", "")).trim();
+  if (nvRaw) {
+    const parts = nvRaw.split(",").map((s) => s.trim());
+    if (parts.length >= 3) {
+      const model = parts[0];
+      const memory = (parseFloat(parts[1]) || 0) * 1024 * 1024;
+      const utilization = Math.min(100, Math.max(0, Math.round(parseFloat(parts[2]) || 0)));
+      const temperature = parts[3] ? parseFloat(parts[3]) : void 0;
+      return { model, memory, utilization, temperature, processes: 0 };
+    }
+  }
+  try {
+    const raw = (await run("wmic path win32_VideoController get Name,AdapterRAM 2>nul", "", 2e3)).trim();
+    const lines = raw.split("\n").filter((l) => l.trim().length > 0);
+    if (lines.length >= 2) {
+      const parts = lines[1].trim().split(/\s{2,}/);
+      if (parts.length >= 2) {
+        const ram = parseInt(parts[0], 10) || 0;
+        const name = parts[1] || "Windows Display Adapter";
+        return { model: name, memory: ram, utilization: 0, processes: 0 };
+      } else if (parts.length === 1) {
+        return { model: parts[0], memory: 0, utilization: 0, processes: 0 };
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+async function collectWindowsNetwork() {
+  let iface = "Ethernet";
+  let ip = "127.0.0.1";
+  const interfaces = os2.networkInterfaces();
+  for (const [name, addrs] of Object.entries(interfaces)) {
+    const addr = addrs?.find((a) => a.family === "IPv4" && !a.internal);
+    if (addr) {
+      iface = name;
+      ip = addr.address;
+      break;
+    }
+  }
+  let rxBytes = 0;
+  let txBytes = 0;
+  let rxPackets = 0;
+  let txPackets = 0;
+  try {
+    const netstatE = (await run("netstat -e 2>nul", "", 1500)).trim();
+    const lines = netstatE.split("\n");
+    for (const line of lines) {
+      const parts = line.trim().split(/\s+/);
+      if (parts[0] && parts[0].toLowerCase() === "bytes" && parts.length >= 3) {
+        rxBytes = parseInt(parts[1], 10) || 0;
+        txBytes = parseInt(parts[2], 10) || 0;
+      } else if (parts[0] && parts[0].toLowerCase().includes("unicast") && parts.length >= 3) {
+        rxPackets += parseInt(parts[1], 10) || 0;
+        txPackets += parseInt(parts[2], 10) || 0;
+      }
+    }
+  } catch {
+  }
+  const now = Date.now();
+  let rxRate = 0;
+  let txRate = 0;
+  if (prevNetSample2 && prevNetSample2.ts > 0) {
+    const dt = Math.max((now - prevNetSample2.ts) / 1e3, 1e-3);
+    rxRate = Math.max(0, (rxBytes - prevNetSample2.rxBytes) / dt);
+    txRate = Math.max(0, (txBytes - prevNetSample2.txBytes) / dt);
+  }
+  prevNetSample2 = { rxBytes, txBytes, ts: now };
+  const connectionStates = await getWindowsConnectionStates();
+  return {
+    interface: iface,
+    ip,
+    rxBytes,
+    txBytes,
+    rxPackets,
+    txPackets,
+    rxRate,
+    txRate,
+    connections: connectionStates.established,
+    protocols: {
+      tcp: { connections: connectionStates.established, rxBytes: 0, txBytes: 0 },
+      udp: { connections: 0, rxBytes: 0, txBytes: 0 }
+    },
+    connectionStates,
+    listeningPorts: [],
+    establishedConnections: connectionStates.established,
+    topRemoteHosts: []
+  };
+}
+async function getWindowsConnectionStates() {
+  const stats = { established: 0, listening: 0, timeWait: 0, closeWait: 0, other: 0 };
+  try {
+    const raw = (await run("netstat -ano 2>nul", "", 2e3)).trim();
+    for (const line of raw.split("\n")) {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length >= 4 && parts[0].toUpperCase() === "TCP") {
+        const state = parts[3].toUpperCase();
+        if (state.includes("ESTABLISHED")) stats.established++;
+        else if (state.includes("LISTENING")) stats.listening++;
+        else if (state.includes("TIME_WAIT")) stats.timeWait++;
+        else if (state.includes("CLOSE_WAIT")) stats.closeWait++;
+        else stats.other++;
+      }
+    }
+  } catch {
+  }
+  return stats;
+}
+async function collectWindowsPackets() {
+  let rxBytes = 0;
+  let txBytes = 0;
+  let rxPackets = 0;
+  let txPackets = 0;
+  try {
+    const netstatE = (await run("netstat -e 2>nul", "", 1500)).trim();
+    const lines = netstatE.split("\n");
+    for (const line of lines) {
+      const parts = line.trim().split(/\s+/);
+      if (parts[0] && parts[0].toLowerCase() === "bytes" && parts.length >= 3) {
+        rxBytes = parseInt(parts[1], 10) || 0;
+        txBytes = parseInt(parts[2], 10) || 0;
+      } else if (parts[0] && parts[0].toLowerCase().includes("unicast") && parts.length >= 3) {
+        rxPackets += parseInt(parts[1], 10) || 0;
+        txPackets += parseInt(parts[2], 10) || 0;
+      }
+    }
+  } catch {
+  }
+  const connectionStates = await getWindowsConnectionStates();
+  return {
+    totalPackets: rxPackets + txPackets,
+    rxPackets,
+    txPackets,
+    rxRate: 0,
+    txRate: 0,
+    connections: connectionStates.established,
+    topProcesses: [],
+    interfaces: [{ iface: "Primary", rxPackets, txPackets, rxBytes, txBytes }],
+    allProcesses: [],
+    connectionStates,
+    listeningPorts: []
+  };
+}
+async function collectWindowsProcesses(limit) {
+  try {
+    const raw = (await run("tasklist /fo csv /nh 2>nul", "", 3e3)).trim();
+    if (!raw) return [];
+    const lines = raw.split("\n");
+    const procs = [];
+    const totalMem = os2.totalmem();
+    for (const line of lines) {
+      const parts = line.split('","').map((s) => s.replace(/(^"|"$)/g, "").trim());
+      if (parts.length >= 5) {
+        const name = parts[0];
+        const pid = parseInt(parts[1], 10);
+        const memStr = parts[4].replace(/[^\d]/g, "");
+        const memKb = parseInt(memStr, 10) || 0;
+        const memBytes = memKb * 1024;
+        const memPct = totalMem > 0 ? Math.round(memBytes / totalMem * 100 * 10) / 10 : 0;
+        const isGpuOrMl = /gpu|vulkan|cuda|ollama|llama|torch|python/i.test(name);
+        if (pid > 0) {
+          procs.push({
+            pid,
+            ppid: 0,
+            user: parts[2] || "SYSTEM",
+            cpu: 0,
+            mem: memPct,
+            state: "R",
+            threads: 0,
+            runtime: 0,
+            command: name,
+            isGpuOrMlAttributed: isGpuOrMl
+          });
+        }
+      }
+    }
+    procs.sort((a, b) => b.mem - a.mem);
+    if (limit && limit > 0) return procs.slice(0, limit);
+    return procs;
+  } catch {
+    return [];
+  }
+}
+async function collectWindowsTasks(limit = 12) {
+  const procs = await collectWindowsProcesses(limit);
+  return procs.map((p) => ({
+    pid: p.pid,
+    user: p.user,
+    cpu: p.cpu,
+    mem: p.mem,
+    state: p.state,
+    runtime: p.runtime,
+    command: p.command
+  }));
+}
+async function getWindowsDisplayInfo() {
+  return [{ name: "Default Display", resolution: "1920x1080", isMain: true }];
+}
+
+// src/monitors/batteryPredictor.ts
+import fs2 from "fs";
+import path2 from "path";
+function formatHours(h) {
+  if (!isFinite(h) || h <= 0) return "calculating";
+  const hours = Math.floor(h);
+  const mins = Math.round((h - hours) * 60);
+  if (hours === 0 && mins === 0) return "< 1m";
+  if (hours === 0) return `${mins}m`;
+  return `${hours}h ${mins}m`;
+}
+function computeSmartBatteryPrediction(battery, power, logDir = "./pyre-exports") {
+  if (!battery) return null;
+  const level = battery.level;
+  const isCharging = battery.state.toLowerCase().includes("charg");
+  const assumedCapacityWh = 58;
+  let currentRate = battery.dischargeRatePerHour || 12;
+  if (battery.dischargeRatePerHour === void 0 && power && power.combinedWatts) {
+    currentRate = power.combinedWatts / assumedCapacityWh * 100;
+  }
+  currentRate = Math.max(2, Math.min(60, currentRate));
+  let historicalSamples = [];
+  try {
+    if (fs2.existsSync(logDir)) {
+      const files = fs2.readdirSync(logDir).filter((f) => f.startsWith("pyre-") && f.endsWith(".csv")).slice(-3);
+      for (const file of files) {
+        const content = fs2.readFileSync(path2.join(logDir, file), "utf-8");
+        const lines = content.split("\n").slice(1);
+        for (const line of lines) {
+          const parts = line.split(",");
+          if (parts.length >= 4) {
+            const cpu = parseFloat(parts[1]);
+            if (!isNaN(cpu)) {
+              const estRate = 5 + cpu / 100 * 20;
+              historicalSamples.push(estRate);
+            }
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  const confidence = isCharging ? "low" : historicalSamples.length > 50 ? "high" : battery.dischargeRatePerHour ? "medium" : "low";
+  const idleRate = 6;
+  const idleHours = level / idleRate;
+  const currentHours = level / currentRate;
+  const heavyRate = Math.max(28, currentRate * 1.5);
+  const heavyHours = level / heavyRate;
+  let recommendation = "Power consumption is normal.";
+  if (isCharging) {
+    recommendation = `Device is currently ${battery.state}. Full capacity health: ${battery.health || "Good"}.`;
+  } else if (currentRate > 25) {
+    recommendation = "High power drain detected. Reducing display brightness and closing heavy background processes can extend battery significantly.";
+  } else if (currentRate < 10) {
+    recommendation = "Excellent power efficiency. Machine is running under low-drain conditions.";
+  }
+  return {
+    currentLevel: level,
+    healthPercentage: battery.maxCapacityPercent,
+    cycleCount: battery.cycles,
+    powerWatts: battery.powerWatts || power?.combinedWatts,
+    scenarios: {
+      idle: {
+        label: "Light / Reading Load",
+        ratePerHour: idleRate,
+        timeRemaining: formatHours(idleHours),
+        hours: idleHours
+      },
+      current: {
+        label: "Current Activity",
+        ratePerHour: Math.round(currentRate * 10) / 10,
+        timeRemaining: isCharging ? "Charging" : formatHours(currentHours),
+        hours: currentHours
+      },
+      heavy: {
+        label: "Sustained Heavy Compute",
+        ratePerHour: Math.round(heavyRate * 10) / 10,
+        timeRemaining: formatHours(heavyHours),
+        hours: heavyHours
+      }
+    },
+    recommendation,
+    confidence
+  };
+}
+
+// src/monitors/collectors.ts
+var SP_TTL_MS = 1e4;
+var NETSTAT_TTL_MS = 1e3;
+var prevCpuTimes = null;
+var prevCpuTotal = { total: 0, idle: 0, ts: 0 };
+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();
+var prevNetSample3 = null;
+var cachedIoReportPath = void 0;
+function resolveIoReportScript() {
+  if (cachedIoReportPath !== void 0) return cachedIoReportPath;
+  try {
+    const dir = path3.dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+      path3.join(dir, "ioreport.py"),
+      path3.join(dir, "..", "src", "monitors", "ioreport.py"),
+      path3.join(dir, "monitors", "ioreport.py"),
+      path3.join(process.cwd(), "src", "monitors", "ioreport.py"),
+      path3.join(process.cwd(), "dist", "ioreport.py")
+    ];
+    for (const c of candidates) {
+      if (fs3.existsSync(c)) {
+        cachedIoReportPath = c;
+        return c;
+      }
+    }
+  } catch {
+  }
+  cachedIoReportPath = null;
+  return null;
+}
+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";
+  return { estimatedTimeToEmpty, dischargeRatePerHour: Math.round(dischargeRate * 10) / 10 };
+}
+async function collectAll(opts = {}) {
+  const [cpu, gpu, memory, disk, rawBattery, thermal, network, processes, system, power, packets, tasks, containers, blenderRenders, activeBuilds] = await Promise.all([
+    collectCpu(),
+    collectGpu(opts.detailed),
+    collectMemory(),
+    collectDisk(),
+    collectBattery(),
+    collectThermal(opts.detailed),
+    collectNetwork(),
+    collectProcesses(opts.processLimit),
+    collectSystem(),
+    collectPower(),
+    collectPackets(),
+    collectTasks(),
+    collectContainers(),
+    collectBlenderRenders(),
+    collectBuilds()
+  ]);
+  const battery = rawBattery ? {
+    ...rawBattery,
+    smartPrediction: computeSmartBatteryPrediction(rawBattery, power) || void 0
+  } : null;
+  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,
+    containers,
+    blenderRenders,
+    activeBuilds
+  };
+}
+async function collectContainers() {
+  try {
+    const raw = (await run('docker stats --no-stream --format "{{.ID}}|{{.Name}}|{{.CPUPerc}}|{{.MemUsage}}|{{.MemPerc}}|{{.NetIO}}|{{.BlockIO}}|{{.PIDs}}" 2>/dev/null', "")).trim();
+    if (!raw) return [];
+    return raw.split("\n").map((line) => {
+      const parts = line.split("|");
+      return {
+        id: parts[0],
+        name: parts[1],
+        cpuPercent: parseFloat(parts[2].replace("%", "")) || 0,
+        memUsage: parts[3],
+        memPercent: parseFloat(parts[4].replace("%", "")) || 0,
+        netIO: parts[5],
+        blockIO: parts[6],
+        pids: parseInt(parts[7], 10) || 0
+      };
+    });
+  } catch {
+    return [];
+  }
+}
+async function collectPower() {
+  if (process.platform === "linux") return collectLinuxPower();
+  if (process.platform === "win32") return collectWindowsPower();
+  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, aneWatts: 0, combinedWatts: power.combined };
+    }
+  } catch {
+  }
+  const scriptPath = resolveIoReportScript();
+  if (scriptPath && process.platform === "darwin") {
+    try {
+      const pyOut = (await run(`python3 "${scriptPath}" 2>/dev/null`, "")).trim();
+      if (pyOut.startsWith("{") && pyOut.endsWith("}")) {
+        const parsed = JSON.parse(pyOut);
+        if (typeof parsed.cpuWatts === "number" || typeof parsed.gpuWatts === "number") {
+          return {
+            cpuWatts: parsed.cpuWatts,
+            gpuWatts: parsed.gpuWatts,
+            aneWatts: parsed.aneWatts ?? 0,
+            combinedWatts: parsed.combinedWatts ?? Math.round(((parsed.cpuWatts ?? 0) + (parsed.gpuWatts ?? 0) + (parsed.aneWatts ?? 0)) * 100) / 100
+          };
+        }
+      }
+    } 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) {
+  if (process.platform === "linux") return collectLinuxGpu();
+  if (process.platform === "win32") return collectWindowsGpu();
+  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", "", 3e3)).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() {
+  if (process.platform === "linux") return collectLinuxSystem();
+  if (process.platform === "win32") return collectWindowsSystem();
+  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 prevCpuTimesRef = { current: prevCpuTimes };
+  if (process.platform === "linux") {
+    const res = await collectLinuxCpu(prevCpuTimesRef);
+    prevCpuTimes = prevCpuTimesRef.current;
+    return res;
+  }
+  if (process.platform === "win32") {
+    const res = await collectWindowsCpu(prevCpuTimesRef);
+    prevCpuTimes = prevCpuTimesRef.current;
+    return res;
+  }
+  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 {
+    }
+  }
+  if (frequency === 0) {
+    try {
+      const cpus = os3.cpus();
+      if (cpus && cpus.length > 0 && cpus[0].speed) {
+        frequency = cpus[0].speed;
+      }
+    } catch {
+    }
+  }
+  let usage = 0;
+  try {
+    const cpus = os3.cpus();
+    let totalNow = 0;
+    let idleNow = 0;
+    for (const cpu of cpus) {
+      totalNow += cpu.times.user + cpu.times.nice + cpu.times.sys + cpu.times.idle + cpu.times.irq;
+      idleNow += cpu.times.idle;
+    }
+    if (prevCpuTotal.ts > 0) {
+      const totalDelta = totalNow - prevCpuTotal.total;
+      const idleDelta = idleNow - prevCpuTotal.idle;
+      if (totalDelta > 0) {
+        usage = Math.round((totalDelta - idleDelta) / totalDelta * 100);
+      }
+    }
+    prevCpuTotal = { total: totalNow, idle: idleNow, ts: Date.now() };
+  } 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 = os3.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 {
+  }
+  let clusters;
+  try {
+    const eCoresStr = await cachedSysctl("hw.perflevel1.physicalcpu", "0");
+    const pCoresStr = await cachedSysctl("hw.perflevel0.physicalcpu", "0");
+    const eCores = parseInt(eCoresStr, 10) || 0;
+    const pCores = parseInt(pCoresStr, 10) || 0;
+    if (eCores > 0 || pCores > 0) {
+      clusters = [];
+      if (eCores > 0) {
+        clusters.push({
+          name: "E-Cluster",
+          cores: eCores,
+          frequencyMhz: Math.round(frequency * 0.6) || 2e3,
+          effectiveUsagePercent: Math.min(100, Math.round(usage * 0.8)),
+          activeResidencyPercent: Math.min(100, Math.round(usage * 0.9))
+        });
+      }
+      if (pCores > 0) {
+        clusters.push({
+          name: "P-Cluster",
+          cores: pCores,
+          frequencyMhz: frequency || 3200,
+          effectiveUsagePercent: Math.min(100, Math.round(usage * 1.1)),
+          activeResidencyPercent: Math.min(100, Math.round(usage))
+        });
+      }
+    }
+  } catch {
+  }
+  return { brand, cores, physicalCores, frequency, usage, loadAvg, temperature, coreUsage, clusters };
+}
+async function collectMemory() {
+  if (process.platform === "linux") return collectLinuxMemory();
+  if (process.platform === "win32") return collectWindowsMemory();
+  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 prevDiskIoSample2 = null;
+var cachedDiskIo2 = null;
+async function getDiskIoRates() {
+  const now = Date.now();
+  if (cachedDiskIo2 && now - cachedDiskIo2.ts < 1e3) {
+    return { readBytesSec: cachedDiskIo2.readBytesSec, writeBytesSec: cachedDiskIo2.writeBytesSec };
+  }
+  try {
+    const raw = (await run("iostat -Id -c 1", "", 1e3)).trim();
+    const lines = raw.split("\n");
+    if (lines.length >= 3) {
+      const dataLine = lines[lines.length - 1].trim();
+      const parts = dataLine.split(/\s+/);
+      if (parts.length >= 3) {
+        const totalMb = parseFloat(parts[2]);
+        if (!isNaN(totalMb)) {
+          const totalBytes = totalMb * 1024 * 1024;
+          let bytesSec = 0;
+          if (prevDiskIoSample2 && prevDiskIoSample2.ts > 0) {
+            const dt = Math.max((now - prevDiskIoSample2.ts) / 1e3, 1e-3);
+            bytesSec = Math.max(0, (totalBytes - prevDiskIoSample2.totalBytes) / dt);
+          }
+          prevDiskIoSample2 = { totalBytes, ts: now };
+          cachedDiskIo2 = { readBytesSec: Math.round(bytesSec * 0.6), writeBytesSec: Math.round(bytesSec * 0.4), ts: now };
+          return { readBytesSec: cachedDiskIo2.readBytesSec, writeBytesSec: cachedDiskIo2.writeBytesSec };
+        }
+      }
+    }
+  } catch {
+  }
+  return { readBytesSec: 0, writeBytesSec: 0 };
+}
+async function collectDisk() {
+  if (process.platform === "linux") return collectLinuxDisk();
+  if (process.platform === "win32") return collectWindowsDisk();
+  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() {
+  if (process.platform === "linux") return collectLinuxBattery();
+  if (process.platform === "win32") return collectWindowsBattery();
+  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", "", 3e3)).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";
+    let friendlySummary;
+    const condLower = (condition || "").toLowerCase();
+    if (condLower.includes("service") || condLower.includes("replace") || condLower.includes("check")) {
+      friendlySummary = "Your battery has more wear than usual \u2014 consider a service appointment.";
+    } else if (cycles !== void 0 && cycles > 1e3) {
+      friendlySummary = "Your battery cycle count is high \u2014 capacity may be reduced.";
+    } else if (maxCapacityPercent !== void 0 && maxCapacityPercent < 80) {
+      friendlySummary = "Your battery maximum capacity is below 80% \u2014 consider servicing.";
+    } else if (condition) {
+      friendlySummary = `Battery condition is ${condition.toLowerCase()}.`;
+    }
+    const estimate = estimateBatteryLife(level, state);
+    let powerWatts;
+    if (!powerPlugged && state === "discharging") {
+      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) {
+            powerWatts = Math.round(watts * 100) / 100;
+          }
+        }
+      } catch {
+      }
+    }
+    return {
+      level,
+      state,
+      timeRemaining,
+      health,
+      powerSource: powerPlugged ? "AC" : "Battery",
+      cycles,
+      condition,
+      maxCapacityPercent,
+      friendlySummary,
+      powerWatts,
+      ...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) {
+  if (process.platform === "linux") return collectLinuxThermal();
+  if (process.platform === "win32") return collectWindowsThermal();
+  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)`;
+    }
+    let fans = [];
+    try {
+      const smcData = await getSmcMetrics();
+      fans = smcData.fans;
+    } catch {
+    }
+    return {
+      state,
+      detail,
+      pressureLevel: pressureFromState(state),
+      temperatures: Object.keys(temperatures).length ? temperatures : void 0,
+      fans: fans.length > 0 ? fans : void 0
+    };
+  } catch {
+    return { state: "Unknown", pressureLevel: 0, error: "Thermal info unavailable on this system" };
+  }
+}
+async function collectNetwork() {
+  if (process.platform === "linux") return collectLinuxNetwork();
+  if (process.platform === "win32") return collectWindowsNetwork();
+  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;
+        }
+      }
+    }
+    const now = Date.now();
+    let rxRate = 0;
+    let txRate = 0;
+    if (prevNetSample3 && prevNetSample3.ts > 0) {
+      const dt = Math.max((now - prevNetSample3.ts) / 1e3, 1e-3);
+      rxRate = Math.max(0, (rxBytes - prevNetSample3.rxBytes) / dt);
+      txRate = Math.max(0, (txBytes - prevNetSample3.txBytes) / dt);
+    }
+    prevNetSample3 = { rxBytes, txBytes, rxPackets, txPackets, ts: now };
+    const protocolStats = await getProtocolStats();
+    const connectionStates = await getConnectionStates();
+    const listeningPorts = await getListeningPorts();
+    const establishedConnections = connectionStates.established;
+    const topRemoteHosts = await getTopRemoteHosts();
+    return {
+      interface: iface,
+      ip,
+      rxBytes,
+      txBytes,
+      rxPackets,
+      txPackets,
+      rxRate,
+      txRate,
+      connections: establishedConnections,
+      protocols: protocolStats,
+      connectionStates,
+      listeningPorts,
+      establishedConnections,
+      topRemoteHosts
+    };
+  } catch {
+    return {
+      interface: "unknown",
+      ip: "0.0.0.0",
+      rxBytes: 0,
+      txBytes: 0,
+      rxPackets: 0,
+      txPackets: 0,
+      rxRate: 0,
+      txRate: 0,
+      connections: 0,
+      protocols: { tcp: { connections: 0, rxBytes: 0, txBytes: 0 }, udp: { connections: 0, rxBytes: 0, txBytes: 0 } },
+      connectionStates: { established: 0, listening: 0, timeWait: 0, closeWait: 0, other: 0 },
+      listeningPorts: [],
+      establishedConnections: 0,
+      topRemoteHosts: []
+    };
+  }
+}
+async function getProtocolStats() {
+  try {
+    const raw = await run("netstat -n -p tcp 2>/dev/null | tail -n +3 | awk '{print $1}' | sort | uniq -c", "");
+    const tcpConnections = (await run("netstat -n -p tcp 2>/dev/null | tail -n +3 | wc -l", "0")).trim();
+    const udpConnections = (await run("netstat -n -p udp 2>/dev/null | tail -n +3 | wc -l", "0")).trim();
+    let tcpRxBytes = 0;
+    let tcpTxBytes = 0;
+    let udpRxBytes = 0;
+    let udpTxBytes = 0;
+    try {
+      const netstat = await cachedNetstatIb();
+      for (const line of netstat.split("\n")) {
+        const parts = line.split(/\s+/);
+        if (parts.length >= 9 && parts[0] && !parts[0].startsWith("Name")) {
+          const iface = parts[0];
+          if (iface.includes("lo")) continue;
+          const rx = parseInt(parts[5]) || 0;
+          const tx = parseInt(parts[7]) || 0;
+          tcpRxBytes += rx;
+          tcpTxBytes += tx;
+        }
+      }
+    } catch {
+    }
+    return {
+      tcp: {
+        connections: parseInt(tcpConnections) || 0,
+        rxBytes: tcpRxBytes,
+        txBytes: tcpTxBytes
+      },
+      udp: {
+        connections: parseInt(udpConnections) || 0,
+        rxBytes: udpRxBytes,
+        txBytes: udpTxBytes
+      }
+    };
+  } catch {
+    return { tcp: { connections: 0, rxBytes: 0, txBytes: 0 }, udp: { connections: 0, rxBytes: 0, txBytes: 0 } };
+  }
+}
+async function getConnectionStates() {
+  try {
+    const raw = await run("netstat -n -p tcp 2>/dev/null | tail -n +3 | awk '{print $6}' | sort | uniq -c", "");
+    const lines = raw.split("\n").filter(Boolean);
+    const stats = { established: 0, listening: 0, timeWait: 0, closeWait: 0, other: 0 };
+    for (const line of lines) {
+      const match = line.match(/(\d+)\s+(\S+)/);
+      if (!match) continue;
+      const count = parseInt(match[1]);
+      const state = match[2].toUpperCase();
+      if (state.includes("ESTABLISHED")) stats.established += count;
+      else if (state.includes("LISTEN")) stats.listening += count;
+      else if (state.includes("TIME_WAIT")) stats.timeWait += count;
+      else if (state.includes("CLOSE_WAIT")) stats.closeWait += count;
+      else stats.other += count;
+    }
+    return stats;
+  } catch {
+    return { established: 0, listening: 0, timeWait: 0, closeWait: 0, other: 0 };
+  }
+}
+async function getListeningPorts() {
+  try {
+    const raw = await run("netstat -n -p tcp 2>/dev/null | grep LISTEN | awk '{print $4}' | rev | cut -d. -f1 | rev", "");
+    const ports = raw.split("\n").map((p) => parseInt(p, 10)).filter((p) => !isNaN(p) && p > 0);
+    return [...new Set(ports)].sort((a, b) => a - b);
+  } catch {
+    return [];
+  }
+}
+async function getTopRemoteHosts() {
+  try {
+    const raw = await run("netstat -n -p tcp 2>/dev/null | tail -n +3 | grep ESTABLISHED | awk '{print $5}' | rev | cut -d. -f1 | rev", "");
+    const ports = raw.split("\n").filter(Boolean);
+    const hostMap = /* @__PURE__ */ new Map();
+    for (const port of ports) {
+      const host = port.split(":")[0];
+      if (!host || host === "127.0.0.1" || host === "::1") continue;
+      const existing = hostMap.get(host) || { count: 0, bytes: 0 };
+      hostMap.set(host, { count: existing.count + 1, bytes: existing.bytes });
+    }
+    const result = [];
+    for (const [host, info] of hostMap.entries()) {
+      result.push({
+        host,
+        ip: host,
+        bytesTransferred: info.bytes,
+        connectionCount: info.count
+      });
+    }
+    return result.sort((a, b) => b.connectionCount - a.connectionCount).slice(0, 10);
+  } catch {
+    return [];
+  }
+}
+async function collectProcesses(limit) {
+  if (process.platform === "linux") return collectLinuxProcesses(limit);
+  if (process.platform === "win32") return collectWindowsProcesses(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);
+      const command = parts[8];
+      const isGpuOrMl = /gpu|metal|vulkan|cuda|ollama|llama|torch|mps|mlx|coreml|python/i.test(command);
+      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, isGpuOrMlAttributed: isGpuOrMl };
+    }).filter((p) => p !== null && p.pid > 0);
+  } catch {
+    return [];
+  }
+}
+function parseBytes(str) {
+  if (!str) return 0;
+  const match = str.trim().match(/([\d.]+)\s*([KMGTPE]?)i?B?/i);
+  if (!match) return 0;
+  let val = parseFloat(match[1]);
+  const unit = match[2].toUpperCase();
+  if (unit === "K") val *= 1024;
+  else if (unit === "M") val *= 1024 * 1024;
+  else if (unit === "G") val *= 1024 * 1024 * 1024;
+  else if (unit === "T") val *= 1024 * 1024 * 1024 * 1024;
+  return Math.round(val);
+}
+async function collectPackets() {
+  if (process.platform === "linux") return collectLinuxPackets();
+  if (process.platform === "win32") return collectWindowsPackets();
+  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;
+    let allProcesses = [];
+    try {
+      const nettop = (await run("script -q /dev/null nettop -l 1 -J bytes_in,bytes_out,state 2>/dev/null", "", 2e3)).trim();
+      const rows = nettop.split("\n");
+      let currentProc = null;
+      for (const row of rows) {
+        if (!row || row.includes("bytes_in")) continue;
+        const parts = row.trimStart().split(/\s{2,}/);
+        const nameCol = parts[0];
+        if (!nameCol.includes("<->")) {
+          if (currentProc) {
+            if (currentProc.connections && currentProc.connections.length > 0) {
+              allProcesses.push(currentProc);
+            }
+          }
+          const lastDot = nameCol.lastIndexOf(".");
+          let pid = 0;
+          let command = nameCol;
+          if (lastDot > 0) {
+            const possiblePid = parseInt(nameCol.substring(lastDot + 1));
+            if (!isNaN(possiblePid)) {
+              pid = possiblePid;
+              command = nameCol.substring(0, lastDot);
+            }
+          }
+          const rx = parseBytes(parts[1]);
+          const tx = parseBytes(parts[2]);
+          currentProc = { pid, command, rxBytes: rx, txBytes: tx, connections: [] };
+        } else {
+          if (currentProc) {
+            let state = "";
+            let rx = 0;
+            let tx = 0;
+            if (parts.length >= 4) {
+              state = parts[1];
+              rx = parseBytes(parts[2]);
+              tx = parseBytes(parts[3]);
+            } else if (parts.length === 3) {
+              rx = parseBytes(parts[1]);
+              tx = parseBytes(parts[2]);
+            }
+            if (state === "Established") connections++;
+            const spaceIdx = nameCol.indexOf(" ");
+            const protocol = spaceIdx > 0 ? nameCol.substring(0, spaceIdx) : "";
+            const endpoints = spaceIdx > 0 ? nameCol.substring(spaceIdx + 1) : nameCol;
+            const arrowIdx = endpoints.indexOf("<->");
+            let local = "";
+            let remote = "";
+            if (arrowIdx > 0) {
+              local = endpoints.substring(0, arrowIdx);
+              remote = endpoints.substring(arrowIdx + 3);
+              remote = resolveIp(remote);
+            } else {
+              local = endpoints;
+            }
+            currentProc.connections.push({ protocol, local, remote, state, rxBytes: rx, txBytes: tx });
+          }
+        }
+      }
+      if (currentProc && currentProc.connections && currentProc.connections.length > 0) {
+        allProcesses.push(currentProc);
+      }
+    } catch {
+      allProcesses = [];
+    }
+    const topProcesses = [...allProcesses].sort((a, b) => b.rxBytes + b.txBytes - (a.rxBytes + a.txBytes));
+    const protocolStats = await getProtocolStats();
+    const connectionStates = await getConnectionStates();
+    const listeningPorts = await getListeningPorts();
+    return {
+      totalPackets: totalRxPackets + totalTxPackets,
+      rxPackets: totalRxPackets,
+      txPackets: totalTxPackets,
+      rxRate: 0,
+      txRate: 0,
+      connections,
+      topProcesses,
+      interfaces: ifaceStats,
+      allProcesses,
+      protocolStats,
+      connectionStates,
+      listeningPorts
+    };
+  } catch {
+    return null;
+  }
+}
+async function collectTasks(limit = 12) {
+  if (process.platform === "linux") return collectLinuxTasks(limit);
+  if (process.platform === "win32") return collectWindowsTasks(limit);
+  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() {
+  if (process.platform === "linux") return getLinuxDisplayInfo();
+  if (process.platform === "win32") return getWindowsDisplayInfo();
+  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() {
+  if (process.platform !== "darwin") {
+    return { configured: false, running: false };
+  }
+  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,
+  collectContainers,
+  collectPower,
+  collectGpu,
+  collectSystem,
+  collectCpu,
+  collectMemory,
+  collectDisk,
+  collectBattery,
+  collectThermal,
+  collectNetwork,
+  collectProcesses,
+  collectPackets,
+  collectTasks,
+  getDisplayInfo,
+  getTimeMachineStatus
+};