pyre-cli 1.3.0 → 2.0.0

package/src/formatters/themes.ts

@@ -0,0 +1,115 @@
+/**
+ * Visual theme definitions for the pyre dashboard.
+ *
+ * Each theme maps UI element roles (border, cpu, mem, …) to a
+ * chalk colour function.  The {@link THEMES} record provides four
+ * built-in themes; additional themes can be added by extending
+ * the {@link ThemeName} union and adding an entry here.
+ */
+import chalk from 'chalk';
+
+export type ThemeName = 'default' | 'dracula' | 'cyberpunk' | 'monochrome' | 'nord' | 'gruvbox';
+
+export interface ThemeColors {
+   border: (s: string) => string;
+   cpu: (s: string) => string;
+   mem: (s: string) => string;
+   gpu: (s: string) => string;
+   power: (s: string) => string;
+   battery: (s: string) => string;
+   thermal: (s: string) => string;
+   network: (s: string) => string;
+   disk: (s: string) => string;
+   graphs: (s: string) => string;
+   process: (s: string) => string;
+}
+
+/**
+ * Built-in colour themes.
+ *
+ * - **default** — muted greys and cyan accents, safe for any terminal.
+ * - **dracula**  — the popular Dracula dark palette.
+ * - **cyberpunk** — high-contrast neon on black.
+ * - **monochrome** — white-only, useful for colour-blind users or
+ *   terminals without 256-colour support.
+ */
+export const THEMES: Record<ThemeName, ThemeColors> = {
+   default: {
+     border: chalk.hex('#4b5563'),
+     cpu: chalk.hex('#22d3ee'),
+     mem: chalk.hex('#a78bfa'),
+     gpu: chalk.hex('#f472b6'),
+     power: chalk.hex('#fbbf24'),
+     battery: chalk.hex('#34d399'),
+     thermal: chalk.hex('#fb923c'),
+     network: chalk.hex('#60a5fa'),
+     disk: chalk.hex('#f472b6'),
+     graphs: chalk.hex('#22d3ee'),
+     process: chalk.hex('#e5e7eb'),
+   },
+   dracula: {
+     border: chalk.hex('#6272a4'),
+     cpu: chalk.hex('#8be9fd'),
+     mem: chalk.hex('#bd93f9'),
+     gpu: chalk.hex('#ff5555'),
+     power: chalk.hex('#f1fa8c'),
+     battery: chalk.hex('#50fa7b'),
+     thermal: chalk.hex('#ffb86c'),
+     network: chalk.hex('#ff79c6'),
+     disk: chalk.hex('#ff5555'),
+     graphs: chalk.hex('#8be9fd'),
+     process: chalk.hex('#f8f8f2'),
+   },
+   cyberpunk: {
+     border: chalk.hex('#ff0055'),
+     cpu: chalk.hex('#00ffcc'),
+     mem: chalk.hex('#ff00ff'),
+     gpu: chalk.hex('#ffff00'),
+     power: chalk.hex('#ffff00'),
+     battery: chalk.hex('#00ff00'),
+     thermal: chalk.hex('#ff6600'),
+     network: chalk.hex('#00ffff'),
+     disk: chalk.hex('#ff007f'),
+     graphs: chalk.hex('#00ffcc'),
+     process: chalk.hex('#ffffff'),
+   },
+    monochrome: {
+      border: chalk.gray,
+      cpu: chalk.white.bold,
+      mem: chalk.white.bold,
+      gpu: chalk.white.bold,
+      power: chalk.white.bold,
+      battery: chalk.white.bold,
+      thermal: chalk.white.bold,
+      network: chalk.white.bold,
+      disk: chalk.white.bold,
+      graphs: chalk.white.bold,
+      process: chalk.white.bold,
+    },
+    nord: {
+      border: chalk.hex('#4c566a'),
+      cpu: chalk.hex('#88c0d0'),
+      mem: chalk.hex('#b48ead'),
+      gpu: chalk.hex('#bf616a'),
+      power: chalk.hex('#ebcb8b'),
+      battery: chalk.hex('#a3be8c'),
+      thermal: chalk.hex('#d08770'),
+      network: chalk.hex('#81a1c1'),
+      disk: chalk.hex('#b48ead'),
+      graphs: chalk.hex('#88c0d0'),
+      process: chalk.hex('#eceff4'),
+    },
+    gruvbox: {
+      border: chalk.hex('#928374'),
+      cpu: chalk.hex('#fb4934'),
+      mem: chalk.hex('#b8bb26'),
+      gpu: chalk.hex('#d3869b'),
+      power: chalk.hex('#fabd2f'),
+      battery: chalk.hex('#b8bb26'),
+      thermal: chalk.hex('#fb4934'),
+      network: chalk.hex('#83a598'),
+      disk: chalk.hex('#d3869b'),
+      graphs: chalk.hex('#fb4934'),
+      process: chalk.hex('#ebdbb2'),
+    },
+  };

package/src/formatters/types.ts

@@ -0,0 +1,62 @@
+/**
+ * Public-facing type definitions for the formatters module.
+ *
+ * These interfaces control how the dashboard is laid out and
+ * which panels are visible.  They are consumed by both the
+ * static `formatTable` function and the live dashboard in
+ * `live/`.
+ */
+import type { ThemeName } from './themes.js';
+import type { StatsData } from '../monitors/types.js';
+
+export type { ThemeName };
+
+export interface ThemeColors {
+   border: (s: string) => string;
+   cpu: (s: string) => string;
+   mem: (s: string) => string;
+   gpu: (s: string) => string;
+   power: (s: string) => string;
+   battery: (s: string) => string;
+   thermal: (s: string) => string;
+   network: (s: string) => string;
+   disk: (s: string) => string;
+   graphs: (s: string) => string;
+   process: (s: string) => string;
+}
+
+export type { StatsData };
+
+export interface VisibleItems {
+   cpu?: boolean;
+   mem?: boolean;
+   gpu?: boolean;
+   power?: boolean;
+   battery?: boolean;
+   thermal?: boolean;
+   network?: boolean;
+   packets?: boolean;
+   tasks?: boolean;
+   disk?: boolean;
+   process?: boolean;
+   tree?: boolean;
+}
+
+export interface TableOptions {
+   /** Terminal width in columns; controls layout, bar sizing, and column count. Defaults to 80. */
+   width?: number;
+   /** Process sort key. Defaults to 'cpu'. */
+   sortBy?: 'cpu' | 'mem' | 'pid' | 'user' | 'command' | 'state' | 'threads' | 'runtime';
+   /** Case-insensitive substring filter applied to the process command. */
+   filter?: string;
+   /** Max process rows to show (the live dashboard sizes this to available terminal height). */
+   processLimit?: number;
+   /** Selected visual theme. */
+   theme?: ThemeName;
+   /** Visibility toggle settings for individual cards. */
+   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

@@ -0,0 +1,153 @@
+/**
+ * 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[] = [];
+
+   /** 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;
+
+  /**
+   * 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;
+      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, this.powerWatts, this.rxPacketRate, this.txPacketRate, this.connections]) {
+        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,201 @@
+#!/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.
+ * P2P mode enables live data streaming between two systems over TCP.
+ */
+import fs from 'node:fs';
+import readline from 'node:readline';
+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';
+import { P2PServer, P2PClient } from './p2p/index.js';
+
+const program = new Command();
+
+program
+    .name('pyre')
+    .version('2.0.0')
+    .description('Mac system monitoring CLI: interactive live dashboard, stats, graphs, export, packet monitor, battery predictor')
+    .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')
+    .option('--packets', 'Include packet monitor panel in output')
+    .option('--limit <n>', 'Max number of processes to include in --once/--json/--csv/--tsv snapshots (0 = all)', '10')
+    .option('--p2p-host <host>', 'P2P host address (server: bind address, client: server address)', '0.0.0.0')
+    .option('--p2p-port <port>', 'P2P port number', '9876')
+    .option('--p2p-password <password>', 'Password for P2P authentication');
+
+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 cmd = program.args[0];
+
+  if (cmd === 'live' || (!isExportMode() && !opts.once && cmd !== 'p2p')) {
+    if (cmd === 'live') {
+      program.args.shift();
+    }
+    await showSplash();
+    const interval = parseFloat(opts.interval) || 2;
+    await startLive({
+      interval,
+      detailed: opts.detailed,
+      exportDir: opts.exportDir,
+      autoLog: opts.log,
+    });
+    return;
+  }
+
+  if (cmd === 'p2p') {
+    const subcommand = program.args[1];
+    if (subcommand === 'server') {
+      await runP2PServer();
+      return;
+    } else if (subcommand === 'connect') {
+      await runP2PConnect();
+      return;
+    } else {
+      console.log(chalk.red('Usage: pyre p2p <server|connect> [options]'));
+      process.exit(1);
+    }
+  }
+
+  // `0` means "no cap" — collectProcesses treats an undefined limit as
+  // unlimited by grabbing every row `ps` returns instead of head-limiting it.
+  const requestedLimit = parseInt(opts.limit, 10);
+  const processLimit = Number.isFinite(requestedLimit) && requestedLimit > 0 ? requestedLimit : undefined;
+
+  const data = await collectAll({ detailed: opts.detailed, processLimit });
+
+  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, visible: { packets: opts.packets ? true : undefined } });
+
+  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}`));
+  process.exit(1);
+});
+
+async function runP2PServer(): Promise<void> {
+  const host = opts.p2pHost || '0.0.0.0';
+  const port = parseInt(opts.p2pPort, 10) || 9876;
+  const password = opts.p2pPassword || '';
+  const interval = parseFloat(opts.interval) || 2;
+  const detailed = !!opts.detailed;
+
+  if (!password) {
+    console.log(chalk.red('Error: a password is required for P2P server mode. Use --p2p-password <password>'));
+    process.exit(1);
+  }
+
+  const server = new P2PServer({ host, port, password, intervalMs: interval * 1000, detailed });
+
+  console.log(chalk.bold(`\n  pyre P2P Server`));
+  console.log(chalk.dim(`  Host: ${host}`));
+  console.log(chalk.dim(`  Port: ${port}`));
+  console.log(chalk.dim(`  Password: ${password}`));
+  console.log(chalk.dim(`  Interval: ${interval}s`));
+  console.log(chalk.dim(`  Detailed: ${detailed ? 'on' : 'off'}`));
+  console.log(chalk.dim(`  Waiting for peers...\n`));
+
+  await server.start();
+
+  const rl = readline.createInterface({ input: process.stdin });
+  rl.on('line', (line) => {
+    const trimmed = line.trim().toLowerCase();
+    if (trimmed === 'q' || trimmed === 'quit' || trimmed === 'exit') {
+      server.stop();
+      rl.close();
+      process.exit(0);
+    } else if (trimmed === 'status') {
+      const info = server.info;
+      console.log(chalk.dim(`  Peers connected: ${info.peersConnected}`));
+    }
+  });
+
+  process.once('SIGINT', () => {
+    server.stop();
+    rl.close();
+    process.exit(0);
+  });
+}
+
+async function runP2PConnect(): Promise<void> {
+  const host = opts.p2pHost || '127.0.0.1';
+  const port = parseInt(opts.p2pPort, 10) || 9876;
+  const password = opts.p2pPassword || '';
+
+  if (!password) {
+    console.log(chalk.red('Error: a password is required for P2P connect mode. Use --p2p-password <password>'));
+    process.exit(1);
+  }
+
+  const client = new P2PClient({ host, port, password });
+
+  client.setOnStatus((msg) => {
+    process.stdout.write(`\r${chalk.dim(msg)}${' '.repeat(40)}\r`);
+  });
+
+  client.setOnData((data) => {
+    process.stdout.write('\x1b[2J\x1b[H');
+    console.log(chalk.bold(`  pyre P2P Client — ${data.header.hostname}`));
+    console.log(chalk.dim(`  ${data.timestamp}`));
+    console.log();
+    console.log(formatTable(data, {
+      width: process.stdout.columns || 80,
+      sortBy: 'cpu',
+      treeView: false,
+      visible: { packets: true },
+    }));
+  });
+
+  console.log(chalk.bold(`\n  pyre P2P Client`));
+  console.log(chalk.dim(`  Connecting to ${host}:${port}...`));
+  console.log(chalk.dim(`  Press Ctrl+C to disconnect\n`));
+
+  try {
+    await client.connect();
+  } catch (err: any) {
+    console.log(chalk.red(`Connection failed: ${err.message}`));
+    process.exit(1);
+  }
+
+  process.once('SIGINT', () => {
+    client.disconnect();
+    process.exit(0);
+  });
+}

package/src/live/export.ts

@@ -0,0 +1,76 @@
+/**
+ * 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,net_rx_packets,net_tx_packets,connections,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 ?? '';
+  const rxPackets = data.network.rxPackets ?? 0;
+  const txPackets = data.network.txPackets ?? 0;
+  const connections = data.network.connections ?? 0;
+  state.logStream.write(
+    `${data.timestamp},${data.cpu.usage},${data.memory.usagePercent},${temp},${data.network.rxBytes},${data.network.txBytes},${rxPackets},${txPackets},${connections},${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';