pyre-cli 1.4.0 → 3.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pyre-cli",
-  "version": "1.4.0",
-  "description": "CLI Mac monitoring tool: temps, system stats, live dashboard, and export",
+  "version": "3.0.0",
+  "description": "CLI Mac monitoring tool: temps, system stats, live dashboard, packet monitor, battery predictor, export",
   "main": "dist/index.js",
   "type": "module",
   "bin": {

package/src/formatters/index.ts

@@ -11,7 +11,7 @@
  * - `render.ts` — dashboard layout, cards, tables, and the main `formatTable`
  * - `output.ts` — JSON/CSV/TSV export and sparkline graph rendering
  */
-export { formatTable, clampWidth, gridColumns, thermalColor, capacityColor } from './render.js';
+export { formatTable, clampWidth, gridColumns, thermalColor, capacityColor, getTabHitboxes, TAB_BAR_ROW, TAB_DEFS } from './render.js';
 export { formatJson, formatCsv, formatTsv, formatGraphs } from './output.js';
 export type { ThemeName, ThemeColors, VisibleItems, TableOptions } from './types.js';
 export { THEMES } from './themes.js';

package/src/formatters/output.ts

@@ -39,39 +39,58 @@ export function formatCsv(data: StatsData): string {
     ],
     ['network', 'rxBytes', String(data.network.rxBytes)],
     ['network', 'txBytes', String(data.network.txBytes)],
+    ['network', 'rxPackets', String(data.network.rxPackets)],
+    ['network', 'txPackets', String(data.network.txPackets)],
+    ['network', 'connections', data.network.connections ? String(data.network.connections) : ''],
     ['battery', 'level', data.battery ? String(data.battery.level) : ''],
     ['battery', 'powerSource', data.battery ? data.battery.powerSource : ''],
     ['battery', 'condition', data.battery?.condition ?? ''],
     ['battery', 'maxCapacityPercent', data.battery?.maxCapacityPercent !== undefined ? String(data.battery.maxCapacityPercent) : ''],
     ['battery', 'cycles', data.battery?.cycles !== undefined ? String(data.battery.cycles) : ''],
+    ['battery', 'estimatedTimeToEmpty', data.battery?.estimatedTimeToEmpty ?? ''],
+    ['battery', 'dischargeRatePerHour', data.battery?.dischargeRatePerHour !== undefined ? String(data.battery.dischargeRatePerHour) : ''],
+    ['battery', 'powerWatts', data.battery?.powerWatts !== undefined ? String(data.battery.powerWatts) : ''],
     ['power', 'cpuWatts', data.power?.cpuWatts !== undefined ? String(data.power.cpuWatts) : ''],
     ['power', 'gpuWatts', data.power?.gpuWatts !== undefined ? String(data.power.gpuWatts) : ''],
     ['power', 'combinedWatts', data.power?.combinedWatts !== undefined ? String(data.power.combinedWatts) : ''],
-['system', 'hostname', data.header.hostname],
+    ['system', 'hostname', data.header.hostname],
      ['system', 'uptime', data.header.uptime],
      ['system', 'timestamp', data.timestamp],
    ];
 
-   if (data.gpu) {
-     rows.push(['gpu', 'model', data.gpu.model]);
-     rows.push(['gpu', 'memory', String(data.gpu.memory)]);
-     rows.push(['gpu', 'utilization', String(data.gpu.utilization)]);
-     if (data.gpu.temperature) rows.push(['gpu', 'tempC', String(data.gpu.temperature)]);
-     rows.push(['gpu', 'processes', String(data.gpu.processes)]);
-   }
+  if (data.packets) {
+    rows.push(['packets', 'totalPackets', String(data.packets.totalPackets)]);
+    rows.push(['packets', 'rxPackets', String(data.packets.rxPackets)]);
+    rows.push(['packets', 'txPackets', String(data.packets.txPackets)]);
+    rows.push(['packets', 'connections', String(data.packets.connections)]);
+    for (const iface of data.packets.interfaces || []) {
+      rows.push(['packets_iface', iface.iface, `${iface.rxPackets},${iface.txPackets},${iface.rxBytes},${iface.txBytes}`]);
+    }
+    for (const proc of data.packets.allProcesses || []) {
+      rows.push(['packets_proc', `pid=${proc.pid}`, `${proc.command},${proc.rxBytes},${proc.txBytes}`]);
+    }
+  }
 
-   for (const p of data.processes) {
-    rows.push(['process', `pid=${p.pid}`, `${p.pid}`]);
-    rows.push(['process', `ppid=${p.pid}`, String(p.ppid)]);
-    rows.push(['process', `user=${p.pid}`, p.user]);
-    rows.push(['process', `cpu=${p.pid}`, String(p.cpu)]);
-    rows.push(['process', `mem=${p.pid}`, String(p.mem)]);
-    rows.push(['process', `state=${p.pid}`, p.state]);
-    rows.push(['process', `threads=${p.pid}`, String(p.threads)]);
-    rows.push(['process', `runtime=${p.pid}`, String(p.runtime)]);
-    rows.push(['process', `command=${p.pid}`, p.command]);
+  if (data.gpu) {
+    rows.push(['gpu', 'model', data.gpu.model]);
+    rows.push(['gpu', 'memory', String(data.gpu.memory)]);
+    rows.push(['gpu', 'utilization', String(data.gpu.utilization)]);
+    if (data.gpu.temperature) rows.push(['gpu', 'tempC', String(data.gpu.temperature)]);
+    rows.push(['gpu', 'processes', String(data.gpu.processes)]);
   }
-  return rows.map(r => r.map(item => `"${String(item).replace(/"/g, '""')}"`).join(',')).join('\n');
+
+  for (const p of data.processes) {
+   rows.push(['process', `pid=${p.pid}`, `${p.pid}`]);
+   rows.push(['process', `ppid=${p.pid}`, String(p.ppid)]);
+   rows.push(['process', `user=${p.pid}`, p.user]);
+   rows.push(['process', `cpu=${p.pid}`, String(p.cpu)]);
+   rows.push(['process', `mem=${p.pid}`, String(p.mem)]);
+   rows.push(['process', `state=${p.pid}`, p.state]);
+   rows.push(['process', `threads=${p.pid}`, String(p.threads)]);
+   rows.push(['process', `runtime=${p.pid}`, String(p.runtime)]);
+   rows.push(['process', `command=${p.pid}`, p.command]);
+ }
+ return rows.map(r => r.map(item => `"${String(item).replace(/"/g, '""')}"`).join(',')).join('\n');
 }
 
 export function formatTsv(data: StatsData): string {
@@ -92,6 +111,15 @@ export function formatGraphs(history: History, width = 80, themeName: ThemeName
   );
   lines.push(graphRow('Net RX/s', history.netRxRate, {}, v => `${formatBytes(v)}/s`, sparkWidth, graphMode));
   lines.push(graphRow('Net TX/s', history.netTxRate, {}, v => `${formatBytes(v)}/s`, sparkWidth, graphMode));
+  if (history.powerWatts.length) {
+    lines.push(graphRow('Power W', history.powerWatts, {}, v => `${v.toFixed(1)} W`, sparkWidth, graphMode));
+  }
+  if (history.rxPacketRate.length) {
+    lines.push(graphRow('RX pkt/s', history.rxPacketRate, {}, v => `${v.toFixed(0)} pkt/s`, sparkWidth, graphMode));
+  }
+  if (history.txPacketRate.length) {
+    lines.push(graphRow('TX pkt/s', history.txPacketRate, {}, v => `${v.toFixed(0)} pkt/s`, sparkWidth, graphMode));
+  }
 
   const title = `Graphs · mode:${graphMode} · last ${sampleCount} sample${sampleCount === 1 ? '' : 's'}`;
   return panel(title, lines, width, theme.graphs, theme.border).join('\n');

package/src/formatters/render.ts

@@ -163,14 +163,18 @@ function gpuCard(data: StatsData, contentWidth: number): string[] | null {
    return lines;
  }
 
- function powerCard(data: StatsData): string[] | null {
-  if (!data.power) return null;
-  const lines: string[] = [];
-  if (data.power.cpuWatts !== undefined) lines.push(statRow('CPU', `${data.power.cpuWatts.toFixed(2)} W`));
-  if (data.power.gpuWatts !== undefined) lines.push(statRow('GPU', `${data.power.gpuWatts.toFixed(2)} W`));
-  if (data.power.combinedWatts !== undefined) lines.push(statRow('Total', `${data.power.combinedWatts.toFixed(2)} W`));
-  return lines.length ? lines : null;
-}
+  function powerCard(data: StatsData): string[] | null {
+   const lines: string[] = [];
+   if (data.power) {
+     if (data.power.cpuWatts !== undefined) lines.push(statRow('CPU', `${data.power.cpuWatts.toFixed(2)} W`));
+     if (data.power.gpuWatts !== undefined) lines.push(statRow('GPU', `${data.power.gpuWatts.toFixed(2)} W`));
+     if (data.power.combinedWatts !== undefined) lines.push(statRow('Total', `${data.power.combinedWatts.toFixed(2)} W`));
+   }
+   if (data.battery?.powerWatts !== undefined && data.battery.powerWatts > 0) {
+     lines.push(statRow('Battery', `${data.battery.powerWatts.toFixed(2)} W`));
+   }
+   return lines.length ? lines : null;
+ }
 
 function batteryCard(data: StatsData, contentWidth: number): string[] | null {
   if (!data.battery) return null;
@@ -185,6 +189,12 @@ function batteryCard(data: StatsData, contentWidth: number): string[] | null {
     lines.push(statRow('Capacity', capacityColor(data.battery.maxCapacityPercent)(`${data.battery.maxCapacityPercent}%`)));
   }
   lines.push(statRow('Source', data.battery.powerSource));
+  if (data.battery.estimatedTimeToEmpty && data.battery.state !== 'charged') {
+    lines.push(statRow('Est. Empty', data.battery.estimatedTimeToEmpty));
+  }
+  if (data.battery.dischargeRatePerHour !== undefined && data.battery.state !== 'charged') {
+    lines.push(statRow('Disch. Rate', `${data.battery.dischargeRatePerHour}%/h`));
+  }
   return lines;
 }
 
@@ -209,7 +219,36 @@ function networkCard(data: StatsData, contentWidth: number): string[] {
   ];
 }
 
-// --- header ------------------------------------------------------------------
+function packetCard(data: StatsData, contentWidth: number): string[] | null {
+  if (!data.packets) return null;
+  const lines: string[] = [];
+  lines.push(statRow('Total', `${data.packets.totalPackets} pkt`));
+  lines.push(statRow('RX', `${data.packets.rxPackets} pkt`));
+  lines.push(statRow('TX', `${data.packets.txPackets} pkt`));
+  lines.push(statRow('Conns', `${data.packets.connections} TCP`));
+  if (data.packets.topProcesses && data.packets.topProcesses.length) {
+    lines.push(statRow('Top Proc', truncatePlain(data.packets.topProcesses[0].command, contentWidth - 10)));
+  }
+  if (data.packets.allProcesses && data.packets.allProcesses.length > 1) {
+    lines.push(statRow('Net Procs', `${data.packets.allProcesses.length} processes`));
+  }
+  if (data.packets.interfaces && data.packets.interfaces.length) {
+    lines.push(statRow('Ifaces', `${data.packets.interfaces.length} active`));
+  }
+  return lines;
+}
+
+function tasksCard(data: StatsData, contentWidth: number): string[] | null {
+  if (!data.tasks || !data.tasks.length) return null;
+  const lines: string[] = [];
+  for (const task of data.tasks.slice(0, 6)) {
+    const cmd = truncatePlain(task.command, Math.max(4, contentWidth - 28));
+    lines.push(statRow(`${task.pid}`, `${task.user.padEnd(8)} ${task.cpu.toFixed(1).padStart(5)}% ${task.mem.toFixed(1).padStart(5)}% ${task.state} ${cmd}`));
+  }
+  return lines;
+}
+
+// --- header / tabs -----------------------------------------------------------
 
 function header(data: StatsData, width: number, badges: string[] = [], borderAccent = THEMES.default.border): string[] {
   const now = new Date().toLocaleTimeString();
@@ -220,6 +259,68 @@ function header(data: StatsData, width: number, badges: string[] = [], borderAcc
   return [line, borderAccent('─'.repeat(width))];
 }
 
+/**
+ * Canonical tab list shared between the renderer (drawing the tab bar)
+ * and the live dashboard's mouse handler (hit-testing clicks against it).
+ * Keeping a single source of truth here avoids the two drifting apart.
+ */
+export const TAB_DEFS: { id: string; label: string; key: string }[] = [
+  { id: 'cpu', label: 'CPU', key: '1' },
+  { id: 'mem', label: 'Memory', key: '2' },
+  { id: 'gpu', label: 'GPU', key: '3' },
+  { id: 'power', label: 'Power', key: '4' },
+  { id: 'battery', label: 'Battery', key: '5' },
+  { id: 'thermal', label: 'Thermal', key: '6' },
+  { id: 'network', label: 'Network', key: '7' },
+  { id: 'packets', label: 'Packets', key: '8' },
+  { id: 'tasks', label: 'Tasks', key: '9' },
+  { id: 'disk', label: 'Disk', key: '0' },
+  { id: 'process', label: 'Process', key: 'p' },
+];
+
+/** The number of leading columns of indent before the tab bar's first character (see `tabBar`). */
+const TAB_BAR_INDENT = 2;
+/** Visible width of the ' │ ' separator drawn between tabs. */
+const TAB_SEPARATOR_WIDTH = 3;
+
+/**
+ * Compute the column range (inclusive start, exclusive end) each tab
+ * occupies when rendered by `tabBar`, so a click at a given column can be
+ * mapped back to a panel id. Row is always the same line the tab bar is
+ * printed on (see `formatTable`: header takes 2 lines, then a blank line,
+ * then the tab bar — i.e. row 4 in a 1-indexed terminal, row index 3 if
+ * 0-indexed from the top of the dashboard).
+ */
+export function getTabHitboxes(): { id: string; start: number; end: number }[] {
+  const boxes: { id: string; start: number; end: number }[] = [];
+  let col = TAB_BAR_INDENT;
+  TAB_DEFS.forEach((t, i) => {
+    const text = `[${t.key}]${t.label}`;
+    const start = col;
+    const end = col + text.length;
+    boxes.push({ id: t.id, start, end });
+    col = end;
+    if (i < TAB_DEFS.length - 1) col += TAB_SEPARATOR_WIDTH;
+  });
+  return boxes;
+}
+
+/** Row (1-indexed, matching terminal mouse-report coordinates) the tab bar renders on. */
+export const TAB_BAR_ROW = 4;
+
+function tabBar(activePanel: string, width: number, theme: ThemeColors): string {
+  const rendered = TAB_DEFS.map(t => {
+    const isActive = activePanel === t.id;
+    const label = isActive ? chalk.bold(t.label) : chalk.dim(t.label);
+    const keyHint = chalk.dim(`[${t.key}]`);
+    return `${keyHint}${label}`;
+  });
+
+  const joined = rendered.join(chalk.dim(' │ '));
+  const padded = visLen(joined) < width ? joined + ' '.repeat(width - visLen(joined)) : joined;
+  return chalk.dim('  ') + padded;
+}
+
 // --- process / disk tables ---------------------------------------------------
 
 function sortProcesses(
@@ -359,15 +460,87 @@ function diskTableLines(
 
 // --- main dashboard ------------------------------------------------------------
 
-/**
- * Render the full static dashboard as a single string.
- *
- * Cards are arranged in rows of {@link gridColumns} columns,
- * and the process table is appended below.  Visibility of
- * individual panels is controlled via {@link TableOptions.visible}.
- */
+function detailPanelTitle(panel: string): string {
+  const map: Record<string, string> = {
+    cpu: 'CPU',
+    mem: 'Memory',
+    gpu: 'GPU',
+    power: 'Power',
+    battery: 'Battery',
+    thermal: 'Thermal',
+    network: 'Network',
+    packets: 'Packets',
+    tasks: 'Tasks',
+    disk: 'Disk',
+    process: 'Processes',
+  };
+  return map[panel] || panel;
+}
+
+function activeDetailLines(data: StatsData, activePanel: string, width: number): string[] | null {
+  const contentWidth = width - 4;
+  switch (activePanel) {
+    case 'cpu':
+      return cpuCard(data, contentWidth);
+    case 'mem':
+      return memCard(data, contentWidth);
+    case 'gpu': {
+      const gpu = gpuCard(data, contentWidth);
+      return gpu ?? ['No GPU data available'];
+    }
+    case 'power': {
+      const power = powerCard(data);
+      if (!power && !data.battery) return ['No power data available'];
+      const lines: string[] = [];
+      if (power) lines.push(...power);
+      if (data.battery?.powerWatts !== undefined && data.battery.powerWatts > 0) {
+        lines.push(statRow('Battery', `${data.battery.powerWatts.toFixed(2)} W`));
+      }
+      return lines.length ? lines : ['No power data available'];
+    }
+    case 'battery':
+      return data.battery ? batteryCard(data, contentWidth) : ['No battery data available'];
+    case 'thermal':
+      return thermalCard(data, contentWidth);
+    case 'network':
+      return networkCard(data, contentWidth);
+    case 'packets': {
+      if (!data.packets) return ['No packet data available'];
+      const lines: string[] = [];
+      lines.push(statRow('Total', `${data.packets.totalPackets} pkt`));
+      lines.push(statRow('RX', `${data.packets.rxPackets} pkt`));
+      lines.push(statRow('TX', `${data.packets.txPackets} pkt`));
+      lines.push(statRow('Conns', `${data.packets.connections} TCP`));
+      if (data.packets.interfaces && data.packets.interfaces.length) {
+        lines.push(statRow('Ifaces', `${data.packets.interfaces.length} active`));
+        for (const iface of data.packets.interfaces.slice(0, 8)) {
+          lines.push(statRow(`  ${iface.iface}`, `RX ${formatBytes(iface.rxBytes)} / TX ${formatBytes(iface.txBytes)}`));
+        }
+      }
+      if (data.packets.allProcesses && data.packets.allProcesses.length) {
+        lines.push(statRow('Net Procs', `${data.packets.allProcesses.length} total`));
+        for (const proc of data.packets.allProcesses.slice(0, 10)) {
+          lines.push(statRow(`  ${proc.pid}`, `${truncatePlain(proc.command, 20)}  TX ${formatBytes(proc.txBytes)}`));
+        }
+      }
+      return lines;
+    }
+    case 'tasks':
+      return data.tasks?.length ? tasksCard(data, contentWidth) : ['No task data available'];
+    case 'disk':
+      return data.disk.length ? diskTableLines(data.disk, width - 4, THEMES.default.border) : ['No disk data available'];
+    case 'process': {
+      const sorted = sortProcesses([...data.processes], 'cpu');
+      return processTableLines(sorted.slice(0, 50), width - 4, THEMES.default.border);
+    }
+    default:
+      return null;
+  }
+}
+
 export function formatTable(data: StatsData, opts: TableOptions = {}): string {
   const width = clampWidth(opts.width);
+  const activePanel = opts.activePanel || 'grid';
   const columns = gridColumns(width);
   const gap = 2;
   const cardWidth = Math.floor((width - gap * (columns - 1)) / columns);
@@ -380,6 +553,16 @@ export function formatTable(data: StatsData, opts: TableOptions = {}): string {
   const out: string[] = [];
   out.push(...header(data, width, [], theme.border));
   out.push('');
+  out.push(tabBar(activePanel, width, theme));
+  out.push('');
+
+  if (activePanel !== 'grid') {
+    const lines = activeDetailLines(data, activePanel, width);
+    if (lines) {
+      out.push(...panel(detailPanelTitle(activePanel), lines, width, theme[activePanel as keyof ThemeColors] ?? theme.cpu, theme.border));
+    }
+    return out.join('\n');
+  }
 
   type Card = { title: string; accent: (s: string) => string; lines: string[] };
   const cards: Card[] = [];
@@ -408,6 +591,14 @@ export function formatTable(data: StatsData, opts: TableOptions = {}): string {
   if (vis.network !== false) {
     cards.push({ title: 'Network', accent: theme.network, lines: networkCard(data, contentWidth) });
   }
+  if (vis.packets !== false) {
+    const packets = packetCard(data, contentWidth);
+    if (packets) cards.push({ title: 'Packets', accent: theme.network, lines: packets });
+  }
+  if (vis.tasks !== false) {
+    const tasks = tasksCard(data, contentWidth);
+    if (tasks) cards.push({ title: 'Tasks', accent: theme.process, lines: tasks });
+  }
 
   for (let i = 0; i < cards.length; i += columns) {
     const row = cards.slice(i, i + columns);

package/src/formatters/types.ts

@@ -35,6 +35,8 @@ export interface VisibleItems {
    battery?: boolean;
    thermal?: boolean;
    network?: boolean;
+   packets?: boolean;
+   tasks?: boolean;
    disk?: boolean;
    process?: boolean;
    tree?: boolean;
@@ -55,4 +57,6 @@ export interface TableOptions {
    visible?: VisibleItems;
    /** Show process tree view instead of flat list. */
    treeView?: boolean;
+   /** Active panel for detail/focus view. 'grid' means show all panels. */
+   activePanel?: 'grid' | 'cpu' | 'mem' | 'gpu' | 'power' | 'battery' | 'thermal' | 'network' | 'packets' | 'tasks' | 'disk' | 'process';
 }

package/src/history.ts

@@ -34,8 +34,22 @@ export class History {
    /** Rolling window of GPU utilization percentages (0–100). */
    gpuUtil: number[] = [];
 
+   /** Rolling window of combined power draw in watts. */
+   powerWatts: number[] = [];
+
+   /** Rolling window of network receive packet rates in packets/sec. */
+   rxPacketRate: number[] = [];
+
+   /** Rolling window of network transmit packet rates in packets/sec. */
+   txPacketRate: number[] = [];
+
+   /** Rolling window of active TCP connections. */
+   connections: number[] = [];
+
    private lastRxBytes = 0;
    private lastTxBytes = 0;
+   private lastRxPackets = 0;
+   private lastTxPackets = 0;
    private lastTs = 0;
 
   /**
@@ -54,59 +68,83 @@ export class History {
    * because there is no prior sample to compute a delta from.
    */
    push(sample: {
-     cpuUsage: number;
-     memUsage: number;
-     temp: number | null;
-     rxBytes: number;
-     txBytes: number;
-     gpuUtil?: number;
-   }) {
-     const now = Date.now();
-     let rxRate = 0;
-     let txRate = 0;
-
-     if (this.lastTs > 0) {
-       const dtSeconds = Math.max((now - this.lastTs) / 1000, 0.001);
-       rxRate = Math.max(0, (sample.rxBytes - this.lastRxBytes) / dtSeconds);
-       txRate = Math.max(0, (sample.txBytes - this.lastTxBytes) / dtSeconds);
-     }
-
-     this.lastRxBytes = sample.rxBytes;
-     this.lastTxBytes = sample.txBytes;
-     this.lastTs = now;
-
-     this.pushBounded(this.cpuUsage, sample.cpuUsage);
-     this.pushBounded(this.memUsage, sample.memUsage);
-     if (sample.temp !== null) this.pushBounded(this.temp, sample.temp);
-     this.pushBounded(this.netRxRate, rxRate);
-     this.pushBounded(this.netTxRate, txRate);
-     if (sample.gpuUtil !== undefined) this.pushBounded(this.gpuUtil, sample.gpuUtil);
-   }
-
-   /** Clear all rolling windows and reset cumulative byte counters. */
-   reset() {
-     this.cpuUsage = [];
-     this.memUsage = [];
-     this.temp = [];
-     this.netRxRate = [];
-     this.netTxRate = [];
-     this.gpuUtil = [];
-     this.lastRxBytes = 0;
-     this.lastTxBytes = 0;
-     this.lastTs = 0;
-   }
+      cpuUsage: number;
+      memUsage: number;
+      temp: number | null;
+      rxBytes: number;
+      txBytes: number;
+      gpuUtil?: number;
+      powerWatts?: number;
+      rxPackets?: number;
+      txPackets?: number;
+      connections?: number;
+    }) {
+      const now = Date.now();
+      let rxRate = 0;
+      let txRate = 0;
+      let rxPktRate = 0;
+      let txPktRate = 0;
+
+      if (this.lastTs > 0) {
+        const dtSeconds = Math.max((now - this.lastTs) / 1000, 0.001);
+        rxRate = Math.max(0, (sample.rxBytes - this.lastRxBytes) / dtSeconds);
+        txRate = Math.max(0, (sample.txBytes - this.lastTxBytes) / dtSeconds);
+        if (sample.rxPackets !== undefined) {
+          rxPktRate = Math.max(0, (sample.rxPackets - this.lastRxPackets) / dtSeconds);
+        }
+        if (sample.txPackets !== undefined) {
+          txPktRate = Math.max(0, (sample.txPackets - this.lastTxPackets) / dtSeconds);
+        }
+      }
+
+      this.lastRxBytes = sample.rxBytes;
+      this.lastTxBytes = sample.txBytes;
+      if (sample.rxPackets !== undefined) this.lastRxPackets = sample.rxPackets;
+      if (sample.txPackets !== undefined) this.lastTxPackets = sample.txPackets;
+      this.lastTs = now;
+
+      this.pushBounded(this.cpuUsage, sample.cpuUsage);
+      this.pushBounded(this.memUsage, sample.memUsage);
+      if (sample.temp !== null) this.pushBounded(this.temp, sample.temp);
+      this.pushBounded(this.netRxRate, rxRate);
+      this.pushBounded(this.netTxRate, txRate);
+      if (sample.gpuUtil !== undefined) this.pushBounded(this.gpuUtil, sample.gpuUtil);
+      if (sample.powerWatts !== undefined) this.pushBounded(this.powerWatts, sample.powerWatts);
+      if (sample.rxPackets !== undefined) this.pushBounded(this.rxPacketRate, rxPktRate);
+      if (sample.txPackets !== undefined) this.pushBounded(this.txPacketRate, txPktRate);
+      if (sample.connections !== undefined) this.pushBounded(this.connections, sample.connections);
+    }
+
+    /** Clear all rolling windows and reset cumulative byte counters. */
+    reset() {
+      this.cpuUsage = [];
+      this.memUsage = [];
+      this.temp = [];
+      this.netRxRate = [];
+      this.netTxRate = [];
+      this.gpuUtil = [];
+      this.powerWatts = [];
+      this.rxPacketRate = [];
+      this.txPacketRate = [];
+      this.connections = [];
+      this.lastRxBytes = 0;
+      this.lastTxBytes = 0;
+      this.lastRxPackets = 0;
+      this.lastTxPackets = 0;
+      this.lastTs = 0;
+    }
 
    /**
     * Grow or shrink the rolling window (e.g. on terminal resize),
     * trimming from the oldest samples.
     * @param n - New maximum length; clamped to at least 1.
     */
-   setMaxLen(n: number) {
-     this.maxLen = Math.max(1, n);
-     for (const arr of [this.cpuUsage, this.memUsage, this.temp, this.netRxRate, this.netTxRate, this.gpuUtil]) {
-       while (arr.length > this.maxLen) arr.shift();
-     }
-   }
+    setMaxLen(n: number) {
+      this.maxLen = Math.max(1, n);
+      for (const arr of [this.cpuUsage, this.memUsage, this.temp, this.netRxRate, this.netTxRate, this.gpuUtil, this.powerWatts, this.rxPacketRate, this.txPacketRate, this.connections]) {
+        while (arr.length > this.maxLen) arr.shift();
+      }
+    }
 
   private pushBounded(arr: number[], v: number) {
     arr.push(v);