pyre-cli 9.5.1 → 10.0.0

package/src/monitors/collectors.ts

@@ -13,9 +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 type { StatsData, CpuData, MemoryData, ThermalData, BatteryData, PowerData, DiskData, NetworkData, ProcessData, GpuData, PacketData, NetworkProcess, TaskData } from './types.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;
@@ -30,6 +65,33 @@ let netstatIbCache: { raw: string; ts: number } | null = null;
 let routeCache: { iface: string; ip: string; ts: number } | null = null;
 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);
@@ -77,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') {
@@ -113,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] = 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(),
@@ -140,8 +199,16 @@ export async function collectAll(opts: { detailed?: boolean; processLimit?: numb
      collectPower(),
      collectPackets(),
      collectTasks(),
+     collectContainers(),
+     collectBlenderRenders(),
+     collectBuilds(),
    ]);
 
+   const battery = rawBattery ? {
+     ...rawBattery,
+     smartPrediction: computeSmartBatteryPrediction(rawBattery, power) || undefined,
+   } : null;
+
    return {
      header: {
        title: chalk.hex('#ff5500').bold('PYRE'),
@@ -161,66 +228,100 @@ export async function collectAll(opts: { detailed?: boolean; processLimit?: numb
      timestamp: new Date().toISOString(),
      packets,
      tasks,
+     containers,
+     blenderRenders,
+     activeBuilds,
    };
  }
 
+export async function collectContainers(): Promise<ContainerData[]> {
+  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 [];
+  }
+}
+
 /**
  * Read power-draw metrics (CPU watts, GPU watts, combined)
  * from the SMC via powermetrics.  Returns `null` when no
  * 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.
@@ -232,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) {
@@ -370,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();
@@ -383,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;
@@ -502,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;
 
@@ -576,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 }> {
@@ -585,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 };
         }
       }
     }
@@ -611,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(),
@@ -634,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;
@@ -703,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,
@@ -713,6 +861,7 @@ export async function collectBattery(): Promise<BatteryData | null> {
       condition,
       maxCapacityPercent,
       friendlySummary,
+      powerWatts,
       ...estimate,
     };
   } catch {
@@ -729,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();
 
@@ -797,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' };
@@ -809,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();
@@ -829,13 +992,172 @@ export async function collectNetwork(): Promise<NetworkData> {
       }
     }
 
-    return { interface: iface, ip, rxBytes, txBytes, rxPackets, txPackets };
+    const now = Date.now();
+    let rxRate = 0;
+    let txRate = 0;
+    if (prevNetSample && prevNetSample.ts > 0) {
+      const dt = Math.max((now - prevNetSample.ts) / 1000, 0.001);
+      rxRate = Math.max(0, (rxBytes - prevNetSample.rxBytes) / dt);
+      txRate = Math.max(0, (txBytes - prevNetSample.txBytes) / dt);
+    }
+    prevNetSample = { 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 };
+    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(): Promise<ProtocolStats> {
+  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 {
+      // ignore
+    }
+    
+    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(): Promise<ConnectionStateStats> {
+  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: ConnectionStateStats = { 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(): Promise<number[]> {
+  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(): Promise<RemoteHostInfo[]> {
+  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 = new Map<string, { count: number; bytes: number }>();
+    
+    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: RemoteHostInfo[] = [];
+    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 [];
   }
 }
 
 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';
@@ -857,79 +1179,163 @@ 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;
-     try {
-       const tcpConns = (await run('netstat -an | grep ESTABLISHED | wc -l', '0', 2000)).trim();
-       connections = parseInt(tcpConns) || 0;
-     } catch {
-       connections = 0;
-     }
-
-     let topProcesses: { pid: number; command: string; rxBytes: number; txBytes: number }[] = [];
-     let allProcesses: { pid: number; command: string; rxBytes: number; txBytes: number; rxPackets?: number; txPackets?: number }[] = [];
-       try {
-          const lsof = (await run('lsof -i -n -P 2>/dev/null | tail -n +2 | awk \'{print $1, $2}\' | sort | uniq -c | sort -rn', '', 2000)).trim();
-         const lsofLines = lsof.split('\n');
-         topProcesses = lsofLines.map(line => {
-           const parts = line.trim().split(/\s+/);
-           if (parts.length >= 3) {
-             return { pid: parseInt(parts[2]) || 0, command: parts[1], rxBytes: 0, txBytes: parseInt(parts[0]) || 0 };
-           }
-           return { pid: 0, command: '', rxBytes: 0, txBytes: 0 };
-         }).filter(p => p.pid > 0);
-
-         allProcesses = topProcesses;
-     } catch {
-       topProcesses = [];
-       allProcesses = [];
-     }
+  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 }[] = [];
 
-      return {
-        totalPackets: totalRxPackets + totalTxPackets,
-        rxPackets: totalRxPackets,
-        txPackets: totalTxPackets,
-        rxRate: 0,
-        txRate: 0,
-        connections,
-        topProcesses,
-        interfaces: ifaceStats,
-        allProcesses,
-      };
-   } catch {
-     return null;
-   }
- }
+    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));
+      
+      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;
+    }
+  }
 
 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();
@@ -955,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[] = [];
@@ -999,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')) {