pyre-cli 3.3.0 → 3.5.0

package/src/live/render.ts

@@ -8,22 +8,67 @@
  */
 import chalk from 'chalk';
 import { formatTable, formatGraphs, gridColumns, THEMES, type ThemeName, panel } from '../formatters/index.js';
-import { state, setStatus, SIGNAL_OPTIONS } from './state.js';
+import { state, setStatus, SIGNAL_OPTIONS, getToggleKey } from './state.js';
 import type { StatsData } from '../monitors/index.js';
 
+// --- render caching -----------------------------------------------------------
+
+let _cachedTable = '';
+let _cachedTableData: StatsData | null = null;
+let _cachedTableParams = '';
+let _tableDataDirty = false;
+
+function invalidateTableCache() {
+  _tableDataDirty = true;
+}
+
+let _cachedGraphs = '';
+let _cachedGraphsVersion = -1;
+let _cachedGraphsParams = '';
+
+function tableCacheParams(): string {
+  const limit = processRowBudget();
+  return [
+    state.sortMode,
+    state.processFilter || '',
+    limit,
+    state.currentTheme,
+    state.activePanel,
+    state.treeView ? '1' : '0',
+    JSON.stringify(state.visiblePanels),
+  ].join('|');
+}
+
+function graphsCacheParams(): string {
+  return [
+    state.termWidth,
+    state.currentTheme,
+    state.graphMode,
+  ].join('|');
+}
+
 /**
  * How many process rows we can realistically fit given
  * current terminal height.  Computed from the number of
  * card columns and the reserved space for the header,
  * cards, graphs, and footer.
  */
-function processRowBudget(): number {
-  const columns = gridColumns(state.termWidth);
-  const visibleCards = Object.values(state.visiblePanels).filter(v => v !== false).length;
-  const cardRows = Math.ceil(visibleCards / columns);
-  const reserved = 2 + cardRows * 8 + 11 + (state.showGraphs ? 9 : 0) + 4;
-  return Math.max(3, Math.min(40, state.termHeight - reserved));
-}
+  function processRowBudget(): number {
+    let overlayRows = 0;
+    if (state.inputMode === 'customizer') overlayRows = state.CUSTOMIZER_OPTIONS.length + 3;
+    else if (state.inputMode === 'signal') overlayRows = 6;
+    else if (state.inputMode === 'filter' || state.inputMode === 'kill' || state.inputMode === 'p2p') overlayRows = 3;
+
+    if (state.activePanel === 'process') {
+      return Math.max(10, state.termHeight - 12 - overlayRows);
+    }
+
+    const columns = gridColumns(state.termWidth);
+    const visibleCards = Object.values(state.visiblePanels).filter(v => v !== false).length;
+    const cardRows = Math.ceil(visibleCards / columns);
+    const reserved = 4 + cardRows * 8 + 8 + (state.showGraphs ? 11 : 0) + 5 + overlayRows;
+    return Math.max(5, state.termHeight - reserved);
+  }
 
 function p2pPanelLines(): { title: string; body: string[] } {
   const events = state.p2pServer ? state.p2pServer.peerEventHistory : state.p2pEvents;
@@ -66,106 +111,175 @@ function renderCustomizerOverlay(): string {
         lines.push(`${prefix}${opt}: ${chalk.bold.green(state.currentTheme)} [${themesList.join(', ')}]`);
       } else if (opt === 'Graph Mode') {
         lines.push(`${prefix}${opt}: ${chalk.bold.green(state.graphMode)} [spark, bar]`);
-      } else if (opt === 'Toggle Tree View') {
-
-       const status = state.treeView ? chalk.green('[VISIBLE]') : chalk.red('[HIDDEN]');
-       lines.push(`${prefix}${opt}: ${status}`);
-     } else {
-       const key = opt.replace('Toggle ', '').toLowerCase();
-       const isVisible = state.visiblePanels[key as keyof typeof state.visiblePanels] !== false;
-       const status = isVisible ? chalk.green('[VISIBLE]') : chalk.red('[HIDDEN]');
-       lines.push(`${prefix}${opt}: ${status}`);
-     }
+      } else {
+        const toggleKey = getToggleKey(opt);
+        const isVisible = toggleKey ? (toggleKey === 'tree' ? state.treeView : state.visiblePanels[toggleKey] !== false) : true;
+        const status = isVisible ? chalk.green('[VISIBLE]') : chalk.red('[HIDDEN]');
+        lines.push(`${prefix}${opt}: ${status}`);
+      }
    });
 
    return lines.map(l => `  ${l}`).join('\n');
  }
 
+// --- frame diffing -------------------------------------------------------
+// Instead of erasing the whole screen (`\x1b[2J`) and repainting everything
+// on every keypress/tick, we keep the previous frame's lines around and
+// only move the cursor + rewrite the lines that actually changed. A full
+// erase forces a scrollback/display invalidation in many terminals
+// (iTerm2, Windows Terminal, tmux, various SSH clients), which is what
+// made menu navigation and tab switches feel like they took a second or
+// two even though the underlying data was already cached.
+let _prevFrameLines: string[] = [];
+let _frameDirty = true; // force full paint on first render / resize
+
+function invalidateFrame() {
+  _frameDirty = true;
+}
+
+function writeFrame(lines: string[]) {
+  if (_frameDirty || _prevFrameLines.length === 0 || lines.length !== _prevFrameLines.length) {
+    process.stdout.write('\x1b[?25l\x1b[H' + lines.map(l => `\x1b[2K${l}`).join('\r\n') + '\x1b[0J');
+    _prevFrameLines = lines;
+    _frameDirty = false;
+    return;
+  }
+
+  // Incremental repaint: move to each changed line and rewrite only
+  // that line, clearing to end-of-line first so shorter replacement
+  // text doesn't leave stale characters behind.
+  let out = '';
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i] !== _prevFrameLines[i]) {
+      out += `\x1b[${i + 1};1H\x1b[2K${lines[i]}`;
+    }
+  }
+  if (out) process.stdout.write(out);
+  _prevFrameLines = lines;
+}
+
 function render() {
   if (!state.lastData) return;
   const lines: string[] = [];
   const theme = THEMES[state.currentTheme] || THEMES.default;
 
+  const params = tableCacheParams();
+  const tableStr = _tableDataDirty || state.lastData !== _cachedTableData || params !== _cachedTableParams
+    ? (() => {
+        const out = formatTable(state.lastData, {
+          width: state.termWidth,
+          sortBy: state.sortMode,
+          filter: state.processFilter || undefined,
+          processLimit: processRowBudget(),
+          theme: state.currentTheme,
+          visible: state.visiblePanels,
+          treeView: state.treeView,
+          activePanel: state.activePanel,
+        });
+        _cachedTableData = state.lastData;
+        _cachedTableParams = params;
+        _cachedTable = out;
+        _tableDataDirty = false;
+        return out;
+      })()
+    : _cachedTable;
+
+  const bodyLines: string[] = [];
   if (state.activePanel === 'p2p') {
     const panelLines = p2pPanelLines();
-    lines.push(...panel(panelLines.title, panelLines.body, state.termWidth, theme.process, theme.border));
+    bodyLines.push(...panel(panelLines.title, panelLines.body, state.termWidth, theme.process, theme.border));
   } else {
-    lines.push(
-      formatTable(state.lastData, {
-        width: state.termWidth,
-        sortBy: state.sortMode,
-        filter: state.processFilter || undefined,
-        processLimit: processRowBudget(),
-        theme: state.currentTheme,
-        visible: state.visiblePanels,
-        treeView: state.treeView,
-        activePanel: state.activePanel,
-      })
-    );
+    bodyLines.push(...tableStr.split('\n'));
   }
 
+  const graphsParams = graphsCacheParams();
+  const graphsStr =
+    state.history.version !== _cachedGraphsVersion || graphsParams !== _cachedGraphsParams
+      ? (() => {
+          const out = formatGraphs(state.history, state.termWidth, state.currentTheme, state.graphMode);
+          _cachedGraphsVersion = state.history.version;
+          _cachedGraphsParams = graphsParams;
+          _cachedGraphs = out;
+          return out;
+        })()
+      : _cachedGraphs;
+
   if (state.showGraphs && state.activePanel !== 'p2p') {
-    lines.push('');
-    lines.push(formatGraphs(state.history, state.termWidth, state.currentTheme, state.graphMode));
+    bodyLines.push('');
+    bodyLines.push(...graphsStr.split('\n'));
   }
 
-  lines.push('');
-  lines.push(footerLine());
+  const footerLines: string[] = [];
+  footerLines.push('');
+  footerLines.push(...footerLine().split('\n'));
 
   if (state.inputMode === 'customizer') {
-      lines.push(renderCustomizerOverlay());
+      footerLines.push(...renderCustomizerOverlay().split('\n'));
     } else if (state.inputMode === 'filter') {
-      lines.push(chalk.cyan(`  Filter processes: ${state.inputBuffer}_`));
+      footerLines.push(chalk.cyan(`  Filter processes: ${state.inputBuffer}_`));
     } else if (state.inputMode === 'kill') {
-      lines.push(chalk.cyan(`  Kill PID: ${state.inputBuffer}_  (enter to confirm, esc to cancel)`));
+      footerLines.push(chalk.cyan(`  Kill PID: ${state.inputBuffer}_  (enter to confirm, esc to cancel)`));
      } else if (state.inputMode === 'signal') {
        const sigIdx = state.SIGNAL_OPTIONS.indexOf(state.inputBuffer as typeof state.SIGNAL_OPTIONS[number]);
        const sigList = state.SIGNAL_OPTIONS.map((s, i) => i === sigIdx ? chalk.yellow(s) : chalk.dim(s)).join('  ');
-       lines.push(chalk.cyan(`  Signal: ${state.inputBuffer}_`));
-       lines.push(chalk.dim(`  ${sigList}`));
-       lines.push(chalk.dim('  ↑/↓ to select, Enter to confirm, Esc to cancel'));
+       footerLines.push(chalk.cyan(`  Signal: ${state.inputBuffer}_`));
+       footerLines.push(chalk.dim(`  ${sigList}`));
+       footerLines.push(chalk.dim('  ↑/↓ to select, Enter to confirm, Esc to cancel'));
      } else if (state.inputMode === 'p2p') {
-       lines.push(chalk.cyan(`  P2P password (${state.p2pPort}): ${state.inputBuffer}_  (enter to start, esc to cancel)`));
+       footerLines.push(chalk.cyan(`  P2P password (${state.p2pPort}): ${state.inputBuffer}_  (enter to start, esc to cancel)`));
      } else if (state.statusMessage) {
-       lines.push(`  ${state.statusMessage}`);
-    }
+       footerLines.push(`  ${state.statusMessage}`);
+     } else {
+       footerLines.push('');
+     }
+
+  const maxBodyLines = Math.max(1, state.termHeight - footerLines.length);
+  if (bodyLines.length > maxBodyLines) {
+    bodyLines.length = maxBodyLines;
+  }
 
-  process.stdout.write('\x1b[2J\x1b[H');
-  process.stdout.write(lines.join('\n'));
+  const frameLines = [...bodyLines, ...footerLines];
+  if (frameLines.length > state.termHeight) {
+    frameLines.length = state.termHeight;
+  }
+  writeFrame(frameLines);
 }
 
 function footerLine(): string {
-   const keys: [string, string][] = [
+   const row1: [string, string][] = [
      ['q', 'quit'],
      ['c', 'customize UI'],
+     ['←/→', 'tab'],
+     ['1-9', 'panels'],
+     ['g', state.showGraphs ? 'hide graphs' : 'show graphs'],
+     ['b', `graph:${state.graphMode}`],
+     ['t', state.treeView ? 'flat' : 'tree'],
+     ['d', state.detailed ? 'basic' : 'detailed'],
+     ['p', state.paused ? 'resume' : 'pause'],
+   ];
+   const row2: [string, string][] = [
+     ['s', `sort:${state.sortMode}`],
+     ['/', 'filter'],
+     ['k', 'kill'],
+     ['S', 'signal'],
+     ['e', 'export'],
+     ['l', state.logging ? 'stop log' : 'log'],
+     ['f', state.exportFormat],
+     ['+/-', `${state.interval}s`],
      ['r', state.p2pServerRunning ? 'stop p2p' : 'start p2p'],
-      ['p', state.paused ? 'resume' : 'pause'],
-       ['g', state.showGraphs ? 'hide graphs' : 'show graphs'],
-       ['b', `graph:${state.graphMode}`],
-       ['d', state.detailed ? 'basic' : 'detailed'],
-       ['←/→', 'tab'],
-       ['1-9', 'panels'],
-       ['s', `sort:${state.sortMode}`],
-       ['/', 'filter'],
-       ['k', 'kill'],
-       ['S', 'signal'],
-       ['t', state.treeView ? 'flat' : 'tree'],
-       ['e', 'export'],
-       ['l', state.logging ? 'stop log' : 'log'],
-       ['f', state.exportFormat],
-       ['+/-', `${state.interval}s`],
-     ];
-    const keyStr = keys.map(([k, label]) => `${chalk.hex('#50fa7b').bold(k)} ${chalk.dim(label)}`).join(chalk.dim('  |  '));
-
+   ];
+   const fmt = (list: [string, string][]) => list.map(([k, label]) => `${chalk.hex('#50fa7b').bold(k)} ${chalk.dim(label)}`).join(chalk.dim('  |  '));
+   const str1 = fmt(row1);
+   const str2 = fmt(row2);
 
    const badges: string[] = [];
    if (state.paused) badges.push(chalk.yellow.bold('⏸ PAUSED'));
    if (state.logging) badges.push(chalk.red.bold('● REC'));
    if (state.activePanel !== 'grid') badges.push(chalk.cyan.bold(`◉ ${state.activePanel.toUpperCase()}`));
-     if (state.p2pServerRunning) badges.push(chalk.green.bold(`P2P ${state.p2pBind || '0.0.0.0'}:${state.p2pPort}`));
+   if (state.p2pServerRunning) badges.push(chalk.green.bold(`P2P ${state.p2pBind || '0.0.0.0'}:${state.p2pPort}`));
    const badgeStr = badges.join('  ');
 
-   return badgeStr ? `${keyStr}    ${badgeStr}` : keyStr;
+   return badgeStr ? `${str1}\n${str2}    ${badgeStr}` : `${str1}\n${str2}`;
   }
 
 function checkAlerts(data: StatsData) {
@@ -181,4 +295,4 @@ function checkAlerts(data: StatsData) {
   }
 }
 
-export { render, footerLine, renderCustomizerOverlay, checkAlerts, processRowBudget };
+export { render, footerLine, renderCustomizerOverlay, checkAlerts, processRowBudget, invalidateTableCache, invalidateFrame };

package/src/live/state.ts

@@ -16,6 +16,7 @@ export const SIGNAL_OPTIONS = ['SIGTERM', 'SIGKILL', 'SIGINT', 'SIGHUP', 'SIGSTO
 
 const state = {
    intervalHandle: null as NodeJS.Timeout | null,
+   uiIntervalHandle: null as NodeJS.Timeout | null,
    running: false,
    paused: false,
    detailed: false,
@@ -53,6 +54,8 @@ const state = {
    processFilter: '',
    inputMode: null as InputMode,
    inputBuffer: '',
+   targetPid: '',
+   selectedSignal: 'SIGTERM' as typeof SIGNAL_OPTIONS[number],
    treeView: false,
    SIGNAL_OPTIONS,
    customizerIndex: 0,
@@ -107,4 +110,22 @@ function setStatus(msg: string, ms = 3000) {
   }, ms);
 }
 
-export { state, setStatus };
+function getToggleKey(opt: string): keyof VisibleItems | null {
+  const map: Record<string, keyof VisibleItems> = {
+    'Toggle CPU': 'cpu',
+    'Toggle Memory': 'mem',
+    'Toggle GPU': 'gpu',
+    'Toggle Power': 'power',
+    'Toggle Battery': 'battery',
+    'Toggle Thermal': 'thermal',
+    'Toggle Network': 'network',
+    'Toggle Packets': 'packets',
+    'Toggle Tasks': 'tasks',
+    'Toggle Disk': 'disk',
+    'Toggle Processes': 'process',
+    'Toggle Tree View': 'tree',
+  };
+  return map[opt] ?? null;
+}
+
+export { state, setStatus, getToggleKey };

package/src/live/types.ts

@@ -10,6 +10,7 @@ export interface LiveOptions {
   detailed?: boolean;
   exportDir?: string;
   autoLog?: boolean;
+  theme?: ThemeName;
 }
 
 export type ExportFormat = 'json' | 'csv' | 'tsv';

package/src/monitors/collectors.ts

@@ -16,6 +16,52 @@ 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 } from './types.js';
 
+const SP_TTL_MS = 10_000;
+const NETSTAT_TTL_MS = 1000;
+const ROUTE_TTL_MS = 5_000;
+const SYSCTL_TTL_MS = 60_000;
+
+let spGpuCache: { raw: string; ts: number } | null = null;
+let spBatteryCache: { raw: string; ts: number } | null = null;
+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 }>();
+
+async function cachedSysctl(key: string, fallback: string): Promise<string> {
+  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(): Promise<string> {
+  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(): Promise<{ iface: string; ip: string }> {
+  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 {
+    // ignore
+  }
+  routeCache = { iface, ip, ts: now };
+  return routeCache;
+}
+
 // Retain samples over a *time* window rather than a fixed tick count. At the
 // default 2s refresh interval the old 10-sample window only spanned ~20s,
 // but battery level only moves in whole-percent steps that typically take
@@ -178,58 +224,61 @@ export async function collectPower(): Promise<PowerData | null> {
   * Returns null when GPU data is unavailable (e.g. on machines
   * without a discrete GPU or when powermetrics is inaccessible).
   */
- export async function collectGpu(detailed?: boolean): Promise<GpuData | null> {
-   try {
-     const spRaw = (await run('system_profiler SPDisplaysDataType 2>/dev/null')).trim();
-     if (!spRaw) return null;
-
-     const modelMatch = spRaw.match(/Chipset Model:\s*(.+)/i);
-     const model = modelMatch ? modelMatch[1].trim() : 'Unknown';
-
-     const memMatch = spRaw.match(/VRAM \(Total\):\s*(.+)/i);
-     let memory = 0;
-     if (memMatch) {
-       const memStr = memMatch[1].trim();
-       const memNum = parseFloat(memStr);
-       if (memStr.includes('GB')) memory = memNum * 1024 * 1024 * 1024;
-       else if (memStr.includes('MB')) memory = memNum * 1024 * 1024;
-     }
+  export async function collectGpu(detailed?: boolean): Promise<GpuData | null> {
+    let spRaw = '';
+    const now = Date.now();
+    if (spGpuCache && now - spGpuCache.ts < SP_TTL_MS) {
+      spRaw = spGpuCache.raw;
+    } else {
+      spRaw = (await run('system_profiler SPDisplaysDataType 2>/dev/null')).trim();
+      spGpuCache = { raw: spRaw, ts: now };
+    }
+    if (!spRaw) return null;
+
+    const modelMatch = spRaw.match(/Chipset Model:\s*(.+)/i);
+    const model = modelMatch ? modelMatch[1].trim() : 'Unknown';
+
+    const memMatch = spRaw.match(/VRAM \(Total\):\s*(.+)/i);
+    let memory = 0;
+    if (memMatch) {
+      const memStr = memMatch[1].trim();
+      const memNum = parseFloat(memStr);
+      if (memStr.includes('GB')) memory = memNum * 1024 * 1024 * 1024;
+      else if (memStr.includes('MB')) memory = memNum * 1024 * 1024;
+    }
 
-     let utilization = 0;
-     let temperature: number | undefined;
-     let gpuProcesses = 0;
+    let utilization = 0;
+    let temperature: number | undefined;
+    let gpuProcesses = 0;
 
-     if (detailed) {
-       try {
-         const pm = (await run('sudo -n powermetrics --samplers gpu_power -n 1 --format text 2>/dev/null', '')).trim();
-         const gpuPowerMatch = pm.match(/GPU Power:\s*([\d.]+)\s*mW/i);
-         if (gpuPowerMatch) {
-           utilization = Math.min(100, Math.round(parseFloat(gpuPowerMatch[1]) / 10));
-         }
-       } catch {
-         // ignore
-       }
+    if (detailed) {
+      try {
+        const pm = (await run('sudo -n powermetrics --samplers gpu_power -n 1 --format text 2>/dev/null', '')).trim();
+        const gpuPowerMatch = pm.match(/GPU Power:\s*([\d.]+)\s*mW/i);
+        if (gpuPowerMatch) {
+          utilization = Math.min(100, Math.round(parseFloat(gpuPowerMatch[1]) / 10));
+        }
+      } catch {
+        // ignore
+      }
 
-       try {
-         const { temps } = await getSmcMetrics();
-         if (temps.gpu_die !== undefined) temperature = temps.gpu_die;
-       } catch {
-         // ignore
-       }
+      try {
+        const { temps } = await getSmcMetrics();
+        if (temps.gpu_die !== undefined) temperature = temps.gpu_die;
+      } catch {
+        // ignore
+      }
 
-       try {
-         const psRaw = (await run('ps aux | grep -i "[g]pu" | wc -l')).trim();
-         gpuProcesses = parseInt(psRaw) || 0;
-       } catch {
-         // ignore
-       }
-     }
+      try {
+        const psRaw = (await run('ps aux | grep -i "[g]pu" | wc -l')).trim();
+        gpuProcesses = parseInt(psRaw) || 0;
+      } catch {
+        // ignore
+      }
+    }
 
-     return { model, memory, utilization, temperature, processes: gpuProcesses };
-   } catch {
-     return null;
-   }
- }
+    return { model, memory, utilization, temperature, processes: gpuProcesses };
+  }
 
 async function collectSystem(): Promise<{ hostname: string; os: string; uptime: string }> {
   const hostname = (await run('hostname', 'Mac')).trim();
@@ -244,28 +293,21 @@ async function collectSystem(): Promise<{ hostname: string; os: string; uptime:
 }
 
 export async function collectCpu(): Promise<CpuData> {
-  const brand = (await run('sysctl -n machdep.cpu.brand_string', 'Unknown CPU')).trim();
-  const cores = parseInt((await run('sysctl -n hw.ncpu')).trim()) || 1;
-  const physicalCores = parseInt((await run('sysctl -n hw.physicalcpu')).trim()) || cores;
-  const frequencyHz = parseInt((await run('sysctl -n hw.cpufrequency')).trim());
+  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 / 1_000_000) : 0;
 
   if (frequency === 0) {
-    // hw.cpufrequency is an Intel-era sysctl. On Apple Silicon it's either
-    // absent or reads back 0, so frequency was silently stuck at 0 MHz on
-    // every M-series Mac. powermetrics reports the actual active clock speed
-    // per core cluster (E/P-cluster) instead — reuse the same cached call
-    // already used for temperature/power rather than shelling out again.
     try {
       const { freq } = await getSmcMetrics();
       const values = Object.values(freq);
       if (values.length) {
-        // powermetrics reports in Hz, system profiler reports in MHz.
-        // We need MHz for the display.
         frequency = Math.round(Math.max(...values) / 1_000_000);
       }
     } catch {
-      // ignore — frequency stays 0, meaning "unavailable" rather than wrong
+      // ignore — frequency stays 0
     }
   }
 
@@ -300,8 +342,8 @@ export async function collectCpu(): Promise<CpuData> {
 }
 
 export async function collectMemory(): Promise<MemoryData> {
-  const totalBytes = parseInt((await run('sysctl -n hw.memsize')).trim()) || 0;
-  const pageSize = parseInt((await run('sysctl -n hw.pagesize', '4096')).trim()) || 4096;
+  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: string) => {
@@ -390,7 +432,14 @@ export async function collectBattery(): Promise<BatteryData | null> {
     let maxCapacityPercent: number | undefined;
 
     try {
-      const battInfo = (await run('system_profiler SPPowerDataType 2>/dev/null')).trim();
+      const now = Date.now();
+      let battInfo: string;
+      if (spBatteryCache && now - spBatteryCache.ts < SP_TTL_MS) {
+        battInfo = spBatteryCache.raw;
+      } else {
+        battInfo = (await run('system_profiler SPPowerDataType 2>/dev/null')).trim();
+        spBatteryCache = { raw: battInfo, ts: now };
+      }
 
       const cycleMatch = battInfo.match(/Cycle Count:\s+(\d+)/);
       if (cycleMatch) cycles = parseInt(cycleMatch[1]);
@@ -530,20 +579,8 @@ export async function collectThermal(detailed?: boolean): Promise<ThermalData> {
 
 export async function collectNetwork(): Promise<NetworkData> {
   try {
-    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 {
-      // ignore
-    }
-
-    const netStat = (await run('netstat -ib')).trim();
+    const { iface, ip } = await cachedRouteIface();
+    const netStat = await cachedNetstatIb();
     let rxBytes = 0;
     let txBytes = 0;
     let rxPackets = 0;
@@ -590,7 +627,7 @@ export async function collectProcesses(limit?: number): Promise<ProcessData[]> {
 
 export async function collectPackets(): Promise<PacketData | null> {
    try {
-     const netStat = (await run('netstat -ib')).trim();
+     const netStat = await cachedNetstatIb();
      const lines = netStat.split('\n').slice(1);
      let totalRxPackets = 0;
      let totalTxPackets = 0;
@@ -626,26 +663,18 @@ export async function collectPackets(): Promise<PacketData | null> {
 
      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', '')).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);
-
-        const allLsof = (await run('lsof -i -n -P 2>/dev/null | tail -n +2 | awk \'{print $1, $2}\' | sort | uniq -c | sort -rn', '')).trim();
-        const allLsofLines = allLsof.split('\n');
-        allProcesses = allLsofLines.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);
+       try {
+          const lsof = (await run('lsof -i -n -P 2>/dev/null | tail -n +2 | awk \'{print $1, $2}\' | sort | uniq -c | sort -rn', '')).trim();
+         const lsofLines = lsof.split('\n');
+         topProcesses = lsofLines.map(line => {
+           const parts = line.trim().split(/\s+/);
+           if (parts.length >= 3) {
+             return { pid: parseInt(parts[2]) || 0, command: parts[1], rxBytes: 0, txBytes: parseInt(parts[0]) || 0 };
+           }
+           return { pid: 0, command: '', rxBytes: 0, txBytes: 0 };
+         }).filter(p => p.pid > 0);
+
+         allProcesses = topProcesses;
      } catch {
        topProcesses = [];
        allProcesses = [];