pyre-cli 6.0.0 → 7.0.0

package/src/live/render.ts

@@ -6,7 +6,7 @@
  * alert checker.  All state variables are imported from
  * `state.ts`.
  */
-import { execFile } from 'node:child_process';
+import { execFile, exec } from 'node:child_process';
 import chalk from 'chalk';
 import { formatTable, formatGraphs, gridColumns, THEMES, type ThemeName, panel, fitVisible } from '../formatters/index.js';
 import { detectAnomalies } from '../anomalies.js';
@@ -54,6 +54,7 @@ function tableCacheParams(): string {
     state.treeView ? '1' : '0',
     state.history.version,
     JSON.stringify(state.visiblePanels),
+    JSON.stringify(state.panelLayout),
   ].join('|');
 }
 
@@ -107,42 +108,45 @@ function p2pPanelLines(): { title: string; body: string[] } {
   return { title, body };
 }
 
-function renderCustomizerOverlay(): string {
-   const themesList = Object.keys(THEMES) as ThemeName[];
-   const lines = [
-     chalk.bgCyan.black.bold(' UI CUSTOMIZER (Use ↑/↓ or J/K to navigate, Enter/Space to toggle, Esc to exit) '),
-   ];
-
-     state.CUSTOMIZER_OPTIONS.forEach((opt, idx) => {
-       const isSelected = idx === state.customizerIndex;
-       const prefix = isSelected ? chalk.yellow('▶ ') : '  ';
-
-        if (opt === 'Theme') {
-          lines.push(`${prefix}${opt}: ${chalk.bold.green(state.currentTheme)} [${themesList.join(', ')}]`);
-        } else if (opt === 'Graph Mode') {
-          lines.push(`${prefix}${opt}: ${chalk.bold.green(state.graphMode)} [spark, bar]`);
-        } else if (opt === 'Splash Screen') {
-          const status = state.splashEnabled ? chalk.green('[ON]') : chalk.red('[OFF]');
-          lines.push(`${prefix}${opt}: ${status}`);
-        } else if (opt === 'Splash Color') {
-          lines.push(`${prefix}${opt}: ${chalk.bold.green(state.splashColorScheme)} [fire, ocean, forest, purple, monochrome]`);
-        } else if (opt === 'Splash Animation') {
-          lines.push(`${prefix}${opt}: ${chalk.bold.green(state.splashAnimation)} [classic, wave, sparks]`);
-        } else if (opt === 'Notifications') {
-          const status = state.notificationsEnabled ? chalk.green('[ON]') : chalk.red('[OFF]');
-          lines.push(`${prefix}${opt}: ${status}`);
-        } else if (opt === 'Temperature Unit') {
-          lines.push(`${prefix}${opt}: ${chalk.bold.green(state.tempUnit.toUpperCase())} [C, F]`);
-        } else {
-          const toggleKey = getToggleKey(opt);
-          const isVisible = toggleKey ? (toggleKey === 'tree' ? state.treeView : state.visiblePanels[toggleKey] !== false) : true;
-          const status = isVisible ? chalk.green('[VISIBLE]') : chalk.red('[HIDDEN]');
-          lines.push(`${prefix}${opt}: ${status}`);
-        }
-     });
+function renderCustomizerOverlay(scrollOffset: number, maxVisibleItems: number): string {
+    const themesList = Object.keys(THEMES) as ThemeName[];
+    const headerLine = chalk.bgCyan.black.bold(' UI CUSTOMIZER (Use ↑/↓ or J/K to navigate, Enter/Space to toggle, Esc to exit) ');
+    const totalItems = state.CUSTOMIZER_OPTIONS.length;
+    const end = Math.min(scrollOffset + maxVisibleItems, totalItems);
+
+    const lines = [headerLine];
+
+    for (let i = scrollOffset; i < end; i++) {
+      const opt = state.CUSTOMIZER_OPTIONS[i];
+      const isSelected = i === state.customizerIndex;
+      const prefix = isSelected ? chalk.yellow('▶ ') : '  ';
+
+       if (opt === 'Theme') {
+         lines.push(`${prefix}${opt}: ${chalk.bold.green(state.currentTheme)} [${themesList.join(', ')}]`);
+       } else if (opt === 'Graph Mode') {
+         lines.push(`${prefix}${opt}: ${chalk.bold.green(state.graphMode)} [spark, bar]`);
+       } else if (opt === 'Splash Screen') {
+         const status = state.splashEnabled ? chalk.green('[ON]') : chalk.red('[OFF]');
+         lines.push(`${prefix}${opt}: ${status}`);
+       } else if (opt === 'Splash Color') {
+         lines.push(`${prefix}${opt}: ${chalk.bold.green(state.splashColorScheme)} [fire, ocean, forest, purple, monochrome]`);
+       } else if (opt === 'Splash Animation') {
+         lines.push(`${prefix}${opt}: ${chalk.bold.green(state.splashAnimation)} [classic, wave, sparks]`);
+       } else if (opt === 'Notifications') {
+         const status = state.notificationsEnabled ? chalk.green('[ON]') : chalk.red('[OFF]');
+         lines.push(`${prefix}${opt}: ${status}`);
+       } else if (opt === 'Temperature Unit') {
+         lines.push(`${prefix}${opt}: ${chalk.bold.green(state.tempUnit.toUpperCase())} [C, F]`);
+       } else {
+         const toggleKey = getToggleKey(opt);
+         const isVisible = toggleKey ? (toggleKey === 'tree' ? state.treeView : state.visiblePanels[toggleKey] !== false) : true;
+         const status = isVisible ? chalk.green('[VISIBLE]') : chalk.red('[HIDDEN]');
+         lines.push(`${prefix}${opt}: ${status}`);
+       }
+    }
 
    return lines.map(l => `  ${l}`).join('\n');
- }
+  }
 
 // --- frame diffing -------------------------------------------------------
 // Instead of erasing the whole screen (`\x1b[2J`) and repainting everything
@@ -212,10 +216,12 @@ function render() {
             visible: state.visiblePanels,
             treeView: state.treeView,
             activePanel: state.activePanel,
-            anomalies,
+            anomalies: anomalies,
+            anomalyHistory: state.anomalyHistory,
             tempUnit: state.tempUnit,
             history: state.history,
             graphMode: state.graphMode,
+            panelLayout: state.panelLayout,
           });
           _cachedTableData = state.lastData;
           _cachedTableParams = cacheParams;
@@ -255,27 +261,38 @@ function render() {
   const footerLine3 = footerLine()[2] || ' ';
   const footerLines = [footerLine1, footerLine2, footerLine3];
 
-  if (state.inputMode === 'customizer') {
-     bodyLines.push('');
-     bodyLines.push(...renderCustomizerOverlay().split('\n'));
-   } else if (state.inputMode === 'filter') {
-     bodyLines.push(chalk.cyan(`  Filter processes: ${state.inputBuffer}_`));
-   } else if (state.inputMode === 'kill') {
-     bodyLines.push(chalk.cyan(`  Kill PID: ${state.inputBuffer}_  (enter to confirm, esc to cancel)`));
-   } else if (state.inputMode === 'signal') {
-     const sigIdx = state.SIGNAL_OPTIONS.indexOf(state.inputBuffer as typeof state.SIGNAL_OPTIONS[number]);
-     const sigList = state.SIGNAL_OPTIONS.map((s, i) => i === sigIdx ? chalk.yellow(s) : chalk.dim(s)).join('  ');
-     bodyLines.push(chalk.cyan(`  Signal: ${state.inputBuffer}_`));
-     bodyLines.push(chalk.dim(`  ${sigList}`));
-     bodyLines.push(chalk.dim('  ↑/↓ to select, Enter to confirm, Esc to cancel'));
-   } else if (state.inputMode === 'p2p') {
-     bodyLines.push(chalk.cyan(`  P2P password (${state.p2pPort}): ${state.inputBuffer}_  (enter to start, esc to cancel)`));
-   } else if (state.statusMessage) {
-     bodyLines.push(`  ${state.statusMessage}`);
-   }
-
   const footerHeight = 3;
   const targetBodyHeight = Math.max(1, state.termHeight - footerHeight);
+
+  if (state.inputMode === 'customizer') {
+    const preOverlayCount = bodyLines.length;
+    const availableForOverlay = targetBodyHeight - preOverlayCount;
+    const totalItems = state.CUSTOMIZER_OPTIONS.length;
+    const headerLines = 1;
+    const blankLines = availableForOverlay >= 2 ? 1 : 0;
+    const maxVisibleItems = Math.max(0, availableForOverlay - headerLines - blankLines);
+    const scrollOffset = totalItems > maxVisibleItems
+      ? Math.max(0, Math.min(state.customizerIndex, totalItems - maxVisibleItems))
+      : 0;
+
+    if (blankLines > 0) bodyLines.push('');
+    bodyLines.push(...renderCustomizerOverlay(scrollOffset, maxVisibleItems).split('\n'));
+  } else if (state.inputMode === 'filter') {
+    bodyLines.push(chalk.cyan(`  Filter processes: ${state.inputBuffer}_`));
+  } else if (state.inputMode === 'kill') {
+    bodyLines.push(chalk.cyan(`  Kill PID: ${state.inputBuffer}_  (enter to confirm, esc to cancel)`));
+  } else if (state.inputMode === 'signal') {
+    const sigIdx = state.SIGNAL_OPTIONS.indexOf(state.inputBuffer as typeof state.SIGNAL_OPTIONS[number]);
+    const sigList = state.SIGNAL_OPTIONS.map((s, i) => i === sigIdx ? chalk.yellow(s) : chalk.dim(s)).join('  ');
+    bodyLines.push(chalk.cyan(`  Signal: ${state.inputBuffer}_`));
+    bodyLines.push(chalk.dim(`  ${sigList}`));
+    bodyLines.push(chalk.dim('  ↑/↓ to select, Enter to confirm, Esc to cancel'));
+  } else if (state.inputMode === 'p2p') {
+    bodyLines.push(chalk.cyan(`  P2P password (${state.p2pPort}): ${state.inputBuffer}_  (enter to start, esc to cancel)`));
+  } else if (state.statusMessage) {
+    bodyLines.push(`  ${state.statusMessage}`);
+  }
+
   if (bodyLines.length > targetBodyHeight) {
     bodyLines.length = targetBodyHeight;
   }
@@ -339,22 +356,60 @@ function checkAlerts(data: StatsData) {
    const temp = data.cpu.temperature ?? data.thermal.temperatures?.cpu_die ?? null;
    const hot = data.cpu.usage >= state.CPU_ALERT_PCT || (temp !== null && temp >= state.TEMP_ALERT_C);
    const anomalies = detectAnomalies(data, state.history);
+   
+   // Add timestamp to anomalies and push to history
+   for (const a of anomalies) {
+     const timestamped = { ...a, timestamp: new Date() };
+     // Only add if not already recently reported (same metric and similar zScore)
+     const recent = state.anomalyHistory.slice(-5);
+     const isDuplicate = recent.some(r => r.metric === a.metric && Math.abs(r.zScore - a.zScore) < 0.5);
+     if (!isDuplicate) {
+       state.anomalyHistory.push(timestamped as any);
+       if (state.anomalyHistory.length > 50) state.anomalyHistory.shift();
+     }
+   }
+
    const hasCriticalAnomaly = anomalies.some(a => a.severity === 'critical');
    const hasWarningAnomaly = anomalies.some(a => a.severity === 'warning');
+   // Process watchdog check
+   let watchdogTriggered = false;
+   if (state.watchdogProcess) {
+     const matches = data.processes.filter(p => p.command.toLowerCase().includes(state.watchdogProcess.toLowerCase()));
+     for (const p of matches) {
+       if (p.cpu >= state.watchdogCpu || p.mem >= state.watchdogMem) {
+         watchdogTriggered = true;
+         break;
+       }
+     }
+   }
+
    const anomalyTriggered = hasCriticalAnomaly || hasWarningAnomaly;
 
-   if ((hot || anomalyTriggered) && !state.alerted) {
+   if ((hot || anomalyTriggered || watchdogTriggered) && !state.alerted) {
      state.alerted = true;
      process.stdout.write('\x07');
      const reasons: string[] = [];
      if (data.cpu.usage >= state.CPU_ALERT_PCT) reasons.push(`CPU at ${data.cpu.usage}%`);
      if (temp !== null && temp >= state.TEMP_ALERT_C) reasons.push(`Temp at ${formatTempForUnit(temp)}`);
+     if (watchdogTriggered) reasons.push(`Watchdog process "${state.watchdogProcess}" crossed threshold`);
      for (const a of anomalies) {
        reasons.push(`${a.metric} anomaly (σ=${a.zScore.toFixed(1)})`);
      }
       setStatus(chalk.red(`⚠ Alert: ${reasons.join('; ')}`), 5000);
       sendNotification('pyre Alert', reasons.join('; '));
-    } else if (!hot && !anomalyTriggered) {
+      
+      const alertMsg = reasons.join('; ');
+      if (state.webhookUrl) {
+        fetch(state.webhookUrl, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ alert: alertMsg, timestamp: new Date().toISOString() })
+        }).catch(() => {});
+      }
+      if (state.alertCmd) {
+        exec(state.alertCmd, { env: { ...process.env, PYRE_ALERT: alertMsg } }, () => {});
+      }
+    } else if (!hot && !anomalyTriggered && !watchdogTriggered) {
      state.alerted = false;
    }
   }

package/src/live/state.ts

@@ -48,6 +48,7 @@ const state = {
        disk: config.visiblePanels.disk,
        process: config.visiblePanels.process,
      } as VisibleItems,
+     panelLayout: config.panelLayout || ['mem', 'disk', 'net'],
     logging: false,
     logStream: null as fs.WriteStream | null,
     statusMessage: '',
@@ -89,9 +90,14 @@ const state = {
      ],
      CPU_ALERT_PCT: config.cpuAlertPct,
      TEMP_ALERT_C: config.tempAlertC,
+     watchdogProcess: config.watchdogProcess || '',
+     watchdogCpu: config.watchdogCpu || 80,
+     watchdogMem: config.watchdogMem || 80,
      notificationsEnabled: config.notificationsEnabled,
+     webhookUrl: config.webhookUrl || '',
+     alertCmd: config.alertCmd || '',
       alerted: false,
-      activePanel: 'grid' as 'grid' | 'cpu' | 'mem' | 'gpu' | 'power' | 'battery' | 'thermal' | 'network' | 'packets' | 'tasks' | 'disk' | 'process' | 'p2p',
+      activePanel: 'grid' as 'grid' | 'cpu' | 'mem' | 'gpu' | 'power' | 'battery' | 'thermal' | 'network' | 'packets' | 'tasks' | 'disk' | 'process' | 'p2p' | 'anomalies',
        mouseEnabled: config.mouseEnabled,
          PANEL_TABS: [
            { id: 'cpu', label: 'CPU', key: '1' },
@@ -106,13 +112,17 @@ const state = {
            { id: 'disk', label: 'Disk', key: '0' },
            { id: 'process', label: 'Process', key: 'P' },
            { id: 'p2p', label: 'P2P', key: 'R' },
-         ] as const,
-        p2pEvents: [] as { type: string; detail: string; ts: number }[],
-        p2pBind: '',
-        p2pServer: null as { stop: () => void; peerEventHistory: { type: string; detail: string; ts: number }[] } | null,
-        p2pServerRunning: false,
-        p2pPort: config.p2pPort,
-        p2pPassword: config.p2pPassword,
+           { id: 'anomalies', label: 'Anomalies', key: 'A' },
+         ],
+         p2pServer: null as import('../p2p/server.js').P2PServer | null,
+         p2pClient: null as import('../p2p/client.js').P2PClient | null,
+         p2pServerRunning: false,
+         p2pClientConnected: false,
+         p2pEvents: [] as any[],
+         p2pBind: '',
+         p2pPassword: config.p2pPassword,
+         p2pPort: config.p2pPort,
+         anomalyHistory: [] as import('../anomalies.js').AnomalyAlert[],
         splashEnabled: config.splashEnabled,
         splashColorScheme: config.splashColorScheme as SplashColorScheme,
         splashAnimation: config.splashAnimation as SplashAnimation,

package/src/monitors/collectors.ts

@@ -504,9 +504,46 @@ export async function collectMemory(): Promise<MemoryData> {
   };
 }
 
+let prevDiskIoSample: { ts: number } | null = null;
+let cachedDiskIo: { readBytesSec: number; writeBytesSec: number; ts: number } | null = null;
+
+async function getDiskIoRates(): Promise<{ readBytesSec: number; writeBytesSec: number }> {
+  const now = Date.now();
+  if (cachedDiskIo && now - cachedDiskIo.ts < 1000) {
+    return { readBytesSec: cachedDiskIo.readBytesSec, writeBytesSec: cachedDiskIo.writeBytesSec };
+  }
+  try {
+    const raw = (await run('iostat -d -c 2 1 2', '')).trim();
+    const blocks = raw.split(/\n\s*\n/).filter(Boolean);
+    const targetBlock = blocks.length > 1 ? blocks[1] : blocks[0];
+    if (targetBlock) {
+      const lines = targetBlock.trim().split('\n');
+      if (lines.length >= 2) {
+        const dataLine = lines[lines.length - 1].trim();
+        const parts = dataLine.split(/\s+/);
+        if (parts.length >= 3) {
+          const mbSec = parseFloat(parts[2]);
+          if (!isNaN(mbSec)) {
+            const bytesSec = Math.round(mbSec * 1024 * 1024);
+            // Splitting combined throughput evenly/estimating if read/write distinction unavailable directly from summary iostat
+            cachedDiskIo = { readBytesSec: Math.round(bytesSec * 0.6), writeBytesSec: Math.round(bytesSec * 0.4), ts: now };
+            return { readBytesSec: cachedDiskIo.readBytesSec, writeBytesSec: cachedDiskIo.writeBytesSec };
+          }
+        }
+      }
+    }
+  } catch {
+    // ignore
+  }
+  return { readBytesSec: 0, writeBytesSec: 0 };
+}
+
 export async function collectDisk(): Promise<DiskData[]> {
-  const raw = (await run('df -h')).trim();
-  const lines = raw.split('\n').slice(1);
+  const [rawDf, ioRates] = await Promise.all([
+    run('df -h'),
+    getDiskIoRates(),
+  ]);
+  const lines = rawDf.trim().split('\n').slice(1);
   return lines
     .map(line => {
       const parts = line.split(/\s+/);
@@ -517,6 +554,8 @@ export async function collectDisk(): Promise<DiskData[]> {
         available: parts[3],
         capacity: parts[4],
         mountpoint: parts[5] || parts[6] || '/',
+        readBytesSec: ioRates.readBytesSec,
+        writeBytesSec: ioRates.writeBytesSec,
       };
     })
     .filter(d => d.filesystem.includes('/') || d.size.includes('G') || d.size.includes('T'));

package/src/monitors/types.ts

@@ -112,6 +112,8 @@ export interface DiskData {
   available: string;
   capacity: string;
   mountpoint: string;
+  readBytesSec?: number;
+  writeBytesSec?: number;
 }
 
 export interface NetworkData {

package/src/state/config.ts

@@ -34,7 +34,11 @@ export interface PyreConfig {
   p2pPassword?: string;
   splashEnabled?: boolean;
   splashColorScheme?: string;
-  splashAnimation?: string;
+  watchdogProcess?: string;
+  watchdogCpu?: number;
+  watchdogMem?: number;
+  webhookUrl?: string;
+  alertCmd?: string;
   visiblePanels?: {
     cpu?: boolean;
     mem?: boolean;
@@ -49,6 +53,7 @@ export interface PyreConfig {
     process?: boolean;
     tree?: boolean;
   };
+  panelLayout?: string[];
 }
 
 export const DEFAULT_CONFIG: Required<PyreConfig> = {
@@ -64,12 +69,17 @@ export const DEFAULT_CONFIG: Required<PyreConfig> = {
   mouseEnabled: true,
   cpuAlertPct: 90,
   tempAlertC: 95,
+  watchdogProcess: '',
+  watchdogCpu: 80,
+  watchdogMem: 80,
   notificationsEnabled: true,
   p2pPort: 9876,
   p2pPassword: 'pyre',
   splashEnabled: true,
   splashColorScheme: 'fire',
   splashAnimation: 'classic',
+  webhookUrl: '',
+  alertCmd: '',
   visiblePanels: {
     cpu: true,
     mem: true,
@@ -84,6 +94,7 @@ export const DEFAULT_CONFIG: Required<PyreConfig> = {
     process: true,
     tree: false,
   },
+  panelLayout: ['mem', 'disk', 'net'],
 };
 
 export function readConfig(): Required<PyreConfig> {

package/src/xbar.ts

@@ -0,0 +1,53 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import chalk from 'chalk';
+
+export function generateXbarPlugin() {
+  const pyrePath = process.argv[1];
+  const nodePath = process.execPath;
+  
+  const script = `#!/bin/bash
+# <xbar.title>Pyre Monitor</xbar.title>
+# <xbar.version>v1.0</xbar.version>
+# <xbar.author>somalip</xbar.author>
+# <xbar.author.github>somalip</xbar.author.github>
+# <xbar.desc>Mac system monitoring powered by pyre.</xbar.desc>
+
+# Run pyre to get a JSON snapshot
+# We use node directly to avoid env issues in xbar
+DATA=$("${nodePath}" "${pyrePath}" --once --json)
+
+if [ -z "$DATA" ]; then
+  echo "🔥 err"
+  echo "---"
+  echo "Could not fetch data"
+  exit 1
+fi
+
+CPU=$(echo "$DATA" | grep -o '"usage": *[0-9.]*' | head -1 | awk '{print $2}')
+MEM=$(echo "$DATA" | grep -o '"usagePercent": *[0-9.]*' | head -1 | awk '{print $2}')
+TEMP=$(echo "$DATA" | grep -o '"temperature": *[0-9.]*' | head -1 | awk '{print $2}')
+
+# Format to 1 decimal place
+CPU=$(printf "%.1f" "$CPU")
+MEM=$(printf "%.1f" "$MEM")
+TEMP=$(printf "%.1f" "$TEMP")
+
+echo "🔥 C:\${CPU}% M:\${MEM}% T:\${TEMP}°C | font=Menlo"
+echo "---"
+echo "Open Dashboard | bash='${nodePath}' param1='${pyrePath}' param2='live' terminal=true"
+`;
+
+  const pluginDir = path.join(os.homedir(), 'Library', 'Application Support', 'xbar', 'plugins');
+  const filename = 'pyre-monitor.2s.sh';
+  const outPath = path.join(process.cwd(), filename);
+  
+  fs.writeFileSync(outPath, script);
+  fs.chmodSync(outPath, '755');
+  
+  console.log(chalk.green(`Generated xbar plugin script at ${outPath}`));
+  console.log(`To install, move it to your xbar plugins directory:`);
+  console.log(chalk.cyan(`  mv ${filename} "${pluginDir}/"`));
+  console.log(`Then refresh xbar.`);
+}