pyre-cli 9.5.2 → 10.1.0

package/src/monitors/collectors.ts

@@ -13,11 +13,44 @@
  */
 import chalk from 'chalk';
 import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import fs from 'node:fs';
 import { run } from './run.js';
 import { getSmcMetrics, parseSuffix } from './smc.js';
 import { resolveIp } from './dns_cache.js';
 import type { StatsData, CpuData, MemoryData, ThermalData, BatteryData, PowerData, DiskData, NetworkData, ProcessData, GpuData, PacketData, NetworkProcess, TaskData, ContainerData, NetworkConnection, BlenderRenderData, ProtocolStats, ConnectionStateStats, RemoteHostInfo } from './types.js';
 import { collectBlenderRenders } from './blender.js';
+import {
+  collectLinuxSystem,
+  collectLinuxCpu,
+  collectLinuxMemory,
+  collectLinuxDisk,
+  collectLinuxBattery,
+  collectLinuxThermal,
+  collectLinuxPower,
+  collectLinuxGpu,
+  collectLinuxNetwork,
+  collectLinuxPackets,
+  collectLinuxProcesses,
+  collectLinuxTasks,
+  getLinuxDisplayInfo,
+} from './platform/linux.js';
+import {
+  collectWindowsSystem,
+  collectWindowsCpu,
+  collectWindowsMemory,
+  collectWindowsDisk,
+  collectWindowsBattery,
+  collectWindowsThermal,
+  collectWindowsPower,
+  collectWindowsGpu,
+  collectWindowsNetwork,
+  collectWindowsPackets,
+  collectWindowsProcesses,
+  collectWindowsTasks,
+  getWindowsDisplayInfo,
+} from './platform/windows.js';
 
 const SP_TTL_MS = 10_000;
 const NETSTAT_TTL_MS = 1000;
@@ -34,6 +67,31 @@ const sysctlCache = new Map<string, { value: string; ts: number }>();
 
 let prevNetSample: { rxBytes: number; txBytes: number; rxPackets: number; txPackets: number; ts: number } | null = null;
 
+let cachedIoReportPath: string | null | undefined = undefined;
+function resolveIoReportScript(): string | null {
+  if (cachedIoReportPath !== undefined) return cachedIoReportPath;
+  try {
+    const dir = path.dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+      path.join(dir, 'ioreport.py'),
+      path.join(dir, '..', 'src', 'monitors', 'ioreport.py'),
+      path.join(dir, 'monitors', 'ioreport.py'),
+      path.join(process.cwd(), 'src', 'monitors', 'ioreport.py'),
+      path.join(process.cwd(), 'dist', 'ioreport.py'),
+    ];
+    for (const c of candidates) {
+      if (fs.existsSync(c)) {
+        cachedIoReportPath = c;
+        return c;
+      }
+    }
+  } catch {
+    // ignore
+  }
+  cachedIoReportPath = null;
+  return null;
+}
+
 async function cachedSysctl(key: string, fallback: string): Promise<string> {
   const now = Date.now();
   const hit = sysctlCache.get(key);
@@ -81,7 +139,7 @@ const MIN_ESTIMATE_WINDOW_MS = 30 * 1000;
 
 let prevBattery: { samples: { level: number; ts: number }[] } = { samples: [] };
 
-function estimateBatteryLife(level: number, state: string): { estimatedTimeToEmpty?: string; dischargeRatePerHour?: number; powerWatts?: number } {
+function estimateBatteryLife(level: number, state: string): { estimatedTimeToEmpty?: string; dischargeRatePerHour?: number } {
   const now = Date.now();
 
   if (state === 'charged' || state === 'charging') {
@@ -117,21 +175,18 @@ function estimateBatteryLife(level: number, state: string): { estimatedTimeToEmp
   const m = Math.round((hoursToEmpty - h) * 60);
   const estimatedTimeToEmpty = hoursToEmpty > 0 ? `${h}h ${m}m` : 'calculating';
 
-  // Rough wattage from discharge rate: %/hour * (typical battery capacity
-  // in Wh) / 100. This is only used as a last-resort estimate — collectPower()
-  // now prefers real ioreg-derived wattage when available (see below).
-  const ASSUMED_CAPACITY_WH = 55;
-  const powerWatts = Math.round(dischargeRate * (ASSUMED_CAPACITY_WH / 100) * 100) / 100;
-
-  return { estimatedTimeToEmpty, dischargeRatePerHour: Math.round(dischargeRate * 10) / 10, powerWatts };
+  return { estimatedTimeToEmpty, dischargeRatePerHour: Math.round(dischargeRate * 10) / 10 };
 }
 
+import { collectBuilds } from './buildTracker.js';
+import { computeSmartBatteryPrediction } from './batteryPredictor.js';
+
 /**
  * Gather every metric category in parallel and return a
  * complete {@link StatsData} snapshot.
  */
 export async function collectAll(opts: { detailed?: boolean; processLimit?: number } = {}): Promise<StatsData> {
-   const [cpu, gpu, memory, disk, battery, thermal, network, processes, system, power, packets, tasks, containers, blenderRenders] = await Promise.all([
+   const [cpu, gpu, memory, disk, rawBattery, thermal, network, processes, system, power, packets, tasks, containers, blenderRenders, activeBuilds] = await Promise.all([
      collectCpu(),
      collectGpu(opts.detailed),
      collectMemory(),
@@ -146,8 +201,14 @@ export async function collectAll(opts: { detailed?: boolean; processLimit?: numb
      collectTasks(),
      collectContainers(),
      collectBlenderRenders(),
+     collectBuilds(),
    ]);
 
+   const battery = rawBattery ? {
+     ...rawBattery,
+     smartPrediction: computeSmartBatteryPrediction(rawBattery, power) || undefined,
+   } : null;
+
    return {
      header: {
        title: chalk.hex('#ff5500').bold('PYRE'),
@@ -169,6 +230,7 @@ export async function collectAll(opts: { detailed?: boolean; processLimit?: numb
      tasks,
      containers,
      blenderRenders,
+     activeBuilds,
    };
  }
 
@@ -201,57 +263,65 @@ export async function collectContainers(): Promise<ContainerData[]> {
  * power data is available.
  */
 export async function collectPower(): Promise<PowerData | null> {
-   try {
-     const { power } = await getSmcMetrics();
-     if (power.cpu !== undefined || power.gpu !== undefined || power.combined !== undefined) {
-       return { cpuWatts: power.cpu, gpuWatts: power.gpu, aneWatts: 0, combinedWatts: power.combined };
-     }
-   } catch {
-     // ignore
-   }
+  if (process.platform === 'linux') return collectLinuxPower();
+  if (process.platform === 'win32') return collectWindowsPower();
+  try {
+    const { power } = await getSmcMetrics();
+    if (power.cpu !== undefined || power.gpu !== undefined || power.combined !== undefined) {
+      return { cpuWatts: power.cpu, gpuWatts: power.gpu, aneWatts: 0, combinedWatts: power.combined };
+    }
+  } catch {
+    // ignore
+  }
 
-   // `pmset -g batt` never actually prints a "mW" figure on any macOS
-   // version — that regex could never match, so this fallback was dead
-   // code and collectPower() silently returned null whenever powermetrics
-   // wasn't available (which is most machines without passwordless sudo
-   // configured). ioreg's AppleSmartBattery entry exposes instantaneous
-   // amperage (mA, signed: negative while discharging) and voltage (mV)
-   // without any privileges, so we can derive real wattage from that.
-   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) {
-       // Two representations show up in the wild: Intel Macs often print a
-       // literal minus sign ("-1200") — no unwrap needed. Apple Silicon
-       // instead wraps a negative reading into an *unsigned 64-bit* field
-       // (e.g. real -1200mA prints as 18446744073709550416). The previous
-       // 32-bit unwrap (`- 0x100000000`) didn't touch that at all, and
-       // `parseInt` can't even represent a number that large precisely, so
-       // it silently mangled into a huge garbage value → absurd wattage.
-       // Parse as BigInt and only unwrap when there's no explicit sign.
-       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) / 1000;
-       const watts = Math.abs((amps / 1000) * volts);
-       // Sanity clamp — a real Mac never draws anywhere near this much;
-       // treat an out-of-range reading as "no usable data" rather than
-       // display nonsense.
-       if (Number.isFinite(watts) && watts < 500) {
-         return { combinedWatts: Math.round(watts * 100) / 100 };
-       }
-     }
-   } catch {
-     // ignore
-   }
+  // Apple Silicon IOReport (reads Energy Model channels GPU Energy, CPU Energy, ANE without root)
+  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 {
+      // ignore
+    }
+  }
 
-   return null;
- }
+  // Fallback: ioreg's AppleSmartBattery entry exposes instantaneous
+  // amperage (mA, signed: negative while discharging) and voltage (mV)
+  // without any privileges, so we can derive real wattage from that.
+  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) / 1000;
+      const watts = Math.abs((amps / 1000) * volts);
+      if (Number.isFinite(watts) && watts < 500) {
+        return { combinedWatts: Math.round(watts * 100) / 100 };
+      }
+    }
+  } catch {
+    // ignore
+  }
+
+  return null;
+}
 
  /**
   * Gather GPU information from system_profiler and powermetrics.
@@ -263,6 +333,8 @@ export async function collectPower(): Promise<PowerData | null> {
    * Returns null when GPU hardware is unavailable.
    */
   export async function collectGpu(detailed?: boolean): Promise<GpuData | null> {
+    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) {
@@ -401,7 +473,9 @@ export async function collectPower(): Promise<PowerData | null> {
     return { model, memory, utilization, temperature, processes: gpuProcesses };
   }
 
-async function collectSystem(): Promise<{ hostname: string; os: string; uptime: string }> {
+export async function collectSystem(): Promise<{ hostname: string; os: string; uptime: string }> {
+  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();
@@ -414,6 +488,17 @@ async function collectSystem(): Promise<{ hostname: string; os: string; uptime:
 }
 
 export async function collectCpu(): Promise<CpuData> {
+  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;
@@ -533,6 +618,8 @@ export async function collectCpu(): Promise<CpuData> {
 }
 
 export async function collectMemory(): Promise<MemoryData> {
+  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;
 
@@ -607,7 +694,7 @@ export async function collectMemory(): Promise<MemoryData> {
   };
 }
 
-let prevDiskIoSample: { ts: number } | null = null;
+let prevDiskIoSample: { totalBytes: number; ts: number } | null = null;
 let cachedDiskIo: { readBytesSec: number; writeBytesSec: number; ts: number } | null = null;
 
 async function getDiskIoRates(): Promise<{ readBytesSec: number; writeBytesSec: number }> {
@@ -616,22 +703,23 @@ async function getDiskIoRates(): Promise<{ readBytesSec: number; writeBytesSec:
     return { readBytesSec: cachedDiskIo.readBytesSec, writeBytesSec: cachedDiskIo.writeBytesSec };
   }
   try {
-    const raw = (await run('iostat -d -c 2 1 2', '', 3000)).trim();
-    const blocks = raw.split(/\n\s*\n/).filter(Boolean);
-    const targetBlock = blocks.length > 1 ? blocks[1] : blocks[0];
-    if (targetBlock) {
-      const lines = targetBlock.trim().split('\n');
-      if (lines.length >= 2) {
-        const dataLine = lines[lines.length - 1].trim();
-        const parts = dataLine.split(/\s+/);
-        if (parts.length >= 3) {
-          const mbSec = parseFloat(parts[2]);
-          if (!isNaN(mbSec)) {
-            const bytesSec = Math.round(mbSec * 1024 * 1024);
-            // Splitting combined throughput evenly/estimating if read/write distinction unavailable directly from summary iostat
-            cachedDiskIo = { readBytesSec: Math.round(bytesSec * 0.6), writeBytesSec: Math.round(bytesSec * 0.4), ts: now };
-            return { readBytesSec: cachedDiskIo.readBytesSec, writeBytesSec: cachedDiskIo.writeBytesSec };
+    const raw = (await run('iostat -Id -c 1', '', 1000)).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 (prevDiskIoSample && prevDiskIoSample.ts > 0) {
+            const dt = Math.max((now - prevDiskIoSample.ts) / 1000, 0.001);
+            bytesSec = Math.max(0, (totalBytes - prevDiskIoSample.totalBytes) / dt);
           }
+          prevDiskIoSample = { totalBytes, ts: now };
+          cachedDiskIo = { readBytesSec: Math.round(bytesSec * 0.6), writeBytesSec: Math.round(bytesSec * 0.4), ts: now };
+          return { readBytesSec: cachedDiskIo.readBytesSec, writeBytesSec: cachedDiskIo.writeBytesSec };
         }
       }
     }
@@ -642,6 +730,8 @@ async function getDiskIoRates(): Promise<{ readBytesSec: number; writeBytesSec:
 }
 
 export async function collectDisk(): Promise<DiskData[]> {
+  if (process.platform === 'linux') return collectLinuxDisk();
+  if (process.platform === 'win32') return collectWindowsDisk();
   const [rawDf, ioRates] = await Promise.all([
     run('df -h'),
     getDiskIoRates(),
@@ -665,6 +755,8 @@ export async function collectDisk(): Promise<DiskData[]> {
 }
 
 export async function collectBattery(): Promise<BatteryData | null> {
+  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;
@@ -734,6 +826,31 @@ export async function collectBattery(): Promise<BatteryData | null> {
 
     const estimate = estimateBatteryLife(level, state);
 
+    let powerWatts: number | undefined;
+    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) / 1000;
+          const watts = Math.abs((amps / 1000) * volts);
+          if (Number.isFinite(watts) && watts < 500) {
+            powerWatts = Math.round(watts * 100) / 100;
+          }
+        }
+      } catch {
+        // ignore
+      }
+    }
+
     return {
       level,
       state,
@@ -744,6 +861,7 @@ export async function collectBattery(): Promise<BatteryData | null> {
       condition,
       maxCapacityPercent,
       friendlySummary,
+      powerWatts,
       ...estimate,
     };
   } catch {
@@ -760,6 +878,8 @@ function pressureFromState(state: string): number {
 }
 
 export async function collectThermal(detailed?: boolean): Promise<ThermalData> {
+  if (process.platform === 'linux') return collectLinuxThermal();
+  if (process.platform === 'win32') return collectWindowsThermal();
   try {
     const therm = (await run('pmset -g therm', '')).trim();
 
@@ -828,11 +948,21 @@ export async function collectThermal(detailed?: boolean): Promise<ThermalData> {
       detail = `${state} (estimated from ${cpuDieTemp}°C)`;
     }
 
+    // Collect fan speeds from SMC (same cached call as temps above)
+    let fans: import('./types.js').FanData[] = [];
+    try {
+      const smcData = await getSmcMetrics();
+      fans = smcData.fans;
+    } catch {
+      // ignore — fans unavailable without sudo
+    }
+
     return {
       state,
       detail,
       pressureLevel: pressureFromState(state),
       temperatures: Object.keys(temperatures).length ? temperatures : undefined,
+      fans: fans.length > 0 ? fans : undefined,
     };
   } catch {
     return { state: 'Unknown', pressureLevel: 0, error: 'Thermal info unavailable on this system' };
@@ -840,6 +970,8 @@ export async function collectThermal(detailed?: boolean): Promise<ThermalData> {
 }
 
 export async function collectNetwork(): Promise<NetworkData> {
+  if (process.platform === 'linux') return collectLinuxNetwork();
+  if (process.platform === 'win32') return collectWindowsNetwork();
   try {
     const { iface, ip } = await cachedRouteIface();
     const netStat = await cachedNetstatIb();
@@ -1024,6 +1156,8 @@ async function getTopRemoteHosts(): Promise<RemoteHostInfo[]> {
 }
 
 export async function collectProcesses(limit?: number): Promise<ProcessData[]> {
+   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';
@@ -1045,109 +1179,132 @@ export async function collectProcesses(limit?: number): Promise<ProcessData[]> {
   }
 }
 
+function parseBytes(str: string): number {
+  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);
+}
+
 export async function collectPackets(): Promise<PacketData | null> {
-   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: { iface: string; rxPackets: number; txPackets: number; rxBytes: number; txBytes: number }[] = [];
-
-     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: NetworkProcess[] = [];
-     
-     try {
-       const nettop = (await run('nettop -L 1 -J bytes_in,bytes_out,state 2>/dev/null', '', 2000)).trim();
-       const rows = nettop.split('\n');
-       
-       let currentProc: NetworkProcess | null = null;
-       
-       for (const row of rows) {
-         if (!row || row.startsWith(',state,')) continue;
-         
-         const cols = row.split(',');
-         const nameCol = cols[0];
-         
-         // If it doesn't contain <->, it's a process row
-         if (!nameCol.includes('<->')) {
-           if (currentProc) {
-             if (currentProc.connections && currentProc.connections.length > 0) {
-               allProcesses.push(currentProc);
-             }
-           }
-           
-           // Extract PID and Name (e.g., "syslogd.369")
-           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 = parseInt(cols[2]) || 0;
-           const tx = parseInt(cols[3]) || 0;
-           
-           currentProc = { pid, command, rxBytes: rx, txBytes: tx, connections: [] };
-         } else {
-           // Connection row
-           if (currentProc) {
-             const state = cols[1];
-             const rx = parseInt(cols[2]) || 0;
-             const tx = parseInt(cols[3]) || 0;
-             if (state === 'Established') connections++;
-             
-             // Parse endpoints (e.g. "tcp4 172.16.0.2:49844<->17.242.13.5:5223")
-             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);
-               
-               // Attempt DNS resolution on remote IP
-               remote = resolveIp(remote);
-             } else {
-               local = endpoints;
-             }
-             
-             // Ignore purely local communication if you want, but for now include all
-             currentProc.connections!.push({ protocol, local, remote, state, rxBytes: rx, txBytes: tx });
-           }
-         }
-       }
-       if (currentProc && currentProc.connections && currentProc.connections.length > 0) {
-         allProcesses.push(currentProc);
-       }
-     } catch {
-       allProcesses = [];
-     }
+  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: { iface: string; rxPackets: number; txPackets: number; rxBytes: number; txBytes: number }[] = [];
+
+    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: NetworkProcess[] = [];
+    
+    try {
+      const nettop = (await run('script -q /dev/null nettop -l 1 -J bytes_in,bytes_out,state 2>/dev/null', '', 2000)).trim();
+      const rows = nettop.split('\n');
+      
+      let currentProc: NetworkProcess | null = 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 it doesn't contain <->, it's a process row
+        if (!nameCol.includes('<->')) {
+          if (currentProc) {
+            if (currentProc.connections && currentProc.connections.length > 0) {
+              allProcesses.push(currentProc);
+            }
+          }
+          
+          // Extract PID and Name (e.g., "syslogd.369")
+          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 {
+          // Connection row
+          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++;
+            
+            // Parse endpoints (e.g. "tcp4 172.16.0.2:49844<->17.242.13.5:5223")
+            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);
+              
+              // Attempt DNS resolution on remote IP
+              remote = resolveIp(remote);
+            } else {
+              local = endpoints;
+            }
+            
+            // Ignore purely local communication if you want, but for now include all
+            currentProc.connections!.push({ protocol, local, remote, state, rxBytes: rx, txBytes: tx });
+          }
+        }
+      }
+      if (currentProc && currentProc.connections && currentProc.connections.length > 0) {
+        allProcesses.push(currentProc);
+      }
+    } catch {
+      allProcesses = [];
+    }
      
       // Sort processes by total bandwidth (tx + rx) to get top processes
       const topProcesses = [...allProcesses].sort((a, b) => (b.rxBytes + b.txBytes) - (a.rxBytes + a.txBytes));
@@ -1176,7 +1333,9 @@ export async function collectPackets(): Promise<PacketData | null> {
   }
 
 export async function collectTasks(limit = 12): Promise<TaskData[]> {
-   try {
+  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();
@@ -1202,6 +1361,8 @@ export interface DisplayInfo {
 }
 
 export async function getDisplayInfo(): Promise<DisplayInfo[]> {
+  if (process.platform === 'linux') return getLinuxDisplayInfo();
+  if (process.platform === 'win32') return getWindowsDisplayInfo();
   try {
     const raw = await run('system_profiler SPDisplaysDataType 2>&1', '');
     const displays: DisplayInfo[] = [];
@@ -1246,6 +1407,9 @@ export interface TimeMachineStatus {
 }
 
 export async function getTimeMachineStatus(): Promise<TimeMachineStatus> {
+  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')) {