pyre-cli 9.5.2 → 10.0.0

package/dist/topoCmd-DU2HHZNH.js

@@ -0,0 +1,148 @@
+import {
+  collectNetwork
+} from "./chunk-GHRDW646.js";
+import "./chunk-M73HCQD2.js";
+import "./chunk-VIACN2RU.js";
+import {
+  run
+} from "./chunk-MZO5QKUR.js";
+
+// src/topoCmd.ts
+import net from "net";
+import os from "os";
+import chalk from "chalk";
+async function probePort(ip, port, timeoutMs = 400) {
+  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() {
+  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) {
+  const peers = [];
+  try {
+    const raw = await run("arp -a -n 2>/dev/null", "");
+    const lines = raw.split("\n");
+    for (const line of lines) {
+      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;
+}
+async function runTopoCommand(opts = {}) {
+  const localNet = await collectNetwork();
+  const gatewayIp = await getDefaultGateway();
+  const lanPeers = await getArpNeighbors(gatewayIp);
+  const hostname = os.hostname();
+  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  \u{1F525} pyre topo \u2014 Network Topology Map\n"));
+  console.log(`  ${chalk.bgCyan.black.bold(" LOCAL HOST ")} ${chalk.bold(hostname)}`);
+  console.log(`    \u251C\u2500\u2500 IP Address:       ${chalk.green.bold(localNet.ip || "127.0.0.1")} (${localNet.interface})`);
+  console.log(`    \u251C\u2500\u2500 Active RX / TX:   \u2193 ${chalk.cyan(localNet.rxBytes ? `${(localNet.rxBytes / 1e6).toFixed(1)} MB` : "0 MB")}  \u2191 ${chalk.blue(localNet.txBytes ? `${(localNet.txBytes / 1e6).toFixed(1)} MB` : "0 MB")}`);
+  console.log("    \u2502");
+  console.log(`    \u251C\u2500\u2500 ${chalk.yellow.bold("DEFAULT GATEWAY / ROUTER")}`);
+  console.log(`    \u2502    \u2514\u2500\u2500 IP: ${chalk.yellow(gatewayIp)}  [Route \u2192 WAN / Internet]`);
+  console.log("    \u2502");
+  console.log(`    \u251C\u2500\u2500 ${chalk.magenta.bold("LAN NEIGHBORS & PEERS")} (${lanPeers.length} discovered via ARP)`);
+  if (lanPeers.length === 0) {
+    console.log(`    \u2502    \u2514\u2500\u2500 ${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 ? "    \u2502    \u2514\u2500\u2500" : "    \u2502    \u251C\u2500\u2500";
+      const gwBadge = peer.isGateway ? chalk.yellow(" [Gateway]") : "";
+      let pyreBadge = "";
+      if (peer.pyreP2P) pyreBadge += chalk.hex("#ff5500").bold(" [\u{1F525} pyre P2P :9876]");
+      if (peer.pyreRest) pyreBadge += chalk.hex("#00ffcc").bold(" [\u{1F525} pyre REST :8080]");
+      console.log(`${prefix} ${peer.ip.padEnd(16)} ${chalk.dim(peer.mac)}${gwBadge}${pyreBadge}`);
+    }
+  }
+  console.log("    \u2502");
+  console.log(`    \u2514\u2500\u2500 ${chalk.cyan.bold("TOP ACTIVE REMOTE CONNECTIONS")}`);
+  if (establishedConns.length === 0) {
+    console.log(`         \u2514\u2500\u2500 ${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 ? "         \u2514\u2500\u2500" : "         \u251C\u2500\u2500";
+      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'));
+}
+export {
+  runTopoCommand
+};

package/dist/watchdogCmd-UF53JPZB.js

@@ -0,0 +1,161 @@
+import {
+  sendAlert
+} from "./chunk-Z2YV5HKV.js";
+import {
+  getConfigDir,
+  readConfig
+} from "./chunk-53O2RGSL.js";
+import {
+  collectAll
+} from "./chunk-GHRDW646.js";
+import "./chunk-M73HCQD2.js";
+import "./chunk-VIACN2RU.js";
+import "./chunk-MZO5QKUR.js";
+
+// src/watchdogCmd.ts
+import fs from "fs";
+import path from "path";
+import chalk from "chalk";
+var DEFAULT_WATCHDOG_RULES = [
+  {
+    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
+  }
+];
+async function runWatchdogCommand(opts = {}) {
+  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 = DEFAULT_WATCHDOG_RULES;
+  if (fs.existsSync(rulePath)) {
+    try {
+      rules = JSON.parse(fs.readFileSync(rulePath, "utf-8"));
+    } catch (err) {
+      console.error(chalk.yellow(`  \u26A0 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 {
+    }
+  }
+  console.log(chalk.bold("\n  \u{1F525} pyre watchdog \u2014 Autonomous Monitoring Daemon\n"));
+  console.log(`  ${chalk.green("\u2714")} Loaded ${chalk.bold(String(rules.length))} rule(s) from ${chalk.cyan(rulePath)}`);
+  console.log(`  ${chalk.green("\u2714")} Refresh interval: ${intervalSec}s  |  Dry run mode: ${isDryRun ? chalk.yellow("ON") : chalk.dim("OFF")}`);
+  console.log(`
+  ${chalk.dim("Active Rules:")}`);
+  for (const r of rules) {
+    const target = r.process ? `proc "${r.process}"` : r.metric || "system";
+    console.log(`    \u2022 ${chalk.bold(r.name)} [if ${target} > ${r.threshold} \u2192 ${chalk.cyan(r.action)}]`);
+  }
+  console.log(chalk.dim("\n  Watching... Press Ctrl+C to stop.\n"));
+  const lastTriggered = /* @__PURE__ */ new Map();
+  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) * 1e3;
+        const last = lastTriggered.get(rule.name) || 0;
+        if (now - last < cooldown) continue;
+        let triggered = false;
+        let detail = "";
+        let targetPid = 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 !== void 0 && temp >= rule.threshold) {
+            triggered = true;
+            detail = `System Temperature at ${temp.toFixed(1)}\xB0C (threshold ${rule.threshold}\xB0C)`;
+          }
+        }
+        if (triggered) {
+          lastTriggered.set(rule.name, now);
+          const timeStr = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+          console.log(`  [${chalk.dim(timeStr)}] ${chalk.red.bold("\u26A0 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(`    \u2714 Killed PID ${targetPid} with SIGTERM`));
+            } catch (err) {
+              console.log(chalk.red(`    \u2716 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: (/* @__PURE__ */ new Date()).toISOString(),
+              severity: "critical"
+            }, alertChannels).catch(() => {
+            });
+            console.log(chalk.green("    \u2714 Multi-channel alert dispatched."));
+          }
+        }
+      }
+    } catch {
+    }
+  };
+  await evaluate();
+  const handle = setInterval(evaluate, intervalSec * 1e3);
+  await new Promise((resolve) => {
+    process.on("SIGINT", () => {
+      clearInterval(handle);
+      console.log(chalk.dim("\n  Watchdog stopped."));
+      resolve();
+      process.exit(0);
+    });
+  });
+}
+export {
+  runWatchdogCommand
+};

package/dist/{wizard-Z3RGA3VB.js → wizard-TD7BGX6O.js}

@@ -1,7 +1,7 @@
 import {
   CONFIG_FILE,
   writeConfig
-} from "./chunk-CXL4GYGQ.js";
+} from "./chunk-53O2RGSL.js";
 
 // src/wizard.ts
 import readline from "readline";

package/install.ps1

@@ -0,0 +1,29 @@
+# pyre Windows PowerShell installer
+# Usage: iwr -useb https://raw.githubusercontent.com/somalip/pyre/main/install.ps1 | iex
+
+$ErrorActionPreference = 'Stop'
+
+Write-Host "🔥 Installing pyre system monitor for Windows..." -ForegroundColor Cyan
+
+# Check for Node.js / npm
+if (-not (Get-Command npm -ErrorAction SilentlyContinue)) {
+    Write-Host "✖ Node.js and npm are required to run pyre." -ForegroundColor Red
+    Write-Host "  Please install Node.js (>= 18) from https://nodejs.org" -ForegroundColor Yellow
+    exit 1
+}
+
+Write-Host "📦 Installing pyre-cli globally via npm..." -ForegroundColor Green
+try {
+    npm install -g pyre-cli
+} catch {
+    Write-Host "✖ Failed to install pyre-cli globally." -ForegroundColor Red
+    exit 1
+}
+
+if (Get-Command pyre -ErrorAction SilentlyContinue) {
+    Write-Host "✔ pyre installed successfully!" -ForegroundColor Green
+    Write-Host "  Run 'pyre live' to start the interactive dashboard." -ForegroundColor Cyan
+    Write-Host "  Run 'pyre --help' to see all available commands." -ForegroundColor Cyan
+} else {
+    Write-Host "ℹ Installation complete. If 'pyre' command is not recognized, restart your PowerShell session." -ForegroundColor Yellow
+}

package/install.sh

@@ -1,10 +1,9 @@
 #!/bin/bash
-# pyre install script - curl installation for macOS
+# pyre install script - curl installation for macOS and Linux
 set -euo pipefail
 
 REPO="somalip/pyre"
 TOOL="pyre"
-BIN_DIR="${BIN_DIR:-/usr/local/bin}"
 
 RED='\033[0;31m'
 GREEN='\033[0;32m'
@@ -13,23 +12,25 @@ NC='\033[0m'
 info() { echo -e "${GREEN}[pyre]${NC} $1"; }
 err() { echo -e "${RED}[pyre]${NC} $1" >&2; }
 
-if [[ "$(uname)" != "Darwin" ]]; then
-  err "pyre requires macOS. Detected $(uname)."
+OS="$(uname -s)"
+if [[ "$OS" != "Darwin" && "$OS" != "Linux" ]]; then
+  err "This installer supports macOS and Linux (detected $OS). On Windows, run install.ps1 in PowerShell."
   exit 1
 fi
 
 if ! command -v npm &> /dev/null; then
-  err "Node.js/npm is required. Install from https://nodejs.org"
+  err "Node.js (>= 18) and npm are required. Install from https://nodejs.org"
   exit 1
 fi
 
-info "Installing ${TOOL} via npm..."
-npm install -g "@$REPO"
+info "Detected platform: $OS"
+info "Installing ${TOOL} globally via npm..."
+npm install -g pyre-cli || npm install -g "@$REPO"
 
 info "Verifying installation..."
 if command -v "$TOOL" &> /dev/null; then
   info "${TOOL} installed successfully!"
-  info "Run ${TOOL} --help to get started."
+  info "Run '${TOOL} live' or '${TOOL} --help' to get started."
 else
-  info "Installation complete. If the command is not found, restart your shell."
+  info "Installation complete. If '${TOOL}' is not found in your PATH, restart your shell or check npm global bin path."
 fi

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pyre-cli",
-  "version": "9.5.2",
-  "description": "CLI Mac monitoring tool: temps, system stats, live dashboard, packet monitor, battery predictor, export",
+  "version": "10.0.0",
+  "description": "Cross-platform system monitoring CLI for macOS, Linux, and Windows: temps, system stats, live dashboard, packet monitor, battery predictor, export",
   "main": "dist/index.js",
   "type": "module",
   "bin": {
@@ -12,6 +12,7 @@
     "src",
     "tsconfig.json",
     "install.sh",
+    "install.ps1",
     "Formula/pyre.rb",
     "README.md",
     "parity.md"
@@ -20,12 +21,15 @@
     "build": "tsup src/index.ts --format esm --clean",
     "start": "node dist/index.js",
     "dev": "tsx src/index.ts",
-    "test": "node dist/index.js --help >/dev/null && echo 'OK'"
+    "test": "node dist/index.js --help && tsx --test src/easy_features.test.ts src/platform.test.ts"
   },
   "engines": {
     "node": ">=18.0.0"
   },
   "keywords": [
+    "cross-platform",
+    "linux",
+    "windows",
     "mac",
     "monitoring",
     "temperature",

package/src/ai/models.ts

@@ -0,0 +1,138 @@
+/**
+ * Built-in AI Model definitions and diagnostic inference engine.
+ *
+ * Allows users to choose their AI explanation model directly inside the TUI
+ * without depending on an external Ollama server host.
+ *
+ * Includes fast, private, zero-dependency built-in offline heuristic & rule models,
+ * alongside optional local Ollama and remote cloud models if selected.
+ */
+import type { AnomalyAlert } from '../anomalies.js';
+
+export interface AIModelOption {
+  id: string;
+  name: string;
+  backend: 'builtin' | 'ollama' | 'openai';
+  description: string;
+  badge: string;
+  offline: boolean;
+}
+
+export const AVAILABLE_AI_MODELS: AIModelOption[] = [
+  {
+    id: 'expert-rules-v1',
+    name: 'Pyre Expert Heuristics (Local Built-in)',
+    backend: 'builtin',
+    description: 'Instant zero-latency diagnostic model. No server or setup required.',
+    badge: 'Offline · Built-in',
+    offline: true,
+  },
+  {
+    id: 'macos-kernel-analyst',
+    name: 'macOS Thermal & I/O Engine (Local Built-in)',
+    backend: 'builtin',
+    description: 'Specialized for Apple Silicon throttling, memory pressure, and swap spikes.',
+    badge: 'Offline · Built-in',
+    offline: true,
+  },
+  {
+    id: 'llama3.2',
+    name: 'Ollama: Llama 3.2 (Local Host)',
+    backend: 'ollama',
+    description: 'Connects to local Ollama server on port 11434.',
+    badge: 'Ollama Server',
+    offline: true,
+  },
+  {
+    id: 'deepseek-r1:1.5b',
+    name: 'Ollama: DeepSeek R1 1.5B (Local Host)',
+    backend: 'ollama',
+    description: 'Fast local reasoning model via Ollama server.',
+    badge: 'Ollama Server',
+    offline: true,
+  },
+  {
+    id: 'mistral',
+    name: 'Ollama: Mistral (Local Host)',
+    backend: 'ollama',
+    description: 'General system analysis via Ollama server.',
+    badge: 'Ollama Server',
+    offline: true,
+  },
+  {
+    id: 'gpt-4o-mini',
+    name: 'OpenAI: GPT-4o Mini (Cloud API)',
+    backend: 'openai',
+    description: 'Requires OPENAI_API_KEY environment variable.',
+    badge: 'Cloud API',
+    offline: false,
+  },
+];
+
+/**
+ * Diagnostic rule engine that provides instantaneous, private,
+ * macOS-tailored explanations for anomaly spikes without calling any external host.
+ */
+export function explainAnomaliesLocally(
+  anomalies: AnomalyAlert[],
+  modelId: string = 'expert-rules-v1'
+): string {
+  if (anomalies.length === 0) {
+    return '✔ No statistical anomalies detected in this session.';
+  }
+
+  const lines: string[] = [];
+  lines.push(`Diagnosis Engine: ${modelId} (Self-Contained TUI Analysis)`);
+  lines.push('──────────────────────────────────────────────────────────────────────────────');
+  lines.push('');
+
+  for (const a of anomalies.slice(0, 8)) {
+    const unit = a.metric === 'Temp' || a.metric === 'Temperature' ? '°C' : a.metric.toLowerCase().includes('net') ? 'B/s' : '%';
+    const severityTag = a.severity === 'critical' ? '[CRITICAL SPIKE]' : '[MODERATE SPIKE]';
+    const zStr = a.zScore > 0 ? `+${a.zScore.toFixed(1)}σ` : `${a.zScore.toFixed(1)}σ`;
+
+    lines.push(`${severityTag} ${a.metric} anomaly at ${a.value.toFixed(1)}${unit} (${zStr} deviation)`);
+
+    // Model reasoning logic
+    if (a.metric === 'CPU') {
+      if (modelId === 'macos-kernel-analyst') {
+        lines.push('  • Cause: High burst of thread execution, possibly kernel_task scheduling or JIT compiler compilation.');
+        lines.push('  • Verdict: Harmless if transient (<30s). Check for runaway build tools or browser renderer loops.');
+        lines.push('  • Recommendation: Press "P" to open the Process table and inspect the top CPU consumers.');
+      } else {
+        lines.push('  • Cause: Sudden compute surge exceeding typical baseline workload.');
+        lines.push('  • Verdict: Likely a compiler, media encoder, or intensive background sync process.');
+        lines.push('  • Recommendation: Press "k" to terminate high-consuming PIDs if unresponsive.');
+      }
+    } else if (a.metric === 'Memory') {
+      lines.push('  • Cause: Rapid memory allocation or buffer spike.');
+      lines.push('  • Verdict: Check for memory leaks or large dataset in-memory parsing.');
+      lines.push('  • Recommendation: Review swap activity; close unused Electron apps to relieve memory pressure.');
+    } else if (a.metric === 'Temp' || a.metric === 'Temperature') {
+      lines.push('  • Cause: Die thermal elevation caused by sustained CPU/GPU power draw.');
+      lines.push('  • Verdict: Normal under heavy compute; Apple Silicon will throttle if >100°C.');
+      lines.push('  • Recommendation: Ensure MacBook airflow vents are clear; watch fan RPM in Thermal panel.');
+    } else if (a.metric === 'GPU') {
+      lines.push('  • Cause: Metal pipeline or display compositor acceleration spike.');
+      lines.push('  • Verdict: Often triggered by 3D rendering, video decoding, or WebGL.');
+      lines.push('  • Recommendation: Check window manager or running 3D applications.');
+    } else if (a.metric.toLowerCase().includes('net')) {
+      lines.push('  • Cause: Outgoing or incoming bandwidth burst.');
+      lines.push('  • Verdict: Cloud sync, large file transfer, or package manager download.');
+      lines.push('  • Recommendation: Switch to Connections panel (key "8") to check remote hosts.');
+    } else if (a.metric === 'Power') {
+      lines.push('  • Cause: Combined wattage draw spike above typical power envelope.');
+      lines.push('  • Verdict: SoC hitting turbo or sustained multi-core boost.');
+      lines.push('  • Recommendation: If on battery power, consider reducing background workloads.');
+    } else {
+      lines.push(`  • Cause: Statistical variance in metric ${a.metric}.`);
+      lines.push('  • Verdict: Deviates significantly from session mean.');
+      lines.push('  • Recommendation: Monitor in live graphs to observe whether it returns to baseline.');
+    }
+    lines.push('');
+  }
+
+  lines.push('──────────────────────────────────────────────────────────────────────────────');
+  lines.push('Tip: Press "m" anytime in the TUI to change the active AI explanation model.');
+  return lines.join('\n');
+}

package/src/alertChannels.ts

@@ -0,0 +1,119 @@
+/**
+ * pyre multi-channel alert sender.
+ *
+ * Sends alert notifications to one or more configured channels:
+ *   - Slack  (incoming webhook URL)
+ *   - Discord (webhook URL)
+ *   - Pushover (API token + user key)
+ *   - ntfy.sh (topic URL)
+ *
+ * All channels use Node.js 18+ built-in fetch.
+ * Failures are always silent.
+ */
+
+export interface AlertPayload {
+  metric: string;
+  value: number;
+  threshold: number;
+  unit: string;
+  host: string;
+  timestamp: string;
+  severity?: 'warning' | 'critical';
+}
+
+export interface AlertChannelConfig {
+  slackUrl?: string;
+  discordUrl?: string;
+  pushoverToken?: string;
+  pushoverUser?: string;
+  ntfyUrl?: string;
+}
+
+function buildMessage(payload: AlertPayload): string {
+  const icon = payload.severity === 'critical' ? '🔴' : '⚠️';
+  return `${icon} pyre alert on ${payload.host}: ${payload.metric} reached ${payload.value.toFixed(1)}${payload.unit} (threshold: ${payload.threshold}${payload.unit}) at ${payload.timestamp}`;
+}
+
+async function postJson(url: string, body: unknown): Promise<void> {
+  await fetch(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+}
+
+async function sendSlack(url: string, payload: AlertPayload): Promise<void> {
+  const color = payload.severity === 'critical' ? '#ff0000' : '#ffa500';
+  await postJson(url, {
+    attachments: [{
+      color,
+      text: buildMessage(payload),
+      footer: 'pyre system monitor',
+      ts: Math.floor(Date.now() / 1000),
+    }],
+  });
+}
+
+async function sendDiscord(url: string, payload: AlertPayload): Promise<void> {
+  const color = payload.severity === 'critical' ? 0xff0000 : 0xffa500;
+  await postJson(url, {
+    embeds: [{
+      title: `pyre — ${payload.metric} Alert`,
+      description: buildMessage(payload),
+      color,
+      footer: { text: 'pyre system monitor' },
+      timestamp: payload.timestamp,
+    }],
+  });
+}
+
+async function sendPushover(token: string, user: string, payload: AlertPayload): Promise<void> {
+  await postJson('https://api.pushover.net/1/messages.json', {
+    token,
+    user,
+    title: `pyre — ${payload.metric} Alert`,
+    message: buildMessage(payload),
+    priority: payload.severity === 'critical' ? 1 : 0,
+  });
+}
+
+async function sendNtfy(url: string, payload: AlertPayload): Promise<void> {
+  await fetch(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'text/plain',
+      'Title': `pyre — ${payload.metric} Alert`,
+      'Priority': payload.severity === 'critical' ? 'high' : 'default',
+      'Tags': payload.severity === 'critical' ? 'rotating_light' : 'warning',
+    },
+    body: buildMessage(payload),
+  });
+}
+
+/** Send an alert to all configured channels. All failures are silently ignored. */
+export async function sendAlert(payload: AlertPayload, config: AlertChannelConfig): Promise<void> {
+  const tasks: Promise<void>[] = [];
+
+  if (config.slackUrl) tasks.push(sendSlack(config.slackUrl, payload).catch(() => {}));
+  if (config.discordUrl) tasks.push(sendDiscord(config.discordUrl, payload).catch(() => {}));
+  if (config.pushoverToken && config.pushoverUser) {
+    tasks.push(sendPushover(config.pushoverToken, config.pushoverUser, payload).catch(() => {}));
+  }
+  if (config.ntfyUrl) tasks.push(sendNtfy(config.ntfyUrl, payload).catch(() => {}));
+
+  if (tasks.length > 0) await Promise.allSettled(tasks);
+}
+
+/** Fire a test alert to all configured channels (used by pyre alert test). */
+export async function sendTestAlert(config: AlertChannelConfig): Promise<void> {
+  const hostname = (await import('node:os')).hostname();
+  await sendAlert({
+    metric: 'CPU',
+    value: 95.0,
+    threshold: 90,
+    unit: '%',
+    host: hostname,
+    timestamp: new Date().toISOString(),
+    severity: 'warning',
+  }, config);
+}