pyre-cli 9.5.1 → 10.0.0

package/src/topoCmd.ts

@@ -0,0 +1,176 @@
+/**
+ * pyre topo — Network Topology Mapper.
+ *
+ * Visualizes the local network topology, including default gateways,
+ * active routing paths, LAN neighbors (via ARP cache), and active remote sockets.
+ * Also scans LAN neighbors for running pyre instances (P2P port 9876, REST port 8080/3000).
+ */
+import net from 'node:net';
+import os from 'node:os';
+import chalk from 'chalk';
+import { run } from './monitors/run.js';
+import { collectNetwork } from './monitors/collectors.js';
+
+export interface TopoOptions {
+  scan?: boolean;
+  json?: boolean;
+}
+
+interface LanPeer {
+  ip: string;
+  mac: string;
+  interface: string;
+  isGateway: boolean;
+  pyreP2P?: boolean;
+  pyreRest?: boolean;
+  hostname?: string;
+}
+
+async function probePort(ip: string, port: number, timeoutMs = 400): Promise<boolean> {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    socket.setTimeout(timeoutMs);
+    socket.once('connect', () => {
+      socket.destroy();
+      resolve(true);
+    });
+    socket.once('timeout', () => {
+      socket.destroy();
+      resolve(false);
+    });
+    socket.once('error', () => {
+      socket.destroy();
+      resolve(false);
+    });
+    socket.connect(port, ip);
+  });
+}
+
+async function getDefaultGateway(): Promise<string> {
+  try {
+    const raw = await run("route -n get default 2>/dev/null | grep gateway | awk '{print $2}'", '');
+    if (raw.trim()) return raw.trim();
+  } catch {}
+  try {
+    const raw = await run("netstat -nr | grep default | awk '{print $2}' | head -n1", '');
+    if (raw.trim()) return raw.trim();
+  } catch {}
+  return '192.168.1.1';
+}
+
+async function getArpNeighbors(gatewayIp: string): Promise<LanPeer[]> {
+  const peers: LanPeer[] = [];
+  try {
+    const raw = await run('arp -a -n 2>/dev/null', '');
+    const lines = raw.split('\n');
+    for (const line of lines) {
+      // macOS format: "? (192.168.1.1) at 0:11:22:33:44:55 on en0 ifscope [ethernet]"
+      const match = line.match(/\(([\d.]+)\)\s+at\s+([0-9a-fA-F:]+)\s+on\s+(\S+)/);
+      if (match) {
+        const ip = match[1];
+        const mac = match[2];
+        const iface = match[3];
+        if (ip === '255.255.255.255' || ip.startsWith('224.') || mac.includes('incomplete')) continue;
+        peers.push({
+          ip,
+          mac,
+          interface: iface,
+          isGateway: ip === gatewayIp,
+        });
+      }
+    }
+  } catch {}
+  return peers;
+}
+
+export async function runTopoCommand(opts: TopoOptions = {}): Promise<void> {
+  const localNet = await collectNetwork();
+  const gatewayIp = await getDefaultGateway();
+  const lanPeers = await getArpNeighbors(gatewayIp);
+  const hostname = os.hostname();
+
+  // If scan is requested or small peer count, probe common pyre ports
+  if (opts.scan || lanPeers.length <= 15) {
+    await Promise.all(
+      lanPeers.map(async (peer) => {
+        const [hasP2P, hasRest] = await Promise.all([
+          probePort(peer.ip, 9876, 250),
+          probePort(peer.ip, 8080, 250),
+        ]);
+        peer.pyreP2P = hasP2P;
+        peer.pyreRest = hasRest;
+      })
+    );
+  }
+
+  const establishedConns = (localNet.topRemoteHosts || []).slice(0, 6);
+
+  if (opts.json) {
+    console.log(
+      JSON.stringify(
+        {
+          localNode: {
+            hostname,
+            ip: localNet.ip,
+            interface: localNet.interface,
+          },
+          gateway: gatewayIp,
+          lanPeers,
+          activeRemoteConnections: establishedConns,
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+
+  console.log(chalk.bold('\n  🔥 pyre topo — Network Topology Map\n'));
+
+  // Local Host Header Box
+  console.log(`  ${chalk.bgCyan.black.bold(' LOCAL HOST ')} ${chalk.bold(hostname)}`);
+  console.log(`    ├── IP Address:       ${chalk.green.bold(localNet.ip || '127.0.0.1')} (${localNet.interface})`);
+  console.log(`    ├── Active RX / TX:   ↓ ${chalk.cyan(localNet.rxBytes ? `${(localNet.rxBytes / 1e6).toFixed(1)} MB` : '0 MB')}  ↑ ${chalk.blue(localNet.txBytes ? `${(localNet.txBytes / 1e6).toFixed(1)} MB` : '0 MB')}`);
+  console.log('    │');
+
+  // Gateway Node
+  console.log(`    ├── ${chalk.yellow.bold('DEFAULT GATEWAY / ROUTER')}`);
+  console.log(`    │    └── IP: ${chalk.yellow(gatewayIp)}  [Route → WAN / Internet]`);
+  console.log('    │');
+
+  // LAN Neighborhood
+  console.log(`    ├── ${chalk.magenta.bold('LAN NEIGHBORS & PEERS')} (${lanPeers.length} discovered via ARP)`);
+  if (lanPeers.length === 0) {
+    console.log(`    │    └── ${chalk.dim('No neighboring ARP entries currently cached.')}`);
+  } else {
+    for (let i = 0; i < lanPeers.length; i++) {
+      const peer = lanPeers[i];
+      const isLast = i === lanPeers.length - 1;
+      const prefix = isLast ? '    │    └──' : '    │    ├──';
+      const gwBadge = peer.isGateway ? chalk.yellow(' [Gateway]') : '';
+      let pyreBadge = '';
+      if (peer.pyreP2P) pyreBadge += chalk.hex('#ff5500').bold(' [🔥 pyre P2P :9876]');
+      if (peer.pyreRest) pyreBadge += chalk.hex('#00ffcc').bold(' [🔥 pyre REST :8080]');
+
+      console.log(`${prefix} ${peer.ip.padEnd(16)} ${chalk.dim(peer.mac)}${gwBadge}${pyreBadge}`);
+    }
+  }
+  console.log('    │');
+
+  // Active External Remote Sockets
+  console.log(`    └── ${chalk.cyan.bold('TOP ACTIVE REMOTE CONNECTIONS')}`);
+  if (establishedConns.length === 0) {
+    console.log(`         └── ${chalk.dim('No active established sockets detected.')}`);
+  } else {
+    for (let i = 0; i < establishedConns.length; i++) {
+      const conn = establishedConns[i];
+      const isLast = i === establishedConns.length - 1;
+      const prefix = isLast ? '         └──' : '         ├──';
+      const connsBadge = chalk.dim(`(${conn.connectionCount} socket${conn.connectionCount > 1 ? 's' : ''})`);
+      console.log(`${prefix} ${chalk.white(conn.host.padEnd(24))} ${chalk.green('ESTABLISHED')} ${connsBadge}`);
+    }
+  }
+
+  console.log();
+  console.log(chalk.dim('  Tip: Run "pyre p2p server" on any node to allow automatic live cluster streaming.\n'));
+}

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
-};