pyre-cli 9.5.2 → 10.0.0

package/src/replayCmd.ts

@@ -0,0 +1,186 @@
+/**
+ * pyre replay — CSV log file playback TUI.
+ *
+ * Reads a pyre CSV log file (from pyre live --log) and plays it back
+ * in a lightweight read-only TUI.
+ *
+ * Controls: Space/p=pause  ]/[=speed  arrow keys=step  q=quit
+ */
+import fs from 'node:fs';
+import readline from 'node:readline';
+import chalk from 'chalk';
+
+export interface ReplayOptions {
+  file: string;
+  speed?: number;
+  plain?: boolean;
+}
+
+interface LogRow {
+  timestamp: string;
+  cpuUsage: number;
+  memUsage: number;
+  tempC?: number;
+  rxBytes?: number;
+  txBytes?: number;
+  rxPackets?: number;
+  txPackets?: number;
+  connections?: number;
+  thermalState?: string;
+}
+
+function parseLogFile(filePath: string): LogRow[] {
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const rows: LogRow[] = [];
+  for (const line of content.split('\n').slice(1)) {
+    if (!line.trim()) continue;
+    const parts = line.split(',');
+    if (parts.length < 3) continue;
+    const cpuUsage = parseFloat(parts[1]);
+    const memUsage = parseFloat(parts[2]);
+    if (isNaN(cpuUsage) || isNaN(memUsage)) continue;
+    rows.push({
+      timestamp: parts[0]?.trim() ?? '',
+      cpuUsage,
+      memUsage,
+      tempC: parts[3] ? parseFloat(parts[3]) || undefined : undefined,
+      rxBytes: parts[4] ? parseFloat(parts[4]) || undefined : undefined,
+      txBytes: parts[5] ? parseFloat(parts[5]) || undefined : undefined,
+      rxPackets: parts[6] ? parseFloat(parts[6]) || undefined : undefined,
+      txPackets: parts[7] ? parseFloat(parts[7]) || undefined : undefined,
+      connections: parts[8] ? parseInt(parts[8], 10) || undefined : undefined,
+      thermalState: parts[9]?.trim() || undefined,
+    });
+  }
+  return rows;
+}
+
+function fmtBytes(bytes: number): string {
+  if (bytes >= 1e9) return `${(bytes / 1e9).toFixed(1)} GB`;
+  if (bytes >= 1e6) return `${(bytes / 1e6).toFixed(1)} MB`;
+  if (bytes >= 1e3) return `${(bytes / 1e3).toFixed(0)} KB`;
+  return `${bytes} B`;
+}
+
+function bar(pct: number, width = 20): string {
+  const filled = Math.max(0, Math.min(Math.round((pct / 100) * width), width));
+  const color = pct >= 90 ? chalk.red : pct >= 70 ? chalk.yellow : chalk.green;
+  return color('█'.repeat(filled)) + chalk.dim('░'.repeat(width - filled));
+}
+
+function renderFrame(row: LogRow, idx: number, total: number, speed: number, paused: boolean, cols: number): string[] {
+  const lines: string[] = [];
+  const divider = chalk.dim('─'.repeat(Math.min(cols - 2, 78)));
+
+  lines.push('');
+  lines.push(chalk.bold.hex('#ff5500')('  🔥 pyre replay') + '  ' + chalk.dim(row.timestamp || ''));
+  lines.push('  ' + divider);
+  lines.push('');
+  lines.push(`  CPU        ${bar(row.cpuUsage)} ${String(row.cpuUsage.toFixed(1)).padStart(5)}%`);
+  lines.push(`  Memory     ${bar(row.memUsage)} ${String(row.memUsage.toFixed(1)).padStart(5)}%`);
+
+  if (row.tempC !== undefined && !isNaN(row.tempC)) {
+    const tc = row.tempC >= 90 ? chalk.red : row.tempC >= 70 ? chalk.yellow : chalk.cyan;
+    lines.push(`  Temp       ${tc(`${row.tempC.toFixed(1)}°C`)}`);
+  }
+  if (row.rxBytes !== undefined || row.txBytes !== undefined) {
+    const rx = row.rxBytes !== undefined ? fmtBytes(row.rxBytes) : 'N/A';
+    const tx = row.txBytes !== undefined ? fmtBytes(row.txBytes) : 'N/A';
+    lines.push(`  Network    ↓ ${chalk.green(rx)}  ↑ ${chalk.blue(tx)}`);
+  }
+  if (row.connections !== undefined) {
+    lines.push(`  Conns      ${chalk.cyan(String(row.connections))}`);
+  }
+  if (row.thermalState && row.thermalState !== 'Nominal') {
+    const sc = row.thermalState === 'Critical' ? chalk.red : chalk.yellow;
+    lines.push(`  Thermal    ${sc(row.thermalState)}`);
+  }
+
+  lines.push('');
+  lines.push('  ' + divider);
+
+  // Scrub bar
+  const progWidth = 30;
+  const progress = total > 1 ? Math.round((idx / (total - 1)) * progWidth) : 0;
+  const progressBar = chalk.cyan('█'.repeat(progress)) + chalk.dim('░'.repeat(progWidth - progress));
+  const icon = paused ? chalk.yellow('⏸') : chalk.green('▶');
+  const spStr = speed === 1 ? '1×' : `${speed}×`;
+  lines.push(`  ${icon} ${progressBar}  ${chalk.bold(`${idx + 1}/${total}`)}  ${chalk.dim(spStr)}`);
+  lines.push('');
+  lines.push(chalk.dim('  Space/p=pause  ]/[=speed  ←/→=step  q=quit'));
+
+  return lines;
+}
+
+export async function runReplayCommand(opts: ReplayOptions): Promise<void> {
+  const { file, speed: initialSpeed = 1, plain } = opts;
+
+  if (!fs.existsSync(file)) {
+    console.error(chalk.red(`  ✖ File not found: ${file}`));
+    process.exit(1);
+  }
+
+  let rows: LogRow[];
+  try {
+    rows = parseLogFile(file);
+  } catch (err) {
+    console.error(chalk.red(`  ✖ Could not parse log file: ${err instanceof Error ? err.message : String(err)}`));
+    process.exit(1);
+  }
+
+  if (rows.length === 0) {
+    console.log(chalk.yellow('  No data rows found in the log file.'));
+    return;
+  }
+
+  if (plain) chalk.level = 0;
+
+  let frameIdx = 0;
+  let speed = initialSpeed;
+  let paused = false;
+  let running = true;
+
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  readline.emitKeypressEvents(process.stdin);
+
+  const cols = process.stdout.columns || 80;
+  process.stdout.write('\x1b[?25l\x1b[2J\x1b[H');
+
+  function renderCurrent() {
+    const lines = renderFrame(rows[frameIdx], frameIdx, rows.length, speed, paused, cols);
+    process.stdout.write('\x1b[H' + lines.map(l => `\x1b[2K${l}`).join('\r\n') + '\x1b[0J');
+  }
+
+  renderCurrent();
+
+  process.stdin.on('keypress', (str: string, key: readline.Key) => {
+    if (!key) return;
+    if ((key.ctrl && key.name === 'c') || key.name === 'q') {
+      running = false;
+      process.stdout.write('\x1b[?25h\x1b[2J\x1b[H');
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+      process.exit(0);
+    }
+    if (key.name === 'space' || key.name === 'p') { paused = !paused; renderCurrent(); return; }
+    if (str === ']') { speed = Math.min(speed * 2, 32); renderCurrent(); return; }
+    if (str === '[') { speed = Math.max(speed / 2, 0.125); renderCurrent(); return; }
+    if (key.name === 'right') { frameIdx = Math.min(frameIdx + 1, rows.length - 1); renderCurrent(); return; }
+    if (key.name === 'left') { frameIdx = Math.max(frameIdx - 1, 0); renderCurrent(); return; }
+  });
+
+  const BASE_MS = 2000;
+  const tick = () => {
+    if (!running) return;
+    if (!paused) {
+      frameIdx++;
+      if (frameIdx >= rows.length) { paused = true; frameIdx = rows.length - 1; }
+      renderCurrent();
+    }
+    setTimeout(tick, BASE_MS / speed);
+  };
+  setTimeout(tick, BASE_MS / speed);
+
+  await new Promise<void>(() => {});
+}

package/src/serveCmd.ts

@@ -0,0 +1,180 @@
+/**
+ * pyre serve — Dedicated REST API Mode.
+ *
+ * Exposes all metrics as structured JSON REST endpoints with optional
+ * API key authorization and CORS support.
+ *
+ * Endpoints:
+ *   GET /api/all
+ *   GET /api/cpu
+ *   GET /api/memory
+ *   GET /api/gpu
+ *   GET /api/battery
+ *   GET /api/thermal
+ *   GET /api/network
+ *   GET /api/disk
+ *   GET /api/processes
+ *   GET /api/containers
+ *   GET /api/system
+ */
+import http from 'node:http';
+import os from 'node:os';
+import chalk from 'chalk';
+import {
+  collectAll,
+  collectCpu,
+  collectMemory,
+  collectGpu,
+  collectBattery,
+  collectThermal,
+  collectNetwork,
+  collectDisk,
+  collectProcesses,
+  collectContainers,
+  collectSystem,
+} from './monitors/collectors.js';
+
+export interface ServeOptions {
+  port?: number;
+  apiKey?: string;
+  detailed?: boolean;
+}
+
+export async function runServeCommand(opts: ServeOptions = {}): Promise<void> {
+  const port = opts.port || 8080;
+  const apiKey = opts.apiKey || process.env.PYRE_API_KEY || '';
+
+  const server = http.createServer(async (req, res) => {
+    // CORS headers
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, x-api-key');
+
+    if (req.method === 'OPTIONS') {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+
+    const urlObj = new URL(req.url || '/', `http://localhost:${port}`);
+    const pathname = urlObj.pathname;
+
+    // Optional API key validation
+    if (apiKey) {
+      const authHeader = req.headers['authorization'] || '';
+      const xApiKey = req.headers['x-api-key'] || '';
+      const queryKey = urlObj.searchParams.get('key') || '';
+      const token = authHeader.startsWith('Bearer ') ? authHeader.slice(7) : authHeader;
+
+      if (token !== apiKey && xApiKey !== apiKey && queryKey !== apiKey) {
+        res.writeHead(401, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Unauthorized: Invalid or missing API key' }));
+        return;
+      }
+    }
+
+    try {
+      let data: any;
+
+      switch (pathname) {
+        case '/api/all':
+        case '/api/stats':
+        case '/api':
+          data = await collectAll({ detailed: opts.detailed });
+          break;
+        case '/api/cpu':
+          data = await collectCpu();
+          break;
+        case '/api/memory':
+        case '/api/mem':
+          data = await collectMemory();
+          break;
+        case '/api/gpu':
+          data = await collectGpu(opts.detailed);
+          break;
+        case '/api/battery':
+        case '/api/power':
+          data = await collectBattery();
+          break;
+        case '/api/thermal':
+        case '/api/temp':
+          data = await collectThermal(opts.detailed);
+          break;
+        case '/api/network':
+        case '/api/net':
+          data = await collectNetwork();
+          break;
+        case '/api/disk':
+          data = await collectDisk();
+          break;
+        case '/api/processes':
+        case '/api/proc':
+          data = await collectProcesses(50);
+          break;
+        case '/api/containers':
+          data = await collectContainers();
+          break;
+        case '/api/system':
+        case '/api/info':
+          data = await collectSystem();
+          break;
+        case '/health':
+        case '/api/health':
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ status: 'ok', uptime: os.uptime(), timestamp: new Date().toISOString() }));
+          return;
+        default:
+          res.writeHead(404, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({
+            error: 'Not found',
+            availableEndpoints: [
+              '/api/all',
+              '/api/cpu',
+              '/api/memory',
+              '/api/gpu',
+              '/api/battery',
+              '/api/thermal',
+              '/api/network',
+              '/api/disk',
+              '/api/processes',
+              '/api/containers',
+              '/api/system',
+              '/api/health',
+            ],
+          }));
+          return;
+      }
+
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(data, null, 2));
+    } catch (err: any) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: err.message || 'Internal metric collection error' }));
+    }
+  });
+
+  server.on('error', (err: any) => {
+    if (err.code === 'EADDRINUSE') {
+      console.error(chalk.red(`\n  ✖ Error: Port ${port} is already in use. Use --port <port> to select an alternate port.\n`));
+    } else {
+      console.error(chalk.red(`\n  ✖ Server error: ${err.message}\n`));
+    }
+    process.exit(1);
+  });
+
+  await new Promise<void>((resolve) => server.listen(port, '0.0.0.0', resolve));
+
+  console.log(chalk.bold('\n  🔥 pyre serve — REST API Server\n'));
+  console.log(`  ${chalk.green('✔')} API base URL: ${chalk.cyan(`http://0.0.0.0:${port}/api/all`)}`);
+  console.log(`  ${chalk.green('✔')} Health check: ${chalk.cyan(`http://0.0.0.0:${port}/api/health`)}`);
+  if (apiKey) {
+    console.log(`  ${chalk.yellow('🔒')} API Key protection: ${chalk.bold('ENABLED')} (Pass via header x-api-key or ?key=)`);
+  } else {
+    console.log(`  ${chalk.dim('🔓')} API Key protection: ${chalk.dim('DISABLED (Public local network access)')}`);
+  }
+  console.log(`\n  ${chalk.dim('Endpoints: /api/cpu, /api/memory, /api/gpu, /api/battery, /api/thermal, /api/network, /api/disk, /api/processes')}`);
+  console.log(chalk.dim('\n  Press Ctrl+C to stop.\n'));
+
+  // Keep alive
+  await new Promise<void>(() => {});
+}

package/src/service.ts

@@ -4,10 +4,43 @@ import path from 'node:path';
 import { execSync } from 'node:child_process';
 import chalk from 'chalk';
 
-const PLIST_LABEL = 'com.pyre.web';
-const PLIST_PATH = path.join(os.homedir(), 'Library', 'LaunchAgents', `${PLIST_LABEL}.plist`);
+const SERVICE_LABEL = 'com.pyre.web';
+const PLIST_PATH = path.join(os.homedir(), 'Library', 'LaunchAgents', `${SERVICE_LABEL}.plist`);
+const SYSTEMD_USER_DIR = path.join(os.homedir(), '.config', 'systemd', 'user');
+const SYSTEMD_UNIT_PATH = path.join(SYSTEMD_USER_DIR, 'pyre-web.service');
+const TASK_NAME = 'PyreWeb';
 
-export function installLaunchdAgent(port: number = 3000): void {
+export function installService(port: number = 3000): void {
+  const platform = process.platform;
+  if (platform === 'darwin') {
+    installLaunchd(port);
+  } else if (platform === 'linux') {
+    installSystemd(port);
+  } else if (platform === 'win32') {
+    installWindowsTask(port);
+  } else {
+    console.log(chalk.yellow(`⚠ Background service installation not supported on ${platform}.`));
+  }
+}
+
+export function uninstallService(): void {
+  const platform = process.platform;
+  if (platform === 'darwin') {
+    uninstallLaunchd();
+  } else if (platform === 'linux') {
+    uninstallSystemd();
+  } else if (platform === 'win32') {
+    uninstallWindowsTask();
+  } else {
+    console.log(chalk.yellow(`⚠ Background service uninstallation not supported on ${platform}.`));
+  }
+}
+
+// Backward-compatible exports for existing callers
+export const installLaunchdAgent = installService;
+export const uninstallLaunchdAgent = uninstallService;
+
+function installLaunchd(port: number): void {
   const nodePath = process.execPath;
   const scriptPath = path.resolve(process.argv[1]);
 
@@ -16,7 +49,7 @@ export function installLaunchdAgent(port: number = 3000): void {
 <plist version="1.0">
 <dict>
     <key>Label</key>
-    <string>${PLIST_LABEL}</string>
+    <string>${SERVICE_LABEL}</string>
     <key>ProgramArguments</key>
     <array>
         <string>${nodePath}</string>
@@ -47,18 +80,18 @@ export function installLaunchdAgent(port: number = 3000): void {
     try {
       execSync(`launchctl unload ${PLIST_PATH} 2>/dev/null`);
     } catch {
-      // ignore if not previously loaded
+      // ignore
     }
     execSync(`launchctl load ${PLIST_PATH}`);
 
     console.log(chalk.green(`✔ Installed and started launchd agent at ${PLIST_PATH}`));
-    console.log(chalk.dim(`  Service label: ${PLIST_LABEL}`));
+    console.log(chalk.dim(`  Service label: ${SERVICE_LABEL}`));
   } catch (err: any) {
     console.log(chalk.red(`✖ Failed to install launchd agent: ${err.message}`));
   }
 }
 
-export function uninstallLaunchdAgent(): void {
+function uninstallLaunchd(): void {
   try {
     if (fs.existsSync(PLIST_PATH)) {
       try {
@@ -75,3 +108,88 @@ export function uninstallLaunchdAgent(): void {
     console.log(chalk.red(`✖ Failed to uninstall launchd agent: ${err.message}`));
   }
 }
+
+function installSystemd(port: number): void {
+  const nodePath = process.execPath;
+  const scriptPath = path.resolve(process.argv[1]);
+  const logDir = path.join(os.homedir(), '.config', 'pyre');
+  if (!fs.existsSync(logDir)) fs.mkdirSync(logDir, { recursive: true });
+  if (!fs.existsSync(SYSTEMD_USER_DIR)) fs.mkdirSync(SYSTEMD_USER_DIR, { recursive: true });
+
+  const unitContent = `[Unit]
+Description=Pyre System Monitor Web Service
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${nodePath} "${scriptPath}" web --port ${port}
+Restart=always
+RestartSec=5
+StandardOutput=append:${path.join(logDir, 'web.log')}
+StandardError=append:${path.join(logDir, 'web.err')}
+
+[Install]
+WantedBy=default.target
+`;
+
+  try {
+    fs.writeFileSync(SYSTEMD_UNIT_PATH, unitContent);
+    try {
+      execSync('systemctl --user daemon-reload');
+      execSync('systemctl --user enable --now pyre-web.service');
+    } catch (cmdErr: any) {
+      console.log(chalk.yellow(`  Unit file written to ${SYSTEMD_UNIT_PATH}, but could not auto-enable: ${cmdErr.message}`));
+      console.log(chalk.dim('  You can manually enable it using: systemctl --user enable --now pyre-web.service'));
+      return;
+    }
+    console.log(chalk.green(`✔ Installed and started systemd user service at ${SYSTEMD_UNIT_PATH}`));
+    console.log(chalk.dim('  Service name: pyre-web.service'));
+  } catch (err: any) {
+    console.log(chalk.red(`✖ Failed to install systemd user service: ${err.message}`));
+  }
+}
+
+function uninstallSystemd(): void {
+  try {
+    if (fs.existsSync(SYSTEMD_UNIT_PATH)) {
+      try {
+        execSync('systemctl --user disable --now pyre-web.service 2>/dev/null');
+      } catch {
+        // ignore
+      }
+      fs.unlinkSync(SYSTEMD_UNIT_PATH);
+      try {
+        execSync('systemctl --user daemon-reload 2>/dev/null');
+      } catch {
+        // ignore
+      }
+      console.log(chalk.green(`✔ Uninstalled systemd user service ${SYSTEMD_UNIT_PATH}`));
+    } else {
+      console.log(chalk.yellow(`  No systemd service found at ${SYSTEMD_UNIT_PATH}`));
+    }
+  } catch (err: any) {
+    console.log(chalk.red(`✖ Failed to uninstall systemd service: ${err.message}`));
+  }
+}
+
+function installWindowsTask(port: number): void {
+  const nodePath = process.execPath;
+  const scriptPath = path.resolve(process.argv[1]);
+  try {
+    const cmd = `schtasks /create /tn "${TASK_NAME}" /tr "\\"${nodePath}\\" \\"${scriptPath}\\" web --port ${port}" /sc onlogon /f`;
+    execSync(cmd, { stdio: 'pipe' });
+    console.log(chalk.green(`✔ Installed Windows scheduled task '${TASK_NAME}' (runs on logon)`));
+  } catch (err: any) {
+    console.log(chalk.red(`✖ Failed to register Windows scheduled task: ${err.message}`));
+  }
+}
+
+function uninstallWindowsTask(): void {
+  try {
+    const cmd = `schtasks /delete /tn "${TASK_NAME}" /f`;
+    execSync(cmd, { stdio: 'pipe' });
+    console.log(chalk.green(`✔ Uninstalled Windows scheduled task '${TASK_NAME}'`));
+  } catch (err: any) {
+    console.log(chalk.yellow(`  No scheduled task '${TASK_NAME}' found or deletion failed: ${err.message}`));
+  }
+}