pyre-cli 1.3.0 → 2.0.0

package/src/monitors/run.ts

@@ -0,0 +1,18 @@
+/**
+ * Shared shell-execution helper for the monitors module.
+ *
+ * Wraps `child_process.execSync` with a timeout and a
+ * fallback return value so that a failing command never
+ * crashes the entire collection pipeline.
+ */
+
+async function run(cmd: string, fallback: string = ''): Promise<string> {
+  try {
+    const { execSync } = await import('node:child_process');
+    return execSync(cmd, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 5000 }).trim();
+  } catch {
+    return fallback;
+  }
+}
+
+export { run };

package/src/monitors/smc.ts

@@ -0,0 +1,107 @@
+/**
+ * SMC and powermetrics sensor reader.
+ *
+ * Modern macOS requires `powermetrics` (root) to read CPU die
+ * temperature, GPU die temperature, SMC die temperature, and
+ * power draw (CPU/GPU/combined watts).  This module wraps that
+ * call with a short-lived cache so that multiple collectors can
+ * reuse the same data within a single tick without invoking
+ * `powermetrics` repeatedly.
+ *
+ * It also provides the `parseSuffix` helper used when decoding
+ * `vm.swapusage` output.
+ */
+import { run } from './run.js';
+
+export interface SmcMetrics {
+  temps: Record<string, number>;
+  power: { cpu?: number; gpu?: number; combined?: number };
+  freq: Record<string, number>;
+}
+
+let smcCache: { data: SmcMetrics; ts: number } | null = null;
+
+/**
+ * Query `powermetrics` for SMC temperatures, power draw, and
+ * CPU frequency.  Results are cached for 1.5 s so that
+ * concurrent collectors (CPU temp, power, thermal) share a
+ * single invocation.
+ *
+ * Falls back to an empty object on any failure (missing
+ * sudoers entry, unavailable binary, etc.) so the rest of the
+ * application degrades gracefully.
+ */
+export async function getSmcMetrics(): Promise<SmcMetrics> {
+  const now = Date.now();
+  if (smcCache && now - smcCache.ts < 1500) return smcCache.data;
+
+  const result: SmcMetrics = { temps: {}, power: {}, freq: {} };
+  try {
+    // `sudo -n` (non-interactive) so we never hang waiting on a
+    // password prompt that can't be answered from a piped child
+    // process; if the user hasn't set up passwordless sudo for
+    // powermetrics, this just fails fast and we fall back to the
+    // thermal-state string instead of a temperature.
+    const pm = (
+      await run(
+        'sudo -n powermetrics --samplers smc,cpu_power -n 1 --format text 2>/dev/null',
+        ''
+      )
+    ).trim();
+
+    if (pm) {
+      const cpuTemp = pm.match(/CPU die temperature:\s*([\d.]+)/i);
+      if (cpuTemp) result.temps['cpu_die'] = parseFloat(cpuTemp[1]);
+
+      const gpuTemp = pm.match(/GPU die temperature:\s*([\d.]+)/i);
+      if (gpuTemp) result.temps['gpu_die'] = parseFloat(gpuTemp[1]);
+
+      const smcTemp = pm.match(/SMC die temperature:\s*([\d.]+)/i);
+      if (smcTemp) result.temps['smc_die'] = parseFloat(smcTemp[1]);
+
+      const cpuPower = pm.match(/CPU Power:\s*([\d.]+)\s*mW/i);
+      if (cpuPower) result.power.cpu = parseFloat(cpuPower[1]) / 1000;
+
+      const gpuPower = pm.match(/GPU Power:\s*([\d.]+)\s*mW/i);
+      if (gpuPower) result.power.gpu = parseFloat(gpuPower[1]) / 1000;
+
+      const combinedPower = pm.match(/Combined Power \(CPU \+ GPU.*?\):\s*([\d.]+)\s*mW/i);
+      if (combinedPower) result.power.combined = parseFloat(combinedPower[1]) / 1000;
+
+      // Apple Silicon reports active clock speed per core cluster
+      // rather than a single number — grab whichever cluster(s)
+      // this chip has.
+      const eFreq = pm.match(/E-Cluster HW active frequency:\s*([\d.]+)/i);
+      if (eFreq) result.freq['e_cluster'] = parseFloat(eFreq[1]);
+
+      const pFreq = pm.match(/P-Cluster HW active frequency:\s*([\d.]+)/i);
+      if (pFreq) result.freq['p_cluster'] = parseFloat(pFreq[1]);
+
+      // Some single-cluster/older chips report just "CPU HW active frequency".
+      const cpuFreq = pm.match(/CPU HW active frequency:\s*([\d.]+)/i);
+      if (cpuFreq) result.freq['cpu'] = parseFloat(cpuFreq[1]);
+    }
+  } catch {
+    // powermetrics unavailable/unauthorized — leave temps/power/freq empty,
+    // the rest of the app degrades gracefully (thermal state string still
+    // shows, and CPU frequency falls back to 0/"unavailable").
+  }
+
+  smcCache = { data: result, ts: now };
+  return result;
+}
+
+/**
+ * Parse a size suffix (K, M, G) from `vm.swapusage` output into
+ * its byte multiplier.  Case-insensitive; defaults to 1 (no
+ * suffix).
+ */
+export function parseSuffix(s: string): number {
+  return s.toUpperCase() === 'K'
+    ? 1024
+    : s.toUpperCase() === 'M'
+      ? 1024 * 1024
+      : s.toUpperCase() === 'G'
+        ? 1024 * 1024 * 1024
+        : 1;
+}

package/src/monitors/types.ts

@@ -0,0 +1,148 @@
+/**
+ * Core data types for system metric collection.
+ *
+ * Every interface in this file represents a distinct category of
+ * system information gathered by the monitors module.  The
+ * {@link StatsData} aggregate ties them together for downstream
+ * formatting and export.
+ */
+
+export interface StatsData {
+   header: { title: string; hostname: string; os: string; uptime: string };
+   cpu: CpuData;
+   gpu: GpuData | null;
+   memory: MemoryData;
+   disk: DiskData[];
+   battery: BatteryData | null;
+   thermal: ThermalData;
+   network: NetworkData;
+   processes: ProcessData[];
+   power: PowerData | null;
+   timestamp: string;
+   packets: PacketData | null;
+   tasks: TaskData[];
+}
+
+export interface GpuData {
+   model: string;
+   memory: number;
+   utilization: number;
+   temperature?: number;
+   processes: number;
+ }
+
+ export interface PowerData {
+   cpuWatts?: number;
+   gpuWatts?: number;
+   combinedWatts?: number;
+ }
+
+ export interface PacketData {
+   totalPackets: number;
+   rxPackets: number;
+   txPackets: number;
+   rxRate: number;
+   txRate: number;
+   connections: number;
+   topProcesses: { pid: number; command: string; rxBytes: number; txBytes: number }[];
+   /** Every process with an open network connection (unlike topProcesses, not truncated). */
+   allProcesses: { pid: number; command: string; rxBytes: number; txBytes: number; rxPackets?: number; txPackets?: number }[];
+   interfaces: { iface: string; rxPackets: number; txPackets: number; rxBytes: number; txBytes: number }[];
+ }
+
+ export interface TaskData {
+   pid: number;
+   user: string;
+   cpu: number;
+   mem: number;
+   command: string;
+   state: string;
+   runtime: number;
+ }
+
+export interface CpuData {
+  brand: string;
+  cores: number;
+  physicalCores: number;
+  frequency: number;
+  usage: number;
+  loadAvg: number[];
+  temperature?: number;
+}
+
+export interface MemoryData {
+  total: number;
+  used: number;
+  free: number;
+  swapTotal: number;
+  swapUsed: number;
+  swapFree: number;
+  pageSize: number;
+  usagePercent: number;
+}
+
+export interface ThermalData {
+  state: string;
+  detail?: string;
+  /** Normalized 0-3 scale (nominal/fair/serious/critical) derived from `state`, for graphing/coloring */
+  pressureLevel: number;
+  temperatures?: Record<string, number | null>;
+  error?: string;
+}
+
+export interface BatteryData {
+  level: number;
+  state: string;
+  timeRemaining: string;
+  health: string;
+  powerSource: string;
+  cycles?: number;
+  condition?: string;
+  maxCapacityPercent?: number;
+  estimatedTimeToEmpty?: string;
+  dischargeRatePerHour?: number;
+  powerWatts?: number;
+}
+
+export interface DiskData {
+  filesystem: string;
+  size: string;
+  used: string;
+  available: string;
+  capacity: string;
+  mountpoint: string;
+}
+
+export interface NetworkData {
+  interface: string;
+  ip: string;
+  rxBytes: number;
+  txBytes: number;
+  rxPackets: number;
+  txPackets: number;
+  rxPacketsPerSec?: number;
+  txPacketsPerSec?: number;
+  connections?: number;
+  topProcesses?: NetworkProcess[];
+}
+
+export interface NetworkProcess {
+  pid: number;
+  command: string;
+  rxBytes: number;
+  txBytes: number;
+  rxPackets: number;
+  txPackets: number;
+}
+
+export interface ProcessData {
+   pid: number;
+   ppid: number;
+   user: string;
+   cpu: number;
+   mem: number;
+   command: string;
+   state: string;
+   threads: number;
+   runtime: number;
+}

package/src/p2p/client.ts

@@ -0,0 +1,197 @@
+import net from 'node:net';
+import chalk from 'chalk';
+import { encodeAuth, encodePing, encodePong, encodeDisconnect } from './protocol.js';
+import type { P2PClientOptions } from './types.js';
+import type { StatsData } from '../monitors/types.js';
+
+interface ReadState {
+  buffer: Buffer;
+  expectingHeader: boolean;
+  messageLength: number;
+}
+
+export class P2PClient {
+  private socket: net.Socket | null = null;
+  private options: P2PClientOptions;
+  private running = false;
+  private readState: ReadState = { buffer: Buffer.alloc(0), expectingHeader: true, messageLength: 0 };
+  private onDataCallback: ((data: StatsData) => void) | null = null;
+  private onStatusCallback: ((msg: string) => void) | null = null;
+  private reconnectTimer: NodeJS.Timeout | null = null;
+  private pingHandle: NodeJS.Timeout | null = null;
+
+  constructor(options: P2PClientOptions) {
+    this.options = options;
+  }
+
+  setOnData(cb: (data: StatsData) => void): void {
+    this.onDataCallback = cb;
+  }
+
+  setOnStatus(cb: (msg: string) => void): void {
+    this.onStatusCallback = cb;
+  }
+
+  async connect(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.socket = new net.Socket();
+
+      this.socket.on('data', (data) => this.onData(data));
+      this.socket.on('close', () => this.onClose());
+      this.socket.on('error', (err) => this.onError(err));
+      this.socket.on('timeout', () => this.onTimeout());
+
+      this.socket.setTimeout(10000);
+
+      this.socket.connect(this.options.port, this.options.host, () => {
+        this.running = true;
+        this.socket?.setTimeout(0);
+        this.socket?.write(encodeAuth(this.options.password));
+        this.status('Connecting...');
+        resolve();
+      });
+
+      this.socket.once('error', (err) => {
+        reject(err);
+      });
+    });
+  }
+
+  disconnect(): void {
+    this.running = false;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.pingHandle) {
+      clearInterval(this.pingHandle);
+      this.pingHandle = null;
+    }
+    if (this.socket) {
+      try {
+        this.socket.write(encodeDisconnect('Client closing'));
+      } catch {
+        // ignore
+      }
+      this.socket.destroy();
+      this.socket = null;
+    }
+    this.status('Disconnected');
+  }
+
+  private onData(data: Buffer): void {
+    this.readState.buffer = Buffer.concat([this.readState.buffer, data]);
+
+    while (this.readState.buffer.length > 0) {
+      if (this.readState.expectingHeader) {
+        if (this.readState.buffer.length >= 4) {
+          this.readState.messageLength = this.readState.buffer.readUInt32BE(0);
+          this.readState.buffer = this.readState.buffer.subarray(4);
+          this.readState.expectingHeader = false;
+        } else {
+          break;
+        }
+      }
+
+      if (!this.readState.expectingHeader) {
+        if (this.readState.buffer.length >= this.readState.messageLength) {
+          const body = this.readState.buffer.subarray(0, this.readState.messageLength);
+          this.readState.buffer = this.readState.buffer.subarray(this.readState.messageLength);
+          this.readState.expectingHeader = true;
+          this.handleMessage(body);
+        } else {
+          break;
+        }
+      }
+    }
+  }
+
+  private handleMessage(body: Buffer): void {
+    try {
+      const msg = JSON.parse(body.toString('utf-8'));
+
+      switch (msg.kind) {
+        case 'auth-ok':
+          this.status('Authenticated — receiving live data');
+          this.startPing();
+          break;
+
+        case 'auth-fail':
+          this.status(`Authentication failed: ${(msg.payload as { reason: string }).reason}`);
+          this.disconnect();
+          break;
+
+        case 'data':
+          if (this.onDataCallback && msg.payload?.stats) {
+            this.onDataCallback(msg.payload.stats as StatsData);
+          }
+          break;
+
+        case 'ping':
+          if (this.socket && !this.socket.destroyed) {
+            const ts = (msg.payload as { ts: number }).ts;
+            this.socket.write(encodePong(ts));
+          }
+          break;
+
+        case 'pong':
+          break;
+
+        case 'disconnect':
+          this.status(`Server disconnected: ${(msg.payload as { reason: string }).reason}`);
+          this.disconnect();
+          break;
+
+        default:
+          break;
+      }
+    } catch {
+      // ignore malformed messages
+    }
+  }
+
+  private startPing(): void {
+    this.pingHandle = setInterval(() => {
+      if (this.socket && !this.socket.destroyed) {
+        this.socket.write(encodePing());
+      }
+    }, 15000);
+  }
+
+  private onClose(): void {
+    if (this.running) {
+      this.status('Connection closed — reconnecting in 3s');
+      this.reconnectTimer = setTimeout(() => {
+        if (this.running) this.connect().catch(() => {});
+      }, 3000);
+    }
+  }
+
+  private onError(err: Error): void {
+    const code = (err as any).code;
+    if (code === 'ECONNREFUSED') {
+      this.status('Connection refused — is the server running?');
+    } else if (code === 'ETIMEDOUT') {
+      this.status('Connection timed out');
+    } else {
+      this.status(`Connection error: ${err.message}`);
+    }
+  }
+
+  private onTimeout(): void {
+    this.status('Connection timed out');
+    this.disconnect();
+  }
+
+  private status(msg: string): void {
+    if (this.onStatusCallback) {
+      this.onStatusCallback(msg);
+    }
+  }
+}
+
+export async function connectP2PClient(options: P2PClientOptions): Promise<P2PClient> {
+  const client = new P2PClient(options);
+  await client.connect();
+  return client;
+}

package/src/p2p/index.ts

@@ -0,0 +1,3 @@
+export { P2PServer, startP2PServer } from './server.js';
+export { P2PClient, connectP2PClient } from './client.js';
+export type { P2PServerOptions, P2PClientOptions, P2PConnectionInfo } from './types.js';

package/src/p2p/protocol.ts

@@ -0,0 +1,71 @@
+import type { P2PMessage, P2PMessageKind, P2PPayload } from './types.js';
+import type { StatsData } from '../monitors/types.js';
+
+const HEADER_SIZE = 4;
+const MAX_MESSAGE_SIZE = 16 * 1024 * 1024;
+
+function buildMessage(kind: P2PMessageKind, payload: P2PPayload): Buffer {
+  const envelope: P2PMessage = { kind, payload };
+  const body = Buffer.from(JSON.stringify(envelope), 'utf-8');
+  const header = Buffer.alloc(HEADER_SIZE);
+  header.writeUInt32BE(body.length, 0);
+  return Buffer.concat([header, body]);
+}
+
+export function encodeAuth(password: string): Buffer {
+  return buildMessage('auth', { password });
+}
+
+export function encodeAuthOk(): Buffer {
+  return buildMessage('auth-ok', { ok: true });
+}
+
+export function encodeAuthFail(reason: string): Buffer {
+  return buildMessage('auth-fail', { ok: false, reason });
+}
+
+export function encodeData(stats: StatsData): Buffer {
+  return buildMessage('data', { stats });
+}
+
+export function encodePing(): Buffer {
+  return buildMessage('ping', { ts: Date.now() });
+}
+
+export function encodePong(ts: number): Buffer {
+  return buildMessage('pong', { ts });
+}
+
+export function encodeDisconnect(reason: string): Buffer {
+  return buildMessage('disconnect', { reason });
+}
+
+export function decodeMessage(buf: Buffer): P2PMessage {
+  const str = buf.toString('utf-8');
+  const msg: P2PMessage = JSON.parse(str);
+  return msg;
+}
+
+export function readMessage(stream: { read(n: number): Buffer | null }): Buffer | null {
+  const header = stream.read(HEADER_SIZE);
+  if (!header || header.length < HEADER_SIZE) return null;
+  const length = header.readUInt32BE(0);
+  if (length > MAX_MESSAGE_SIZE) {
+    throw new Error(`Message too large: ${length} bytes`);
+  }
+  const body = stream.read(length);
+  if (!body || body.length < length) return null;
+  return body;
+}
+
+export function readAll(stream: { read(n: number): Buffer | null }, total: number): Buffer {
+  const chunks: Buffer[] = [];
+  let remaining = total;
+  while (remaining > 0) {
+    const chunk = stream.read(remaining);
+    if (!chunk) break;
+    chunks.push(chunk);
+    remaining -= chunk.length;
+  }
+  return Buffer.concat(chunks);
+}