pyre-cli 9.4.0 → 9.5.1

package/dist/pipeCmd-7THXEGDH.js

@@ -0,0 +1,39 @@
+import "./chunk-SG26Y3WF.js";
+import {
+  collectAll
+} from "./chunk-HGRBBPYX.js";
+import "./chunk-FH5WDJBF.js";
+
+// src/pipeCmd.ts
+async function runPipeCommand(opts = {}) {
+  const intervalMs = opts.intervalMs ?? 1e3;
+  const maxSamples = opts.samples ?? 0;
+  let count = 0;
+  const emitSample = async () => {
+    try {
+      const data = await collectAll({ detailed: opts.detailed });
+      process.stdout.write(JSON.stringify(data) + "\n");
+      count++;
+      if (maxSamples > 0 && count >= maxSamples) {
+        process.exit(0);
+      }
+    } catch (err) {
+      process.stderr.write(`Error collecting stats: ${err.message}
+`);
+    }
+  };
+  await emitSample();
+  if (maxSamples > 0 && count >= maxSamples) {
+    return;
+  }
+  const timer = setInterval(async () => {
+    await emitSample();
+  }, intervalMs);
+  process.once("SIGINT", () => {
+    clearInterval(timer);
+    process.exit(0);
+  });
+}
+export {
+  runPipeCommand
+};

package/dist/prometheus-LFYHF6VO.js

@@ -0,0 +1,56 @@
+// src/prometheus.ts
+function formatPrometheusMetrics(data) {
+  const lines = [];
+  const addGauge = (name, help, val, labels = {}) => {
+    if (val === void 0 || Number.isNaN(val)) return;
+    lines.push(`# HELP ${name} ${help}`);
+    lines.push(`# TYPE ${name} gauge`);
+    const labelStr = Object.entries(labels).map(([k, v]) => `${k}="${v}"`).join(",");
+    const labelSuffix = labelStr ? `{${labelStr}}` : "";
+    lines.push(`${name}${labelSuffix} ${val}`);
+  };
+  addGauge("pyre_cpu_usage_percent", "CPU usage percentage", data.cpu.usage);
+  addGauge("pyre_cpu_frequency_mhz", "CPU frequency in MHz", data.cpu.frequency);
+  addGauge("pyre_cpu_cores_physical", "Physical CPU core count", data.cpu.physicalCores);
+  addGauge("pyre_cpu_cores_logical", "Logical CPU core count", data.cpu.cores);
+  if (data.cpu.loadAvg && data.cpu.loadAvg.length >= 3) {
+    addGauge("pyre_cpu_load_1m", "1-minute load average", data.cpu.loadAvg[0]);
+    addGauge("pyre_cpu_load_5m", "5-minute load average", data.cpu.loadAvg[1]);
+    addGauge("pyre_cpu_load_15m", "15-minute load average", data.cpu.loadAvg[2]);
+  }
+  if (data.cpu.temperature) {
+    addGauge("pyre_cpu_temperature_celsius", "CPU die temperature in Celsius", data.cpu.temperature);
+  }
+  addGauge("pyre_memory_total_bytes", "Total RAM in bytes", data.memory.total);
+  addGauge("pyre_memory_used_bytes", "Used RAM in bytes", data.memory.used);
+  addGauge("pyre_memory_free_bytes", "Free RAM in bytes", data.memory.free);
+  addGauge("pyre_memory_usage_percent", "Memory usage percentage", data.memory.usagePercent);
+  if (data.memory.swapTotal) {
+    addGauge("pyre_memory_swap_total_bytes", "Total swap memory in bytes", data.memory.swapTotal);
+    addGauge("pyre_memory_swap_used_bytes", "Used swap memory in bytes", data.memory.swapUsed);
+  }
+  if (data.gpu) {
+    addGauge("pyre_gpu_utilization_percent", "GPU utilization percentage", data.gpu.utilization, { model: data.gpu.model });
+    addGauge("pyre_gpu_memory_bytes", "GPU memory size in bytes", data.gpu.memory, { model: data.gpu.model });
+    if (data.gpu.temperature) {
+      addGauge("pyre_gpu_temperature_celsius", "GPU temperature in Celsius", data.gpu.temperature, { model: data.gpu.model });
+    }
+  }
+  if (data.power) {
+    if (data.power.cpuWatts) addGauge("pyre_power_cpu_watts", "CPU power draw in Watts", data.power.cpuWatts);
+    if (data.power.gpuWatts) addGauge("pyre_power_gpu_watts", "GPU power draw in Watts", data.power.gpuWatts);
+    if (data.power.combinedWatts) addGauge("pyre_power_system_watts", "Combined system power draw in Watts", data.power.combinedWatts);
+  }
+  if (data.battery) {
+    addGauge("pyre_battery_level_percent", "Battery level percentage", data.battery.level);
+    if (data.battery.cycles) addGauge("pyre_battery_cycle_count", "Battery cycle count", data.battery.cycles);
+    if (data.battery.maxCapacityPercent) addGauge("pyre_battery_max_capacity_percent", "Battery health maximum capacity percentage", data.battery.maxCapacityPercent);
+  }
+  addGauge("pyre_thermal_pressure_level", "Thermal pressure level (0=Nominal, 1=Fair, 2=Serious, 3=Critical)", data.thermal.pressureLevel);
+  addGauge("pyre_network_rx_bytes_total", "Total network received bytes", data.network.rxBytes);
+  addGauge("pyre_network_tx_bytes_total", "Total network transmitted bytes", data.network.txBytes);
+  return lines.join("\n") + "\n";
+}
+export {
+  formatPrometheusMetrics
+};

package/dist/service-WTS3NBQU.js

@@ -0,0 +1,73 @@
+// src/service.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { execSync } from "child_process";
+import chalk from "chalk";
+var PLIST_LABEL = "com.pyre.web";
+var PLIST_PATH = path.join(os.homedir(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
+function installLaunchdAgent(port = 3e3) {
+  const nodePath = process.execPath;
+  const scriptPath = path.resolve(process.argv[1]);
+  const plistContent = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${PLIST_LABEL}</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${nodePath}</string>
+        <string>${scriptPath}</string>
+        <string>web</string>
+        <string>--port</string>
+        <string>${port}</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>StandardOutPath</key>
+    <string>${path.join(os.homedir(), ".config", "pyre", "web.log")}</string>
+    <key>StandardErrorPath</key>
+    <string>${path.join(os.homedir(), ".config", "pyre", "web.err")}</string>
+</dict>
+</plist>
+`;
+  try {
+    const launchAgentsDir = path.dirname(PLIST_PATH);
+    if (!fs.existsSync(launchAgentsDir)) {
+      fs.mkdirSync(launchAgentsDir, { recursive: true });
+    }
+    fs.writeFileSync(PLIST_PATH, plistContent);
+    try {
+      execSync(`launchctl unload ${PLIST_PATH} 2>/dev/null`);
+    } catch {
+    }
+    execSync(`launchctl load ${PLIST_PATH}`);
+    console.log(chalk.green(`\u2714 Installed and started launchd agent at ${PLIST_PATH}`));
+    console.log(chalk.dim(`  Service label: ${PLIST_LABEL}`));
+  } catch (err) {
+    console.log(chalk.red(`\u2716 Failed to install launchd agent: ${err.message}`));
+  }
+}
+function uninstallLaunchdAgent() {
+  try {
+    if (fs.existsSync(PLIST_PATH)) {
+      try {
+        execSync(`launchctl unload ${PLIST_PATH} 2>/dev/null`);
+      } catch {
+      }
+      fs.unlinkSync(PLIST_PATH);
+      console.log(chalk.green(`\u2714 Uninstalled launchd agent ${PLIST_PATH}`));
+    } else {
+      console.log(chalk.yellow(`  No launchd agent found at ${PLIST_PATH}`));
+    }
+  } catch (err) {
+    console.log(chalk.red(`\u2716 Failed to uninstall launchd agent: ${err.message}`));
+  }
+}
+export {
+  installLaunchdAgent,
+  uninstallLaunchdAgent
+};

package/dist/stressCmd-MFXMFXYX.js

@@ -0,0 +1,51 @@
+// src/stressCmd.ts
+import { Worker, isMainThread, workerData } from "worker_threads";
+import os from "os";
+import chalk from "chalk";
+if (!isMainThread) {
+  const endTime = workerData?.endTime;
+  while (true) {
+    if (endTime && Date.now() >= endTime) {
+      break;
+    }
+    Math.hypot(Math.random(), Math.random());
+  }
+  process.exit(0);
+}
+async function runStressCommand(opts = {}) {
+  const durationSec = opts.durationSec ?? 30;
+  const numCores = opts.cores ?? os.cpus().length;
+  const endTime = Date.now() + durationSec * 1e3;
+  console.log(chalk.bold(`
+  pyre stress \u2014 Synthetic Load Generator`));
+  console.log(chalk.dim(`  Spawning ${numCores} worker threads for ${durationSec} seconds...`));
+  console.log(chalk.dim(`  Press Ctrl+C to stop early.
+`));
+  const workers = [];
+  for (let i = 0; i < numCores; i++) {
+    const worker = new Worker(new URL(import.meta.url), {
+      workerData: { endTime }
+    });
+    workers.push(worker);
+  }
+  const cleanup = () => {
+    for (const w of workers) {
+      w.terminate();
+    }
+  };
+  process.once("SIGINT", () => {
+    cleanup();
+    console.log(chalk.yellow("\n  Stress test cancelled by user."));
+    process.exit(0);
+  });
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      cleanup();
+      console.log(chalk.green(`  \u2714 Synthetic load test completed after ${durationSec}s.`));
+      resolve();
+    }, durationSec * 1e3);
+  });
+}
+export {
+  runStressCommand
+};

package/dist/wizard-GVIAHIVV.js

@@ -0,0 +1,55 @@
+import {
+  CONFIG_FILE,
+  writeConfig
+} from "./chunk-RVGKEJXT.js";
+
+// src/wizard.ts
+import readline from "readline";
+import chalk from "chalk";
+import fs from "fs";
+async function runSetupWizardIfNeeded(skipWizardFlag) {
+  if (skipWizardFlag || process.env.PYRE_NO_WIZARD === "1" || !process.stdout.isTTY) {
+    return;
+  }
+  if (fs.existsSync(CONFIG_FILE)) {
+    return;
+  }
+  console.log(chalk.bold("\n  \u{1F525} Welcome to pyre! First-run Setup Wizard\n"));
+  console.log(chalk.dim("  This quick 3-question setup configures your defaults.\n"));
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const ask = (query) => {
+    return new Promise((resolve) => rl.question(query, resolve));
+  };
+  try {
+    console.log(chalk.cyan("  1. Pick a default color theme:"));
+    console.log(chalk.dim("     (1) default  (2) dracula  (3) cyberpunk  (4) monochrome  (5) nord  (6) gruvbox"));
+    const themeAns = (await ask(chalk.yellow("     Choice [1-6] (default: 1): "))).trim();
+    let theme = "default";
+    if (themeAns === "2") theme = "dracula";
+    else if (themeAns === "3") theme = "cyberpunk";
+    else if (themeAns === "4") theme = "monochrome";
+    else if (themeAns === "5") theme = "nord";
+    else if (themeAns === "6") theme = "gruvbox";
+    console.log(chalk.cyan("\n  2. Enable desktop notifications on system thermal/CPU alerts?"));
+    const notifAns = (await ask(chalk.yellow("     Enable notifications? [Y/n]: "))).trim().toLowerCase();
+    const notificationsEnabled = notifAns !== "n";
+    console.log(chalk.cyan("\n  3. Sudo / Powermetrics setup:"));
+    console.log(chalk.dim("     pyre reads basic metrics sudolessly. For detailed per-core wattages,"));
+    console.log(chalk.dim("     you can optionally grant passwordless sudo for powermetrics later."));
+    await ask(chalk.yellow("     Press Enter to finish setup... "));
+    writeConfig({
+      theme,
+      notificationsEnabled
+    });
+    console.log(chalk.green("\n  \u2714 Preferences saved to ~/.config/pyre/config.json\n"));
+  } catch {
+  } finally {
+    rl.close();
+  }
+}
+export {
+  runSetupWizardIfNeeded
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pyre-cli",
-  "version": "9.4.0",
+  "version": "9.5.1",
   "description": "CLI Mac monitoring tool: temps, system stats, live dashboard, packet monitor, battery predictor, export",
   "main": "dist/index.js",
   "type": "module",

package/src/checkCmd.ts

@@ -0,0 +1,83 @@
+import chalk from 'chalk';
+import { collectAll } from './monitors/index.js';
+import { formatBytes } from './formatters/render.js';
+
+export interface CheckOptions {
+  exitCode?: boolean;
+  cpuAlertPct?: number;
+  tempAlertC?: number;
+  detailed?: boolean;
+}
+
+export async function runCheckCommand(opts: CheckOptions = {}): Promise<void> {
+  const data = await collectAll({ detailed: opts.detailed });
+
+  const cpuUsage = data.cpu.usage;
+  const tempC = data.cpu.temperature ?? data.thermal.temperatures?.cpu_die;
+  const memUsage = data.memory.usagePercent;
+  const disk = data.disk.mainVolume;
+
+  const sentences: string[] = [];
+  let isWarning = false;
+
+  // CPU & Temp sentence
+  const tempStr = tempC !== undefined ? `${Math.round(tempC)}°C` : null;
+  const cpuAlertThreshold = opts.cpuAlertPct ?? 90;
+  const tempAlertThreshold = opts.tempAlertC ?? 95;
+
+  if (cpuUsage >= cpuAlertThreshold || (tempC !== undefined && tempC >= tempAlertThreshold)) {
+    isWarning = true;
+    if (tempStr) {
+      sentences.push(`CPU running hot at ${tempStr}, ${Math.round(cpuUsage)}% used.`);
+    } else {
+      sentences.push(`CPU load is high at ${Math.round(cpuUsage)}% used.`);
+    }
+  } else {
+    if (tempStr) {
+      sentences.push(`CPU running cool at ${tempStr}, ${Math.round(cpuUsage)}% used.`);
+    } else {
+      sentences.push(`CPU running normally at ${Math.round(cpuUsage)}% used.`);
+    }
+  }
+
+  // Memory & Battery sentence
+  if (data.battery) {
+    if (data.battery.friendlySummary) {
+      if (data.battery.friendlySummary.toLowerCase().includes('service') || data.battery.friendlySummary.toLowerCase().includes('reduced')) {
+        isWarning = true;
+      }
+      sentences.push(data.battery.friendlySummary);
+    } else {
+      let healthStr = 'health good';
+      if (data.battery.health.toLowerCase().includes('service') || data.battery.health.toLowerCase().includes('check')) {
+        healthStr = 'service recommended';
+        isWarning = true;
+      }
+      sentences.push(`Battery at ${data.battery.level}%, ${healthStr}.`);
+    }
+  } else {
+    sentences.push(`Memory at ${Math.round(memUsage)}% used.`);
+  }
+
+  // Disk sentence
+  if (disk) {
+    const freeBytes = disk.free;
+    const freeStr = formatBytes(freeBytes);
+    sentences.push(`${freeStr} free on ${disk.mount}.`);
+    if (disk.usePercent >= 90) {
+      isWarning = true;
+    }
+  }
+
+  const summaryText = sentences.join(' ');
+
+  if (isWarning) {
+    console.log(chalk.yellow(`⚠ ${summaryText}`));
+  } else {
+    console.log(chalk.green(`✔ ${summaryText}`));
+  }
+
+  if (opts.exitCode && isWarning) {
+    process.exit(1);
+  }
+}

package/src/fleet.ts

@@ -1,31 +1,32 @@
-import { execSync } from 'node:child_process';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
 import chalk from 'chalk';
 import { formatTable } from './formatters/render.js';
 import type { StatsData } from './monitors/types.js';
 
-export function runFleetCommand(hosts: string[]) {
-  console.log(chalk.cyan(`Fetching data from ${hosts.length} hosts...`));
-  const results: { host: string; data?: StatsData; error?: string }[] = [];
+const execAsync = promisify(exec);
 
-  for (const host of hosts) {
+export async function runFleetCommand(hosts: string[]): Promise<void> {
+  console.log(chalk.cyan(`Fetching concurrent data from ${hosts.length} fleet host(s)...`));
+
+  const promises = hosts.map(async (host) => {
     try {
-      // Connect to each host via ssh and run pyre
-      const out = execSync(`ssh ${host} "pyre --once --json"`, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] });
-      const data = JSON.parse(out) as StatsData;
-      results.push({ host, data });
+      const { stdout } = await execAsync(`ssh -o ConnectTimeout=5 ${host} "pyre --once --json"`);
+      const data = JSON.parse(stdout) as StatsData;
+      return { host, data };
     } catch (e: any) {
-      results.push({ host, error: e.message });
+      return { host, error: e.message || String(e) };
     }
-  }
+  });
+
+  const results = await Promise.all(promises);
 
-  // Very basic grid layout for fleet
   for (const result of results) {
-    console.log(chalk.bold.blue(`\n=== ${result.host} ===\n`));
+    console.log(chalk.bold.blue(`\n=== Host: ${result.host} ===\n`));
     if (result.error) {
-      console.log(chalk.red(`Error connecting to host: ${result.error}`));
+      console.log(chalk.red(`  ✖ Error connecting to host: ${result.error}`));
     } else if (result.data) {
-      // Print a compact table for each host
-      console.log(formatTable(result.data, { width: process.stdout.columns || 80, activePanel: 'grid' }));
+      console.log(formatTable(result.data, { width: process.stdout.columns || 80, minimal: true }));
     }
   }
 }

package/src/formatters/render.ts

@@ -184,17 +184,25 @@ function gaugeRow(label: string, percent: number, contentWidth: number): string
   return `${chalk.dim(label.padEnd(labelW))}${color(str)}${chalk.dim('─'.repeat(empty))} ${pctText}`;
 }
 
+export function statusSymbol(level: 'ok' | 'warn' | 'crit'): string {
+  if (level === 'crit') return '✕ ';
+  if (level === 'warn') return '⚠ ';
+  return '✓ ';
+}
+
 export function thermalColor(pressureLevel: number) {
-  if (pressureLevel >= 3) return chalk.red;
-  if (pressureLevel === 2) return chalk.yellow;
-  if (pressureLevel === 1) return chalk.yellowBright;
-  return chalk.green;
+  const symbol = pressureLevel >= 3 ? '✕ ' : pressureLevel >= 1 ? '⚠ ' : '✓ ';
+  if (pressureLevel >= 3) return (s: string) => chalk.red(symbol + s);
+  if (pressureLevel === 2) return (s: string) => chalk.yellow(symbol + s);
+  if (pressureLevel === 1) return (s: string) => chalk.yellowBright(symbol + s);
+  return (s: string) => chalk.green(symbol + s);
 }
 
 export function capacityColor(percent: number) {
-  if (percent < 80) return chalk.red;
-  if (percent < 90) return chalk.yellow;
-  return chalk.green;
+  const symbol = percent < 80 ? '✕ ' : percent < 90 ? '⚠ ' : '✓ ';
+  if (percent < 80) return (s: string) => chalk.red(symbol + s);
+  if (percent < 90) return (s: string) => chalk.yellow(symbol + s);
+  return (s: string) => chalk.green(symbol + s);
 }
 
 export function formatBytes(bytes: number): string {
@@ -232,6 +240,11 @@ function cpuCard(data: StatsData, contentWidth: number): string[] {
     gaugeRow('Usage', data.cpu.usage, contentWidth),
     statRow('Load', data.cpu.loadAvg.map(l => l.toFixed(2)).join(' ')),
   ];
+  if (data.cpu.clusters && data.cpu.clusters.length) {
+    for (const cl of data.cpu.clusters) {
+      lines.push(statRow(cl.name, `${cl.frequencyMhz} MHz · eff ${cl.effectiveUsagePercent}% · act ${cl.activeResidencyPercent}%`));
+    }
+  }
   if (data.cpu.coreUsage && data.cpu.coreUsage.length) {
     const slotW = 2;
     const maxCores = Math.max(1, Math.floor((contentWidth - 10) / (slotW + 1)));
@@ -275,6 +288,7 @@ function gpuCard(data: StatsData, contentWidth: number): string[] | null {
    if (data.power) {
      if (data.power.cpuWatts !== undefined) lines.push(statRow('CPU', `${data.power.cpuWatts.toFixed(2)} W`));
      if (data.power.gpuWatts !== undefined) lines.push(statRow('GPU', `${data.power.gpuWatts.toFixed(2)} W`));
+     lines.push(statRow('ANE', `${(data.power.aneWatts ?? 0).toFixed(2)} W`));
      if (data.power.combinedWatts !== undefined) lines.push(statRow('Total', `${data.power.combinedWatts.toFixed(2)} W`));
    }
    if (data.battery?.powerWatts !== undefined && data.battery.powerWatts > 0) {
@@ -769,9 +783,15 @@ function btopCpuBox(data: StatsData, width: number, theme: ThemeColors, opts: Ta
     const rightW = contentWidth - leftW - 2;
 
     const leftLines: string[] = [];
-    leftLines.push(fitVisible(theme.cpu('CPU Usage History'), leftW));
-
     const cpuHistory = opts.history?.cpuUsage || [];
+    let historyLabel = 'CPU Usage History';
+    if (cpuHistory.length > 0) {
+      const avg = Math.round(cpuHistory.reduce((a, b) => a + b, 0) / cpuHistory.length);
+      const max = Math.round(Math.max(...cpuHistory));
+      historyLabel += ` (avg ${avg}% · max ${max}%)`;
+    }
+    leftLines.push(fitVisible(theme.cpu(historyLabel), leftW));
+
     if (cpuHistory.length > 1) {
       const graphRows = multiRowBrailleGraph(cpuHistory, 3, { min: 0, max: 100 });
       for (const gr of graphRows) {
@@ -1005,6 +1025,23 @@ export function formatTable(data: StatsData, opts: TableOptions = {}): string {
   out.push(tabBar(activePanel, width, theme));
   out.push('');
 
+  if (opts.minimal) {
+    const contentWidth = width - 4;
+    const lines: string[] = [];
+    lines.push(gaugeRow('CPU', data.cpu.usage, contentWidth));
+    lines.push(gaugeRow('Memory', data.memory.usagePercent, contentWidth));
+    if (data.gpu) {
+      lines.push(gaugeRow('GPU', data.gpu.utilization, contentWidth));
+    }
+    const tempC = data.cpu.temperature ?? data.thermal.temperatures?.cpu_die;
+    if (tempC !== undefined) {
+      const tempStr = formatTempUnit(tempC, opts.tempUnit);
+      lines.push(statRow('Temp', thermalColor(data.thermal.pressureLevel)(tempStr)));
+    }
+    out.push(...panel('macmon mode', lines, width, theme.cpu, theme.border));
+    return out.join('\n');
+  }
+
   if (activePanel !== 'grid') {
     const lines = activeDetailLines(data, activePanel, width, opts);
     if (lines) {

package/src/formatters/types.ts

@@ -86,4 +86,6 @@ export interface TableOptions {
     trackedPid?: number | null;
     /** Currently inspected process details for modal overlay. */
     inspectProcess?: any;
+    /** Minimal mode: renders only CPU, GPU, Memory, and Temperature as large glanceable gauges. */
+    minimal?: boolean;
 }