pyre-cli 9.5.1 → 10.0.0

package/dist/doctor-GYHFTNZQ.js

@@ -0,0 +1,387 @@
+import {
+  CONFIG_FILE,
+  readConfig
+} from "./chunk-53O2RGSL.js";
+import {
+  run
+} from "./chunk-MZO5QKUR.js";
+
+// src/doctor.ts
+import fs from "fs";
+import chalk from "chalk";
+async function runDoctor() {
+  const platform = process.platform;
+  if (platform === "linux") return runLinuxDoctor();
+  if (platform === "win32") return runWindowsDoctor();
+  return runMacDoctor();
+}
+async function runMacDoctor() {
+  const checks = [];
+  try {
+    const pmResult = await run("sudo -n powermetrics --samplers cpu_power -n 1 2>&1", "");
+    if (pmResult.includes("Password:") || pmResult.includes("Permission denied") || pmResult.includes("sudo: a password is required")) {
+      checks.push({
+        name: "Sudo / Powermetrics",
+        status: "warn",
+        message: "Passwordless sudo for powermetrics is not configured.",
+        details: "Powermetrics allows high-precision GPU & CPU power sampling. Run with sudo or configure passwordless sudo in /etc/sudoers."
+      });
+    } else {
+      checks.push({
+        name: "Sudo / Powermetrics",
+        status: "ok",
+        message: "Powermetrics access available."
+      });
+    }
+  } catch {
+    checks.push({
+      name: "Sudo / Powermetrics",
+      status: "warn",
+      message: "Powermetrics check failed."
+    });
+  }
+  try {
+    const psCheck = await run("ps -ax -o pid,user,command", "");
+    if (psCheck.length > 0) {
+      checks.push({
+        name: "TCC / Process Visibility",
+        status: "ok",
+        message: "Process listing access available."
+      });
+    } else {
+      checks.push({
+        name: "TCC / Process Visibility",
+        status: "warn",
+        message: "Restricted process visibility.",
+        details: "Grant Full Disk Access or Terminal permissions in System Settings -> Privacy & Security."
+      });
+    }
+  } catch {
+    checks.push({
+      name: "TCC / Process Visibility",
+      status: "error",
+      message: "Unable to list system processes."
+    });
+  }
+  try {
+    const netCheck = await run("netstat -rn", "");
+    if (netCheck.includes("default") || netCheck.includes("gateway")) {
+      checks.push({
+        name: "Network Reachability",
+        status: "ok",
+        message: "Network interface active with default gateway."
+      });
+    } else {
+      checks.push({
+        name: "Network Reachability",
+        status: "warn",
+        message: "No active network route detected for P2P mode."
+      });
+    }
+  } catch {
+    checks.push({
+      name: "Network Reachability",
+      status: "warn",
+      message: "Could not verify network routes."
+    });
+  }
+  try {
+    const spctlOut = await run("spctl --status 2>&1", "");
+    if (spctlOut.includes("assessments enabled")) {
+      checks.push({
+        name: "Gatekeeper",
+        status: "ok",
+        message: "Gatekeeper enforcement is enabled."
+      });
+    } else {
+      checks.push({
+        name: "Gatekeeper",
+        status: "warn",
+        message: "Gatekeeper is disabled or status check unconfirmed.",
+        details: 'Re-enable Gatekeeper using "sudo spctl --master-enable" to protect against untrusted software.'
+      });
+    }
+  } catch {
+    checks.push({
+      name: "Gatekeeper",
+      status: "warn",
+      message: "Could not query Gatekeeper status."
+    });
+  }
+  try {
+    const sipOut = await run("csrutil status 2>&1", "");
+    if (sipOut.includes("enabled")) {
+      checks.push({
+        name: "System Integrity Protection",
+        status: "ok",
+        message: "SIP is enabled."
+      });
+    } else {
+      checks.push({
+        name: "System Integrity Protection",
+        status: "warn",
+        message: "SIP is disabled or restricted.",
+        details: "System Integrity Protection protects core system files. Enable it from macOS Recovery."
+      });
+    }
+  } catch {
+    checks.push({
+      name: "System Integrity Protection",
+      status: "warn",
+      message: "Could not query SIP status."
+    });
+  }
+  try {
+    const xprotectOut = await run("system_profiler SPInstallHistoryDataType 2>&1", "");
+    const xpMatches = Array.from(xprotectOut.matchAll(/XProtect(?:Remediator)?ConfigData.*?\n.*?Install Date:\s*(.+)/gi));
+    if (xpMatches.length > 0) {
+      const latestDateStr = xpMatches[xpMatches.length - 1][1];
+      checks.push({
+        name: "XProtect Definitions",
+        status: "ok",
+        message: `XProtect active (last updated ${latestDateStr.trim()}).`
+      });
+    } else {
+      checks.push({
+        name: "XProtect Definitions",
+        status: "ok",
+        message: "XProtect definitions installed."
+      });
+    }
+  } catch {
+    checks.push({
+      name: "XProtect Definitions",
+      status: "warn",
+      message: "Could not determine XProtect update history."
+    });
+  }
+  checks.push(checkConfigIntegrity());
+  return checks;
+}
+async function runLinuxDoctor() {
+  const checks = [];
+  try {
+    const psCheck = await run("ps -eo pid,user,comm", "");
+    if (psCheck.length > 0) {
+      checks.push({
+        name: "Process Visibility",
+        status: "ok",
+        message: "Full process table access available."
+      });
+    } else {
+      checks.push({
+        name: "Process Visibility",
+        status: "warn",
+        message: "Restricted process table access."
+      });
+    }
+  } catch {
+    checks.push({
+      name: "Process Visibility",
+      status: "error",
+      message: "Unable to query process list."
+    });
+  }
+  try {
+    const statExists = fs.existsSync("/proc/stat");
+    const memExists = fs.existsSync("/proc/meminfo");
+    if (statExists && memExists) {
+      checks.push({
+        name: "Kernel Telemetry (/proc)",
+        status: "ok",
+        message: "Kernel telemetry interfaces readable."
+      });
+    } else {
+      checks.push({
+        name: "Kernel Telemetry (/proc)",
+        status: "error",
+        message: "Core pseudo-filesystems (/proc) unavailable or restricted."
+      });
+    }
+  } catch {
+    checks.push({
+      name: "Kernel Telemetry (/proc)",
+      status: "warn",
+      message: "Could not check /proc readability."
+    });
+  }
+  try {
+    const thermZones = fs.existsSync("/sys/class/thermal");
+    const hwmon = fs.existsSync("/sys/class/hwmon");
+    if (thermZones || hwmon) {
+      checks.push({
+        name: "Hardware Sensors (/sys)",
+        status: "ok",
+        message: "Thermal and hardware monitoring sensors detected."
+      });
+    } else {
+      checks.push({
+        name: "Hardware Sensors (/sys)",
+        status: "warn",
+        message: "No hardware sensor paths detected in /sys/class."
+      });
+    }
+  } catch {
+    checks.push({
+      name: "Hardware Sensors (/sys)",
+      status: "warn",
+      message: "Unable to query sensor interfaces."
+    });
+  }
+  try {
+    const netCheck = await run("ip route 2>/dev/null || route -n 2>/dev/null", "");
+    if (netCheck.includes("default") || netCheck.includes("0.0.0.0")) {
+      checks.push({
+        name: "Network Reachability",
+        status: "ok",
+        message: "Active default route detected."
+      });
+    } else {
+      checks.push({
+        name: "Network Reachability",
+        status: "warn",
+        message: "No default network gateway detected."
+      });
+    }
+  } catch {
+    checks.push({
+      name: "Network Reachability",
+      status: "warn",
+      message: "Could not verify network routes."
+    });
+  }
+  try {
+    const sysctlRes = await run("systemctl --user status 2>&1", "");
+    if (!sysctlRes.includes("Failed to connect to bus") && !sysctlRes.includes("not found")) {
+      checks.push({
+        name: "Systemd User Daemon",
+        status: "ok",
+        message: "Systemd user session active (ready for pyre --install)."
+      });
+    } else {
+      checks.push({
+        name: "Systemd User Daemon",
+        status: "warn",
+        message: "Systemd user session not available.",
+        details: "Background services via pyre --install require an active user systemd session."
+      });
+    }
+  } catch {
+    checks.push({
+      name: "Systemd User Daemon",
+      status: "warn",
+      message: "Systemd check skipped."
+    });
+  }
+  checks.push(checkConfigIntegrity());
+  return checks;
+}
+async function runWindowsDoctor() {
+  const checks = [];
+  try {
+    const psCheck = await run("tasklist /nh 2>nul", "");
+    if (psCheck.length > 0) {
+      checks.push({
+        name: "Process Visibility",
+        status: "ok",
+        message: "Windows process table access available."
+      });
+    } else {
+      checks.push({
+        name: "Process Visibility",
+        status: "warn",
+        message: "Tasklist query returned no output."
+      });
+    }
+  } catch {
+    checks.push({
+      name: "Process Visibility",
+      status: "error",
+      message: "Unable to query Windows tasklist."
+    });
+  }
+  try {
+    const wmiCheck = await run('wmic os get Caption 2>nul || powershell -Command "(Get-CimInstance Win32_OperatingSystem).Caption"', "");
+    if (wmiCheck.toLowerCase().includes("windows")) {
+      checks.push({
+        name: "WMI / CIM Subsystem",
+        status: "ok",
+        message: "WMI/CIM management queries responsive."
+      });
+    } else {
+      checks.push({
+        name: "WMI / CIM Subsystem",
+        status: "warn",
+        message: "WMI/CIM query did not return expected response.",
+        details: "Some hardware metrics (disks, thermal) rely on WMI or PowerShell CIM."
+      });
+    }
+  } catch {
+    checks.push({
+      name: "WMI / CIM Subsystem",
+      status: "warn",
+      message: "Could not execute WMI query."
+    });
+  }
+  try {
+    const netCheck = await run("netstat -rn 2>nul", "");
+    if (netCheck.includes("0.0.0.0")) {
+      checks.push({
+        name: "Network Reachability",
+        status: "ok",
+        message: "Active default IPv4 gateway detected."
+      });
+    } else {
+      checks.push({
+        name: "Network Reachability",
+        status: "warn",
+        message: "No default route detected in routing table."
+      });
+    }
+  } catch {
+    checks.push({
+      name: "Network Reachability",
+      status: "warn",
+      message: "Could not verify Windows network routes."
+    });
+  }
+  checks.push(checkConfigIntegrity());
+  return checks;
+}
+function checkConfigIntegrity() {
+  try {
+    readConfig();
+    return {
+      name: "Configuration File",
+      status: "ok",
+      message: `Config file valid (${CONFIG_FILE}).`
+    };
+  } catch (err) {
+    return {
+      name: "Configuration File",
+      status: "error",
+      message: "Failed to parse config file.",
+      details: err.message
+    };
+  }
+}
+function printDoctorReport(checks) {
+  const osLabel = process.platform === "darwin" ? "macOS" : process.platform === "win32" ? "Windows" : "Linux";
+  console.log(chalk.bold(`
+  pyre doctor \u2014 System Diagnostics (${osLabel})
+`));
+  for (const check of checks) {
+    let icon = chalk.green("\u2714");
+    if (check.status === "warn") icon = chalk.yellow("\u26A0");
+    if (check.status === "error") icon = chalk.red("\u2716");
+    console.log(`  ${icon} ${chalk.bold(check.name.padEnd(26))} ${check.message}`);
+    if (check.details) {
+      console.log(chalk.dim(`     \u21B3 ${check.details}`));
+    }
+  }
+  console.log();
+}
+export {
+  printDoctorReport,
+  runDoctor
+};

package/dist/explainCmd-MF6PIMLW.js

@@ -0,0 +1,222 @@
+import {
+  explainAnomaliesLocally
+} from "./chunk-ZLVIVFSO.js";
+
+// src/explainCmd.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+import chalk from "chalk";
+function parseAnomalies(dir, sinceStr) {
+  if (!fs.existsSync(dir)) return [];
+  const files = fs.readdirSync(dir).filter((f) => f.startsWith("pyre-") && f.endsWith(".csv"));
+  if (files.length === 0) return [];
+  let cutoff = Date.now() - 7 * 24 * 60 * 60 * 1e3;
+  if (sinceStr === "yesterday" || sinceStr === "1d") cutoff = Date.now() - 24 * 60 * 60 * 1e3;
+  else if (sinceStr.endsWith("d")) {
+    const d = parseInt(sinceStr.slice(0, -1), 10);
+    if (!isNaN(d)) cutoff = Date.now() - d * 24 * 60 * 60 * 1e3;
+  } else if (!isNaN(Date.parse(sinceStr))) {
+    cutoff = Date.parse(sinceStr);
+  }
+  const rows = [];
+  for (const file of files.sort()) {
+    try {
+      const content = fs.readFileSync(path.join(dir, file), "utf-8");
+      for (const line of content.split("\n").slice(1)) {
+        if (!line.trim()) continue;
+        const parts = line.split(",");
+        if (parts.length < 3) continue;
+        const ts = new Date(parts[0]);
+        if (!isNaN(ts.getTime()) && ts.getTime() >= cutoff) {
+          const cpu = parseFloat(parts[1]);
+          const mem = parseFloat(parts[2]);
+          const temp = parts[3] ? parseFloat(parts[3]) : NaN;
+          if (!isNaN(cpu) && !isNaN(mem)) {
+            rows.push({ ts, cpu, mem, temp: isNaN(temp) ? void 0 : temp });
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  if (rows.length < 5) return [];
+  const mean = (arr) => arr.reduce((a, b) => a + b, 0) / arr.length;
+  const std = (arr, m) => Math.sqrt(arr.reduce((a, b) => a + (b - m) ** 2, 0) / arr.length);
+  const cpuVals = rows.map((r) => r.cpu);
+  const memVals = rows.map((r) => r.mem);
+  const tempVals = rows.filter((r) => r.temp !== void 0).map((r) => r.temp);
+  const cpuMean = mean(cpuVals);
+  const cpuStd = std(cpuVals, cpuMean);
+  const memMean = mean(memVals);
+  const memStd = std(memVals, memMean);
+  const tempMean = tempVals.length ? mean(tempVals) : 0;
+  const tempStd = tempVals.length ? std(tempVals, tempMean) : 0;
+  const anomalies = [];
+  for (const r of rows) {
+    if (cpuStd > 0) {
+      const z = (r.cpu - cpuMean) / cpuStd;
+      if (z >= 2.5) anomalies.push({ timestamp: r.ts.toISOString(), metric: "CPU", value: r.cpu, baseline: cpuMean, zScore: z });
+    }
+    if (memStd > 0) {
+      const z = (r.mem - memMean) / memStd;
+      if (z >= 2.5) anomalies.push({ timestamp: r.ts.toISOString(), metric: "Memory", value: r.mem, baseline: memMean, zScore: z });
+    }
+    if (r.temp !== void 0 && tempStd > 0) {
+      const z = (r.temp - tempMean) / tempStd;
+      if (z >= 2.5) anomalies.push({ timestamp: r.ts.toISOString(), metric: "Temperature", value: r.temp, baseline: tempMean, zScore: z });
+    }
+  }
+  return anomalies;
+}
+function buildPrompt(anomalies, hostname, sinceStr) {
+  const osLabel = process.platform === "darwin" ? "macOS" : process.platform === "win32" ? "Windows" : "Linux";
+  const lines = anomalies.slice(0, 10).map((a) => {
+    const unit = a.metric === "Temperature" ? "\xB0C" : "%";
+    return `- ${a.metric} spike at ${a.timestamp}: ${a.value.toFixed(1)}${unit} (baseline ${a.baseline.toFixed(1)}${unit}, +${a.zScore.toFixed(1)}\u03C3)`;
+  });
+  return [
+    `You are a ${osLabel} system performance expert analyzing a monitoring log from "${hostname}".`,
+    `The following statistical anomalies (z-score \u2265 2.5\u03C3) were detected in the past ${sinceStr}:`,
+    "",
+    ...lines,
+    "",
+    "For each anomaly, provide:",
+    `1. A plain-English explanation of what likely caused it (be specific to ${osLabel})`,
+    "2. Whether it is likely harmless or worth investigating",
+    "3. One actionable recommendation the user can take right now",
+    "",
+    "Be concise (2-3 sentences per anomaly). Use bullet points. Do not use technical jargon."
+  ].join("\n");
+}
+async function queryOllama(prompt, model) {
+  const res = await fetch("http://localhost:11434/api/generate", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ model, prompt, stream: false }),
+    signal: AbortSignal.timeout(6e4)
+  });
+  if (!res.ok) throw new Error(`Ollama error: ${res.status} ${res.statusText}`);
+  const data = await res.json();
+  if (data.error) throw new Error(data.error);
+  return data.response ?? "";
+}
+async function queryOpenAI(prompt, model, apiKey) {
+  const res = await fetch("https://api.openai.com/v1/chat/completions", {
+    method: "POST",
+    headers: { "Content-Type": "application/json", "Authorization": `Bearer ${apiKey}` },
+    body: JSON.stringify({ model, messages: [{ role: "user", content: prompt }], max_tokens: 800 }),
+    signal: AbortSignal.timeout(6e4)
+  });
+  if (!res.ok) throw new Error(`OpenAI error: ${res.status} ${await res.text()}`);
+  const data = await res.json();
+  return data.choices?.[0]?.message?.content ?? "";
+}
+async function runExplainCommand(opts = {}) {
+  const {
+    since = "7d",
+    backend = "builtin",
+    model = backend === "openai" ? "gpt-4o-mini" : backend === "ollama" ? "llama3.2" : "expert-rules-v1",
+    apiKey = process.env["OPENAI_API_KEY"] ?? "",
+    dir = "./pyre-exports"
+  } = opts;
+  console.log(chalk.bold("\n  \u{1F525} pyre explain \u2014 AI Anomaly Analysis\n"));
+  const anomalies = parseAnomalies(dir, since);
+  if (anomalies.length === 0) {
+    console.log(chalk.green("  \u2714 No anomalies detected in the past " + since + "."));
+    console.log(chalk.dim("  Run pyre live --log to build a history first.\n"));
+    return;
+  }
+  if (backend === "builtin") {
+    console.log(chalk.dim(`  Analyzing ${anomalies.length} anomaly event(s) using local built-in model (${model})...
+`));
+    const alerts = anomalies.map((a) => ({
+      metric: a.metric,
+      value: a.value,
+      zScore: a.zScore,
+      severity: a.zScore >= 3.5 ? "critical" : "warning",
+      timestamp: new Date(a.timestamp)
+    }));
+    const analysis = explainAnomaliesLocally(alerts, model);
+    console.log(chalk.bold("  Analysis:\n"));
+    for (const line of analysis.split("\n")) {
+      if (line.startsWith("Diagnosis Engine:")) {
+        console.log(chalk.bold.magenta("  " + line));
+      } else if (line.startsWith("Tip:")) {
+        console.log(chalk.cyan.bold("  " + line));
+      } else if (line.startsWith("  \u2022 Recommendation:")) {
+        console.log("  " + chalk.green(line));
+      } else if (line.startsWith("  \u2022 Cause:")) {
+        console.log("  " + chalk.yellow(line));
+      } else if (line.startsWith("  \u2022 Verdict:")) {
+        console.log("  " + chalk.dim(line));
+      } else {
+        console.log("  " + chalk.dim(line));
+      }
+    }
+    console.log();
+    return;
+  }
+  console.log(chalk.dim(`  Found ${anomalies.length} anomaly event(s). Sending to ${backend} (${model})...
+`));
+  const hostname = os.hostname();
+  const prompt = buildPrompt(anomalies, hostname, since);
+  let explanation = "";
+  try {
+    if (backend === "openai") {
+      if (!apiKey) {
+        console.log(chalk.yellow("  \u26A0 No API key found."));
+        console.log(chalk.dim("  Set OPENAI_API_KEY environment variable or use --api-key <key>\n"));
+        return;
+      }
+      explanation = await queryOpenAI(prompt, model, apiKey);
+    } else {
+      explanation = await queryOllama(prompt, model);
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (backend === "ollama" && (msg.includes("ECONNREFUSED") || msg.includes("fetch failed"))) {
+      console.log(chalk.yellow("  \u26A0 Ollama server is not running at localhost:11434.\n"));
+      console.log(chalk.dim("  Switching to local built-in AI model (offline, zero-setup)...\n"));
+      const alerts = anomalies.map((a) => ({
+        metric: a.metric,
+        value: a.value,
+        zScore: a.zScore,
+        severity: a.zScore >= 3.5 ? "critical" : "warning",
+        timestamp: new Date(a.timestamp)
+      }));
+      const fallbackAnalysis = explainAnomaliesLocally(alerts, "expert-rules-v1");
+      console.log(chalk.bold("  Analysis (Built-in Heuristic Model):\n"));
+      for (const line of fallbackAnalysis.split("\n")) {
+        console.log("  " + line);
+      }
+      console.log();
+      return;
+    } else {
+      console.log(chalk.red(`  \u2716 LLM error: ${msg}
+`));
+    }
+    return;
+  }
+  if (!explanation.trim()) {
+    console.log(chalk.yellow("  \u26A0 LLM returned an empty response. Try a different model.\n"));
+    return;
+  }
+  console.log(chalk.bold("  Analysis:\n"));
+  for (const line of explanation.split("\n")) {
+    const t = line.trim();
+    if (t.startsWith("-") || t.startsWith("\u2022")) {
+      console.log(chalk.dim("  ") + chalk.white(t));
+    } else if (t.match(/^\d+\./)) {
+      console.log(chalk.dim("  ") + chalk.cyan(t));
+    } else if (t) {
+      console.log("  " + t);
+    } else {
+      console.log("");
+    }
+  }
+  console.log();
+}
+export {
+  runExplainCommand
+};