pyre-cli 9.5.2 → 10.0.0

package/src/watchdogCmd.ts

@@ -0,0 +1,198 @@
+/**
+ * pyre watchdog — Persistent Autonomous Rules Engine.
+ *
+ * Evaluates configurable metric threshold and process rules continuously,
+ * executing remediation actions (kill, renice) and dispatching multi-channel alerts.
+ *
+ * Example watchdog configuration rule:
+ * {
+ *   "name": "Stop runaway background renderers",
+ *   "metric": "cpu",
+ *   "process": "photoanalysisd",
+ *   "threshold": 80,
+ *   "durationSec": 10,
+ *   "action": "kill", // "kill" | "notify" | "alert"
+ *   "cooldownSec": 60
+ * }
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import chalk from 'chalk';
+import { collectAll } from './monitors/collectors.js';
+import { sendAlert } from './alertChannels.js';
+import { getConfigDir, readConfig } from './state/config.js';
+
+export interface WatchdogRule {
+  name: string;
+  metric?: 'cpu' | 'mem' | 'temp' | 'process_cpu' | 'process_mem';
+  process?: string;
+  threshold: number;
+  durationSec?: number;
+  action: 'kill' | 'notify' | 'alert';
+  cooldownSec?: number;
+}
+
+export interface WatchdogOptions {
+  configFile?: string;
+  dryRun?: boolean;
+  interval?: number;
+}
+
+const DEFAULT_WATCHDOG_RULES: WatchdogRule[] = [
+  {
+    name: 'High CPU System Alert',
+    metric: 'cpu',
+    threshold: 92,
+    durationSec: 5,
+    action: 'alert',
+    cooldownSec: 120,
+  },
+  {
+    name: 'Critical Temperature Protection',
+    metric: 'temp',
+    threshold: 98,
+    durationSec: 5,
+    action: 'alert',
+    cooldownSec: 180,
+  },
+];
+
+export async function runWatchdogCommand(opts: WatchdogOptions = {}): Promise<void> {
+  const configDir = getConfigDir();
+  const defaultRulePath = path.join(configDir, 'watchdog.json');
+  const rulePath = opts.configFile || defaultRulePath;
+  const intervalSec = opts.interval || 2;
+  const isDryRun = !!opts.dryRun;
+
+  let rules: WatchdogRule[] = DEFAULT_WATCHDOG_RULES;
+
+  if (fs.existsSync(rulePath)) {
+    try {
+      rules = JSON.parse(fs.readFileSync(rulePath, 'utf-8'));
+    } catch (err: any) {
+      console.error(chalk.yellow(`  ⚠ Could not parse watchdog config at ${rulePath}: ${err.message}. Using default rules.`));
+    }
+  } else if (!opts.configFile) {
+    try {
+      if (!fs.existsSync(configDir)) fs.mkdirSync(configDir, { recursive: true });
+      fs.writeFileSync(defaultRulePath, JSON.stringify(DEFAULT_WATCHDOG_RULES, null, 2));
+    } catch {
+      // ignore
+    }
+  }
+
+  console.log(chalk.bold('\n  🔥 pyre watchdog — Autonomous Monitoring Daemon\n'));
+  console.log(`  ${chalk.green('✔')} Loaded ${chalk.bold(String(rules.length))} rule(s) from ${chalk.cyan(rulePath)}`);
+  console.log(`  ${chalk.green('✔')} Refresh interval: ${intervalSec}s  |  Dry run mode: ${isDryRun ? chalk.yellow('ON') : chalk.dim('OFF')}`);
+  console.log(`\n  ${chalk.dim('Active Rules:')}`);
+  for (const r of rules) {
+    const target = r.process ? `proc "${r.process}"` : r.metric || 'system';
+    console.log(`    • ${chalk.bold(r.name)} [if ${target} > ${r.threshold} → ${chalk.cyan(r.action)}]`);
+  }
+  console.log(chalk.dim('\n  Watching... Press Ctrl+C to stop.\n'));
+
+  // Track rule trigger history for cooldowns
+  const lastTriggered = new Map<string, number>();
+
+  const config = readConfig();
+  const alertChannels = {
+    slackUrl: config.slackAlertUrl,
+    discordUrl: config.discordAlertUrl,
+    pushoverToken: config.pushoverToken,
+    pushoverUser: config.pushoverUser,
+    ntfyUrl: config.ntfyUrl,
+  };
+
+  const evaluate = async () => {
+    try {
+      const data = await collectAll();
+      const now = Date.now();
+
+      for (const rule of rules) {
+        const cooldown = (rule.cooldownSec || 60) * 1000;
+        const last = lastTriggered.get(rule.name) || 0;
+        if (now - last < cooldown) continue;
+
+        let triggered = false;
+        let detail = '';
+        let targetPid: number | null = null;
+
+        if (rule.process) {
+          const match = data.processes.find(p => p.command.toLowerCase().includes(rule.process!.toLowerCase()));
+          if (match) {
+            const val = rule.metric === 'process_mem' ? match.mem : match.cpu;
+            if (val >= rule.threshold) {
+              triggered = true;
+              targetPid = match.pid;
+              detail = `Process "${match.command}" (PID ${match.pid}) at ${val.toFixed(1)}% (threshold ${rule.threshold}%)`;
+            }
+          }
+        } else if (rule.metric === 'cpu') {
+          if (data.cpu.usage >= rule.threshold) {
+            triggered = true;
+            detail = `System CPU usage at ${data.cpu.usage.toFixed(1)}% (threshold ${rule.threshold}%)`;
+          }
+        } else if (rule.metric === 'mem') {
+          if (data.memory.usagePercent >= rule.threshold) {
+            triggered = true;
+            detail = `System Memory at ${data.memory.usagePercent.toFixed(1)}% (threshold ${rule.threshold}%)`;
+          }
+        } else if (rule.metric === 'temp') {
+          const temp = data.cpu.temperature ?? data.thermal.temperatures?.cpu_die;
+          if (temp !== undefined && temp >= rule.threshold) {
+            triggered = true;
+            detail = `System Temperature at ${temp.toFixed(1)}°C (threshold ${rule.threshold}°C)`;
+          }
+        }
+
+        if (triggered) {
+          lastTriggered.set(rule.name, now);
+          const timeStr = new Date().toLocaleTimeString();
+          console.log(`  [${chalk.dim(timeStr)}] ${chalk.red.bold('⚠ TRIGGERED:')} ${chalk.bold(rule.name)}: ${detail}`);
+
+          if (isDryRun) {
+            console.log(chalk.yellow(`    [DRY RUN] Would execute action: ${rule.action}`));
+            continue;
+          }
+
+          if (rule.action === 'kill' && targetPid) {
+            try {
+              process.kill(targetPid, 'SIGTERM');
+              console.log(chalk.green(`    ✔ Killed PID ${targetPid} with SIGTERM`));
+            } catch (err: any) {
+              console.log(chalk.red(`    ✖ Failed to kill PID ${targetPid}: ${err.message}`));
+            }
+          }
+
+          if (rule.action === 'alert') {
+            await sendAlert({
+              metric: rule.name,
+              value: rule.threshold,
+              threshold: rule.threshold,
+              unit: '%',
+              host: data.header.hostname,
+              timestamp: new Date().toISOString(),
+              severity: 'critical',
+            }, alertChannels).catch(() => {});
+            console.log(chalk.green('    ✔ Multi-channel alert dispatched.'));
+          }
+        }
+      }
+    } catch {
+      // ignore loop error
+    }
+  };
+
+  await evaluate();
+  const handle = setInterval(evaluate, intervalSec * 1000);
+
+  // Keep alive until SIGINT
+  await new Promise<void>((resolve) => {
+    process.on('SIGINT', () => {
+      clearInterval(handle);
+      console.log(chalk.dim('\n  Watchdog stopped.'));
+      resolve();
+      process.exit(0);
+    });
+  });
+}

package/src/xbar.ts

@@ -6,16 +6,15 @@ 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>
+# <xbar.desc>Cross-platform 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
@@ -39,15 +38,27 @@ 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.`);
+  try {
+    fs.chmodSync(outPath, 0o755);
+  } catch {
+    // ignore on non-POSIX filesystems
+  }
+
+  console.log(chalk.green(`Generated menu bar plugin script at ${outPath}`));
+
+  if (process.platform === 'darwin') {
+    const pluginDir = path.join(os.homedir(), 'Library', 'Application Support', 'xbar', 'plugins');
+    console.log(`To install in xbar or SwiftBar on macOS:`);
+    console.log(chalk.cyan(`  mv ${filename} "${pluginDir}/"`));
+  } else if (process.platform === 'linux') {
+    const argosDir = path.join(os.homedir(), '.config', 'argos');
+    console.log(`To install in Argos (GNOME Shell) on Linux:`);
+    console.log(chalk.cyan(`  mkdir -p "${argosDir}" && mv ${filename} "${argosDir}/"`));
+  } else {
+    console.log(chalk.dim(`Compatible with BitBar, xbar, and Argos shell plugins.`));
+  }
 }

package/dist/brewHealth-F2BXF5M6.js

@@ -1,74 +0,0 @@
-import {
-  run
-} from "./chunk-FH5WDJBF.js";
-
-// src/brewHealth.ts
-import chalk from "chalk";
-async function getBrewHealth() {
-  try {
-    const brewPath = await run("which brew 2>&1", "");
-    if (!brewPath.trim() || brewPath.includes("not found")) {
-      return { installedCount: 0, outdatedCount: 0, cellarSize: "N/A", doctorWarnings: [], brewAvailable: false };
-    }
-    const outdatedRaw = await run("brew outdated --quiet 2>&1", "");
-    const outdatedLines = outdatedRaw.trim().split("\n").filter((l) => l.length > 0 && !l.startsWith("Homebrew") && !l.startsWith("==>"));
-    const listRaw = await run("brew list --formula -1 2>&1", "");
-    const listLines = listRaw.trim().split("\n").filter((l) => l.length > 0);
-    let cellarSize = "N/A";
-    try {
-      const cellarPath = await run("brew --cellar 2>&1", "");
-      if (cellarPath.trim()) {
-        const duRaw = await run(`du -sh "${cellarPath.trim()}" 2>&1`, "");
-        const duMatch = duRaw.match(/^([0-9\.\,]+[KMGTP]?i?B?)/i);
-        if (duMatch) cellarSize = duMatch[1];
-      }
-    } catch {
-      cellarSize = "N/A";
-    }
-    const doctorRaw = await run("brew doctor 2>&1", "");
-    const doctorWarnings = [];
-    const docLines = doctorRaw.split("\n");
-    for (const line of docLines) {
-      if (line.startsWith("Warning:")) {
-        doctorWarnings.push(line.replace(/^Warning:\s*/, "").trim());
-      }
-    }
-    return {
-      installedCount: listLines.length,
-      outdatedCount: outdatedLines.length,
-      cellarSize,
-      doctorWarnings,
-      brewAvailable: true
-    };
-  } catch (err) {
-    return { installedCount: 0, outdatedCount: 0, cellarSize: "N/A", doctorWarnings: [], brewAvailable: false };
-  }
-}
-async function printBrewHealthReport() {
-  console.log(chalk.bold("\n  pyre brew \u2014 Homebrew Health Summary\n"));
-  const health = await getBrewHealth();
-  if (!health.brewAvailable) {
-    console.log(chalk.yellow("  \u26A0 Homebrew is not installed or not available on PATH.\n"));
-    return;
-  }
-  console.log(`  \u{1F4E6} Installed Formulae: ${chalk.bold(health.installedCount)}`);
-  console.log(`  \u23F3 Outdated Packages:   ${health.outdatedCount > 0 ? chalk.yellow.bold(health.outdatedCount) : chalk.green("0 (Up to date)")}`);
-  console.log(`  \u{1F4BE} Cellar Disk Usage:  ${chalk.bold(health.cellarSize)}`);
-  console.log();
-  if (health.doctorWarnings.length === 0) {
-    console.log(chalk.green("  \u2714 brew doctor: No warnings detected system-wide."));
-  } else {
-    console.log(chalk.yellow(`  \u26A0 brew doctor warnings (${health.doctorWarnings.length}):`));
-    for (const warn of health.doctorWarnings.slice(0, 5)) {
-      console.log(chalk.dim(`     \u2022 ${warn}`));
-    }
-    if (health.doctorWarnings.length > 5) {
-      console.log(chalk.dim(`     ... and ${health.doctorWarnings.length - 5} more.`));
-    }
-  }
-  console.log();
-}
-export {
-  getBrewHealth,
-  printBrewHealthReport
-};

package/dist/chunk-FH5WDJBF.js

@@ -1,15 +0,0 @@
-// src/monitors/run.ts
-import { exec } from "child_process";
-import { promisify } from "util";
-var execAsync = promisify(exec);
-async function run(cmd, fallback = "", timeout = 3e3) {
-  try {
-    return (await execAsync(cmd, { encoding: "utf8", timeout })).stdout.trim();
-  } catch {
-    return fallback;
-  }
-}
-
-export {
-  run
-};