pyre-cli 1.3.0 → 1.4.0

package/src/history.ts

@@ -0,0 +1,115 @@
+/**
+ * Rolling window of recent metric samples, used to render
+ * sparkline graphs in the live dashboard.
+ *
+ * Network rates (bytes/sec) are derived from the cumulative
+ * counters returned by the monitors module by computing the
+ * delta between consecutive samples.
+ *
+ * @example
+ * ```ts
+ * const h = new History(60);
+ * h.push({ cpuUsage: 42, memUsage: 55, temp: 62, rxBytes: 1024, txBytes: 512 });
+ * ```
+ */
+export class History {
+  /** Maximum number of samples retained in the rolling window. */
+  maxLen: number;
+
+  /** Rolling window of CPU usage percentages (0–100). */
+  cpuUsage: number[] = [];
+
+  /** Rolling window of memory usage percentages (0–100). */
+  memUsage: number[] = [];
+
+  /** Rolling window of CPU die temperatures in °C. */
+  temp: number[] = [];
+
+  /** Rolling window of network receive rates in bytes/sec. */
+  netRxRate: number[] = [];
+
+  /** Rolling window of network transmit rates in bytes/sec. */
+  netTxRate: number[] = [];
+
+   /** Rolling window of GPU utilization percentages (0–100). */
+   gpuUtil: number[] = [];
+
+   private lastRxBytes = 0;
+   private lastTxBytes = 0;
+   private lastTs = 0;
+
+  /**
+   * Create a new History instance.
+   * @param maxLen - Maximum number of samples to retain. Defaults to 40.
+   */
+  constructor(maxLen = 40) {
+    this.maxLen = maxLen;
+  }
+
+  /**
+   * Push a new sample into the rolling window.
+   *
+   * Network rates are computed as bytes/sec from the cumulative
+   * counters.  The first sample always reports 0 for rates
+   * 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;
+   }
+
+   /**
+    * 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();
+     }
+   }
+
+  private pushBounded(arr: number[], v: number) {
+    arr.push(v);
+    if (arr.length > this.maxLen) arr.shift();
+  }
+}

package/src/index.ts

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+/**
+ * pyre - Mac system monitoring CLI
+ * Monitors temps, cpu, memory, disk, battery, and system stats.
+ * Live mode is a full interactive dashboard: graphs, pause/resume,
+ * on-demand snapshot export, and continuous CSV logging.
+ */
+import fs from 'node:fs';
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { collectAll } from './monitors/index.js';
+import { formatTable, formatJson, formatCsv, formatTsv } from './formatters/index.js';
+import { startLive, stopLive } from './live/index.js';
+import { showSplash } from './splash.js';
+
+const program = new Command();
+
+program
+   .name('pyre')
+   .version('2.0.0')
+   .description('Mac system monitoring CLI: interactive live dashboard, stats, graphs, export')
+   .option('-j, --json', 'Output as JSON')
+   .option('-c, --csv', 'Output as CSV')
+   .option('-t, --tsv', 'Output as TSV')
+   .option('--detailed', 'Include detailed system info and sensor readings')
+   .option('--interval <seconds>', 'Refresh interval for live mode', '2')
+   .option('--once', 'Show a single static snapshot instead of live feed')
+   .option('--out <file>', 'Also write the snapshot output to a file (--once/--json/--csv/--tsv modes)')
+   .option('--export-dir <dir>', 'Directory used for live-mode snapshot exports and logs', './pyre-exports')
+   .option('--log', 'Start continuous CSV logging immediately when live mode starts')
+   .option('--tree', 'Show process tree view instead of flat list')
+   .option('--sort <key>', 'Sort processes by: cpu, mem, pid, user, command, state, threads, runtime', 'cpu');
+
+program.parse(process.argv);
+
+const opts = program.opts();
+
+function isExportMode() {
+  return opts.json || opts.csv || opts.tsv;
+}
+
+function stripAnsi(s: string): string {
+  // eslint-disable-next-line no-control-regex
+  return s.replace(/\x1b\[[0-9;]*m/g, '');
+}
+
+async function main() {
+  const requestedLive = program.args[0] === 'live' || (!isExportMode() && !opts.once);
+  if (requestedLive) {
+    await showSplash();
+    const interval = parseFloat(opts.interval) || 2;
+    await startLive({
+      interval,
+      detailed: opts.detailed,
+      exportDir: opts.exportDir,
+      autoLog: opts.log,
+    });
+    return;
+  }
+
+  const data = await collectAll({ detailed: opts.detailed });
+
+  let output: string;
+  if (opts.json) output = formatJson(data);
+  else if (opts.csv) output = formatCsv(data);
+  else if (opts.tsv) output = formatTsv(data);
+  else output = formatTable(data, { width: process.stdout.columns || 80, sortBy: opts.sort, treeView: opts.tree });
+
+  console.log(output);
+
+  if (opts.out) {
+    fs.writeFileSync(opts.out, stripAnsi(output));
+    console.log(chalk.dim(`\nSaved to ${opts.out}`));
+  }
+}
+
+main().catch((err) => {
+  console.error(chalk.red(`Error: ${err.message}`));
+  stopLive();
+  process.exit(1);
+});

package/src/live/export.ts

@@ -0,0 +1,73 @@
+/**
+ * Live dashboard export and logging helpers.
+ *
+ * Handles snapshot export (JSON/CSV/TSV), continuous
+ * CSV logging, and the supporting file-system utilities.
+ * All state variables are imported from `state.ts`.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { formatJson, formatCsv, formatTsv } from '../formatters/index.js';
+import { state, setStatus } from './state.js';
+
+/** Ensure a directory exists, creating it recursively if needed. */
+function ensureDir(dir: string) {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+/** Generate a filesystem-safe timestamp string for export filenames. */
+function timestampForFile(): string {
+  return new Date().toISOString().replace(/[:.]/g, '-');
+}
+
+function exportSnapshot() {
+  if (!state.lastData) {
+    setStatus('No data yet — try again in a moment');
+    return;
+  }
+  try {
+    ensureDir(state.exportDir);
+    const file = path.join(state.exportDir, `pyre-${timestampForFile()}.${state.exportFormat}`);
+    const content =
+      state.exportFormat === 'json' ? formatJson(state.lastData) : state.exportFormat === 'csv' ? formatCsv(state.lastData) : formatTsv(state.lastData);
+    fs.writeFileSync(file, content);
+    setStatus(`Exported snapshot -> ${file}`);
+  } catch (err: any) {
+    setStatus(`Export failed: ${err.message}`);
+  }
+}
+
+function startLogging() {
+  try {
+    ensureDir(state.exportDir);
+    const file = path.join(state.exportDir, `pyre-log-${timestampForFile()}.csv`);
+    state.logStream = fs.createWriteStream(file, { flags: 'a' });
+    state.logStream.write('timestamp,cpu_usage,mem_usage_percent,temp_c,net_rx_bytes,net_tx_bytes,thermal_state\n');
+    state.logging = true;
+    setStatus(`Logging every tick -> ${file}`);
+  } catch (err: any) {
+    setStatus(`Logging failed to start: ${err.message}`);
+  }
+}
+
+function stopLogging() {
+  state.logging = false;
+  state.logStream?.end();
+  state.logStream = null;
+  setStatus('Logging stopped');
+}
+
+function toggleLogging() {
+  if (state.logging) stopLogging();
+  else startLogging();
+}
+
+function writeLogRow(data: any) {
+  if (!state.logging || !state.logStream) return;
+  const temp = data.cpu.temperature ?? data.thermal.temperatures?.cpu_die ?? '';
+  state.logStream.write(
+    `${data.timestamp},${data.cpu.usage},${data.memory.usagePercent},${temp},${data.network.rxBytes},${data.network.txBytes},${data.thermal.state}\n`
+  );
+}
+
+export { ensureDir, timestampForFile, exportSnapshot, startLogging, stopLogging, toggleLogging, writeLogRow };

package/src/live/index.ts

@@ -0,0 +1,16 @@
+/**
+ * pyre live dashboard module.
+ *
+ * Provides the interactive live monitoring mode with
+ * keyboard-driven customization, process filtering,
+ * snapshot export, and continuous CSV logging.
+ *
+ * The module is organised into five sub-files:
+ * - `types.ts`   — type definitions
+ * - `state.ts`   — shared mutable session state
+ * - `render.ts`  — screen rendering and alert checking
+ * - `input.ts`   — keypress handling and session lifecycle
+ * - `export.ts`  — snapshot export and CSV logging
+ */
+export { startLive, stopLive } from './input.js';
+export type { LiveOptions } from './types.js';

package/src/live/input.ts

@@ -0,0 +1,311 @@
+/**
+ * Live dashboard input handling and session lifecycle.
+ *
+ * Contains `startLive`, `stopLive`, the keypress handler,
+ * resize handling, and the ticker restart logic.
+ *
+ * Imported by `index.ts` as the public API of the live module.
+ */
+import readline from 'node:readline';
+import chalk from 'chalk';
+import { collectAll, StatsData } from '../monitors/index.js';
+import { THEMES, type ThemeName, type VisibleItems } from '../formatters/index.js';
+import { state, setStatus } from './state.js';
+import { exportSnapshot, startLogging, stopLogging, toggleLogging, writeLogRow } from './export.js';
+import { render, footerLine, checkAlerts, processRowBudget } from './render.js';
+import type { LiveOptions, ExportFormat, InputMode, SortMode, GraphMode } from './types.js';
+
+function handleInputModeKey(str: string, key: readline.Key) {
+   if (key.name === 'escape') {
+     state.inputMode = null;
+     state.inputBuffer = '';
+     render();
+     return;
+   }
+
+   if (state.inputMode === 'customizer') {
+     const themesList = Object.keys(THEMES) as ThemeName[];
+
+     if (key.name === 'up' || str === 'k') {
+       state.customizerIndex = (state.customizerIndex - 1 + state.CUSTOMIZER_OPTIONS.length) % state.CUSTOMIZER_OPTIONS.length;
+     } else if (key.name === 'down' || str === 'j') {
+       state.customizerIndex = (state.customizerIndex + 1) % state.CUSTOMIZER_OPTIONS.length;
+     } else if (key.name === 'return' || str === ' ') {
+       const selected = state.CUSTOMIZER_OPTIONS[state.customizerIndex];
+       if (selected === 'Theme') {
+         const nextIdx = (themesList.indexOf(state.currentTheme) + 1) % themesList.length;
+         state.currentTheme = themesList[nextIdx];
+        } else if (selected === 'Toggle Tree View') {
+          state.treeView = !state.treeView;
+        } else if (selected === 'Graph Mode') {
+          state.graphMode = state.graphMode === 'spark' ? 'bar' : 'spark';
+        } else {
+
+         const itemKey = selected.replace('Toggle ', '').toLowerCase() as keyof VisibleItems;
+         state.visiblePanels[itemKey] = !state.visiblePanels[itemKey];
+       }
+     }
+     render();
+     return;
+   }
+
+    if (state.inputMode === 'signal') {
+      if (key.name === 'up' || str === 'k') {
+       const idx = state.SIGNAL_OPTIONS.indexOf(state.inputBuffer as typeof state.SIGNAL_OPTIONS[number]);
+       state.inputBuffer = state.SIGNAL_OPTIONS[(idx - 1 + state.SIGNAL_OPTIONS.length) % state.SIGNAL_OPTIONS.length];
+      } else if (key.name === 'down' || str === 'j') {
+       const idx = state.SIGNAL_OPTIONS.indexOf(state.inputBuffer as typeof state.SIGNAL_OPTIONS[number]);
+       state.inputBuffer = state.SIGNAL_OPTIONS[(idx + 1) % state.SIGNAL_OPTIONS.length];
+      } else if (key.name === 'return' || str === ' ') {
+        killProcess(state.inputBuffer.trim(), state.inputBuffer.trim() as NodeJS.Signals);
+        state.inputMode = null;
+        state.inputBuffer = '';
+        render();
+        return;
+      }
+      render();
+      return;
+    }
+
+   if (key.name === 'return') {
+     if (state.inputMode === 'filter') {
+       state.processFilter = state.inputBuffer.trim();
+       setStatus(state.processFilter ? `Filtering: "${state.processFilter}"` : 'Filter cleared');
+     } else if (state.inputMode === 'kill') {
+       killProcess(state.inputBuffer.trim());
+     }
+     state.inputMode = null;
+     state.inputBuffer = '';
+     render();
+     return;
+   }
+
+   if (key.name === 'backspace') {
+     state.inputBuffer = state.inputBuffer.slice(0, -1);
+     render();
+     return;
+   }
+
+   if (str && str.length === 1 && !key.ctrl && !key.meta) {
+     state.inputBuffer += str;
+     render();
+   }
+ }
+
+function killProcess(pidStr: string, signal: string = 'SIGTERM') {
+   const pid = parseInt(pidStr, 10);
+   if (!pid || pid <= 0) {
+     setStatus(`Invalid PID: ${pidStr}`);
+     return;
+   }
+   try {
+     process.kill(pid, signal as NodeJS.Signals);
+     setStatus(`Sent ${signal} to PID ${pid}`);
+   } catch (err: any) {
+     setStatus(`Failed to send ${signal} to ${pid}: ${err.message}`);
+   }
+  }
+
+  function onResize() {
+   state.termWidth = process.stdout.columns || 80;
+   state.termHeight = process.stdout.rows || 24;
+   state.history.setMaxLen(Math.max(20, Math.min(200, state.termWidth - 30)));
+   render();
+ }
+
+ function restartTicker() {
+   if (state.intervalHandle) clearInterval(state.intervalHandle);
+   state.intervalHandle = setInterval(tick, state.interval * 1000);
+ }
+
+ async function tick() {
+   if (state.paused) return;
+   try {
+     const data = await collectAll({ detailed: state.detailed, processLimit: processRowBudget() });
+     state.lastData = data;
+
+     const temp = data.cpu.temperature ?? data.thermal.temperatures?.cpu_die ?? null;
+     state.history.push({
+       cpuUsage: data.cpu.usage,
+       memUsage: data.memory.usagePercent,
+       temp,
+       rxBytes: data.network.rxBytes,
+       txBytes: data.network.txBytes,
+       gpuUtil: data.gpu?.utilization,
+     });
+
+     writeLogRow(data);
+     checkAlerts(data);
+     render();
+   } catch {
+     // skip bad tick
+   }
+ }
+
+ /**
+  * Start the interactive live dashboard.
+  *
+  * Sets up raw TTY mode, keypress listeners, and the
+  * rendering interval.  Idempotent — calling while already
+  * running is a no-op.
+  */
+ export async function startLive(opts: LiveOptions) {
+   if (state.running) return;
+   state.running = true;
+   state.paused = false;
+   state.detailed = !!opts.detailed;
+   state.interval = opts.interval;
+   if (opts.exportDir) state.exportDir = opts.exportDir;
+   state.termWidth = process.stdout.columns || 80;
+   state.termHeight = process.stdout.rows || 24;
+   state.history.reset();
+   state.history.setMaxLen(Math.max(20, Math.min(200, state.termWidth - 30)));
+
+   process.stdout.write('\x1b[?1049h');
+   process.stdout.write('\x1b[?25l');
+   process.stdout.write('\x1b[2J\x1b[H');
+   process.title = 'pyre';
+
+   await tick();
+   restartTicker();
+
+   if (opts.autoLog) startLogging();
+
+   readline.emitKeypressEvents(process.stdin);
+   if (process.stdin.isTTY) process.stdin.setRawMode(true);
+   process.stdin.resume();
+
+   process.stdout.on('resize', onResize);
+
+   state.keypressHandler = (str: string, key: readline.Key) => {
+     if (!key) return;
+
+     if (key.ctrl && key.name === 'c') {
+       stopLive();
+       return;
+     }
+
+     if (state.inputMode) {
+       handleInputModeKey(str, key);
+       return;
+     }
+
+     switch (key.sequence) {
+       case '+':
+         state.interval += 1;
+         restartTicker();
+         setStatus(`Interval set to ${state.interval}s`);
+         return;
+       case '-':
+         state.interval = Math.max(1, state.interval - 1);
+         restartTicker();
+         setStatus(`Interval set to ${state.interval}s`);
+         return;
+       case '/':
+         state.inputMode = 'filter';
+         state.inputBuffer = state.processFilter;
+         render();
+         return;
+     }
+
+     switch (key.name) {
+       case 'q':
+         stopLive();
+         break;
+       case 'c':
+         state.inputMode = 'customizer';
+         state.customizerIndex = 0;
+         render();
+         break;
+       case 'p':
+         state.paused = !state.paused;
+         setStatus(state.paused ? 'Paused' : 'Resumed');
+         render();
+         break;
+        case 'g':
+          state.showGraphs = !state.showGraphs;
+          render();
+          break;
+        case 'b':
+          state.graphMode = state.graphMode === 'spark' ? 'bar' : 'spark';
+          setStatus(`Graph mode: ${state.graphMode}`);
+          render();
+          break;
+        case 'd':
+
+         state.detailed = !state.detailed;
+         setStatus(`Detailed sensor mode: ${state.detailed ? 'on' : 'off'}`);
+         break;
+       case 's':
+         const sortCycle: SortMode[] = ['cpu', 'mem', 'pid', 'user', 'command', 'state', 'threads', 'runtime'];
+         const curIdx = sortCycle.indexOf(state.sortMode);
+         state.sortMode = sortCycle[(curIdx + 1) % sortCycle.length];
+         setStatus(`Sorting by ${state.sortMode}`);
+         render();
+         break;
+       case 'k':
+         state.inputMode = 'kill';
+         state.inputBuffer = '';
+         render();
+         break;
+       case 'S':
+         state.inputMode = 'signal';
+         state.inputBuffer = 'SIGTERM';
+         render();
+         break;
+       case 't':
+         state.treeView = !state.treeView;
+         setStatus(state.treeView ? 'Tree view enabled' : 'Flat view enabled');
+         render();
+         break;
+       case 'e':
+         exportSnapshot();
+         render();
+         break;
+       case 'l':
+         toggleLogging();
+         render();
+         break;
+       case 'f':
+         state.exportFormat = state.exportFormat === 'json' ? 'csv' : state.exportFormat === 'csv' ? 'tsv' : 'json';
+         setStatus(`Export format: ${state.exportFormat}`);
+         render();
+         break;
+     }
+   };
+
+   process.stdin.on('keypress', state.keypressHandler);
+   process.once('SIGINT', () => stopLive());
+ }
+
+ export function stopLive() {
+   if (state.intervalHandle) {
+     clearInterval(state.intervalHandle);
+     state.intervalHandle = null;
+   }
+   if (state.statusTimer) {
+     clearTimeout(state.statusTimer);
+     state.statusTimer = null;
+   }
+   if (state.logStream) {
+     state.logStream.end();
+     state.logStream = null;
+   }
+   if (state.keypressHandler) {
+     process.stdin.removeListener('keypress', state.keypressHandler);
+     state.keypressHandler = null;
+   }
+   process.stdout.removeListener('resize', onResize);
+
+   state.running = false;
+   state.logging = false;
+
+   if (process.stdin.isTTY) process.stdin.setRawMode(false);
+   process.stdin.pause();
+
+   process.stdout.write('\x1b[?25h');
+   process.stdout.write('\x1b[?1049l');
+   process.stdout.write('\x1b[2J\x1b[H');
+
+   process.exit(0);
+ }