pyre-cli 7.1.0 → 8.0.0

package/dist/updateCheck-52X6LJG5.js

@@ -0,0 +1,84 @@
+// src/updateCheck.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+import https from "https";
+import chalk from "chalk";
+var UPDATE_CACHE_FILE = path.join(os.homedir(), ".config", "pyre", "update-check.json");
+function checkForUpdates(currentVersion) {
+  return new Promise((resolve) => {
+    try {
+      if (fs.existsSync(UPDATE_CACHE_FILE)) {
+        const raw = fs.readFileSync(UPDATE_CACHE_FILE, "utf-8");
+        const cached = JSON.parse(raw);
+        if (Date.now() - (cached.lastChecked || 0) < 24 * 60 * 60 * 1e3) {
+          return resolve({
+            currentVersion,
+            latestVersion: cached.latestVersion || currentVersion,
+            hasUpdate: isNewerVersion(currentVersion, cached.latestVersion)
+          });
+        }
+      }
+    } catch {
+    }
+    const req = https.get("https://registry.npmjs.org/pyre-cli/latest", { timeout: 2e3 }, (res) => {
+      let body = "";
+      res.on("data", (chunk) => body += chunk);
+      res.on("end", () => {
+        try {
+          if (res.statusCode === 200) {
+            const data = JSON.parse(body);
+            const latestVersion = data.version || currentVersion;
+            fs.mkdirSync(path.dirname(UPDATE_CACHE_FILE), { recursive: true });
+            fs.writeFileSync(UPDATE_CACHE_FILE, JSON.stringify({ lastChecked: Date.now(), latestVersion }));
+            return resolve({
+              currentVersion,
+              latestVersion,
+              hasUpdate: isNewerVersion(currentVersion, latestVersion)
+            });
+          }
+        } catch {
+        }
+        resolve(null);
+      });
+    });
+    req.on("error", () => resolve(null));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve(null);
+    });
+  });
+}
+function isNewerVersion(current, latest) {
+  if (!latest) return false;
+  const cParts = current.split(".").map((n) => parseInt(n, 10));
+  const lParts = latest.split(".").map((n) => parseInt(n, 10));
+  for (let i = 0; i < Math.max(cParts.length, lParts.length); i++) {
+    const c = cParts[i] || 0;
+    const l = lParts[i] || 0;
+    if (l > c) return true;
+    if (l < c) return false;
+  }
+  return false;
+}
+async function printUpdateReport(currentVersion) {
+  console.log(chalk.bold("\n  pyre update \u2014 Version Check\n"));
+  console.log(`  Current Version: ${chalk.bold(currentVersion)}`);
+  const result = await checkForUpdates(currentVersion);
+  if (!result) {
+    console.log(chalk.yellow("  \u26A0 Unable to reach npm registry for update check.\n"));
+    return;
+  }
+  if (result.hasUpdate) {
+    console.log(chalk.green.bold(`  \u{1F680} A new version of pyre is available: v${result.latestVersion}`));
+    console.log(chalk.dim(`  Run "npm install -g pyre-cli" to update.
+`));
+  } else {
+    console.log(chalk.green(`  \u2714 You are running the latest version of pyre (v${currentVersion}).
+`));
+  }
+}
+export {
+  checkForUpdates,
+  printUpdateReport
+};

package/package.json

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

package/parity.md

@@ -511,15 +511,22 @@ Useful for:
 
 # 14. What btop Does NOT Do
 
-Compared to macOS Activity Monitor, btop does **not** provide:
-
-* App energy impact scoring
-* Detailed GPU history graphs on all Macs
-* Network connection inspector
-* Application sandbox details
-* Launch agent management
-* System extension management
-* Full disk/file activity tracing
+---
+
+# 15. Exclusive pyre Features (Not Available in btop)
+
+pyre provides Mac-native security, diagnostics, and ecosystem capabilities that btop structurally cannot offer:
+
+* **Security & Posture Audit** — Gatekeeper enforcement (`spctl`), System Integrity Protection (`csrutil`), XProtect definition update checks in `pyre doctor`, and System Extensions inspector (`pyre extensions`).
+* **Statistical Anomaly Digest** — `pyre anomalies --since <range>` analyzes historical CSV telemetry and highlights z-score metric spikes (+2.5σ/3.5σ).
+* **Mac Ecosystem Inspectors** — Homebrew health summary (`pyre brew`), Time Machine backup status (`pyre info`), and connected display resolution/type details (`pyre info`).
+* **Memory Pressure & Pressure Level** — Wired, compressed, purgeable memory, swapins/outs, and kernel VM pressure level (`Normal`, `Warning`, `Critical`).
+* **Micro-benchmarking Energy Estimator** — `pyre bench <cmd>` calculates Watt-seconds, total kWh energy consumption, and dollar cost estimation.
+* **Grafana Infrastructure Export** — Shipped `grafana/pyre-dashboard.json` dashboard template mapping pyre's metric schema.
+* **Atomic Config Profiles** — `pyre profile save/load/list` for rapid context switching (dev, gaming, monitoring).
+* **Kill Confirmation Guard Rails** — Hard confirmation safety check when attempting to terminate protected system PIDs (`launchd`, pyre PID, parent PID).
+* **Accessible Plain-Text Mode** — `--plain`/`--a11y` mode for screen reader compatibility and clean file logging without ANSI noise.
+* **P2P Live Data Streaming & Fleet** — Multi-Mac live streaming with password/TLS auth, HMAC signing, rate-limiting, and IP filtering.
 
 ---
 

package/src/anomaliesCmd.ts

@@ -0,0 +1,151 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import chalk from 'chalk';
+
+export interface AnomaliesCmdOptions {
+  since?: string;
+  dir?: string;
+  detailed?: boolean;
+}
+
+export function runAnomaliesDigest(opts: AnomaliesCmdOptions = {}): void {
+  const dir = opts.dir || './pyre-exports';
+  const sinceStr = opts.since || '7d';
+
+  console.log(chalk.bold(`\n  pyre anomalies — Resource Spike & Anomaly Digest\n`));
+
+  if (!fs.existsSync(dir)) {
+    console.log(chalk.yellow(`  No logs directory found for range '${sinceStr}' at ${dir}.`));
+    console.log(chalk.dim('  Enable background logging with `pyre --log` to record history.\n'));
+    return;
+  }
+
+  const files = fs.readdirSync(dir).filter(f => f.startsWith('pyre-log-') && f.endsWith('.csv'));
+  if (files.length === 0) {
+    console.log(chalk.yellow(`  No CSV logs found for range '${sinceStr}' in ${dir}.`));
+    console.log(chalk.dim('  Enable background logging with `pyre --log` to record history.\n'));
+    return;
+  }
+
+  // Parse time window
+  let cutoff = Date.now() - 7 * 24 * 60 * 60 * 1000;
+  if (sinceStr === 'yesterday' || sinceStr === '1d') {
+    cutoff = Date.now() - 24 * 60 * 60 * 1000;
+  } else if (sinceStr.endsWith('d')) {
+    const d = parseInt(sinceStr.slice(0, -1), 10);
+    if (!isNaN(d)) cutoff = Date.now() - d * 24 * 60 * 60 * 1000;
+  } else if (!isNaN(Date.parse(sinceStr))) {
+    cutoff = Date.parse(sinceStr);
+  }
+
+  interface LogRow {
+    ts: Date;
+    cpu: number;
+    mem: number;
+    temp?: number;
+    topProc?: string;
+  }
+
+  const rows: LogRow[] = [];
+  for (const file of files.sort()) {
+    const fullPath = path.join(dir, file);
+    try {
+      const content = fs.readFileSync(fullPath, 'utf-8');
+      const lines = content.split('\n').slice(1);
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        const parts = line.split(',');
+        if (parts.length >= 3) {
+          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.length >= 4 ? parseFloat(parts[3]) : undefined;
+            const topProc = parts.length >= 5 ? parts[4] : undefined;
+            if (!isNaN(cpu) && !isNaN(mem)) {
+              rows.push({ ts, cpu, mem, temp: isNaN(temp!) ? undefined : temp, topProc });
+            }
+          }
+        }
+      }
+    } catch {
+      // ignore parse errors
+    }
+  }
+
+  if (rows.length < 5) {
+    console.log(chalk.yellow(`  Insufficient data recorded since ${sinceStr} (need at least 5 samples).`));
+    console.log(chalk.dim('  Run pyre with `--log` for longer intervals to build history.\n'));
+    return;
+  }
+
+  // Calculate stats
+  const cpuVals = rows.map(r => r.cpu);
+  const memVals = rows.map(r => r.mem);
+  const tempVals = rows.filter(r => r.temp !== undefined).map(r => r.temp!);
+
+  const calcMeanStd = (arr: number[]) => {
+    if (arr.length === 0) return { mean: 0, std: 0 };
+    const mean = arr.reduce((a, b) => a + b, 0) / arr.length;
+    const variance = arr.reduce((a, b) => a + Math.pow(b - mean, 2), 0) / arr.length;
+    return { mean, std: Math.sqrt(variance) };
+  };
+
+  const cpuStats = calcMeanStd(cpuVals);
+  const memStats = calcMeanStd(memVals);
+  const tempStats = calcMeanStd(tempVals);
+
+  interface DetectedAnomaly {
+    ts: Date;
+    metric: string;
+    value: number;
+    baseline: number;
+    zScore: number;
+    topProc?: string;
+  }
+
+  const anomalies: DetectedAnomaly[] = [];
+
+  for (const r of rows) {
+    if (cpuStats.std > 0) {
+      const z = (r.cpu - cpuStats.mean) / cpuStats.std;
+      if (z >= 2.5) {
+        anomalies.push({ ts: r.ts, metric: 'CPU', value: r.cpu, baseline: cpuStats.mean, zScore: z, topProc: r.topProc });
+      }
+    }
+    if (memStats.std > 0) {
+      const z = (r.mem - memStats.mean) / memStats.std;
+      if (z >= 2.5) {
+        anomalies.push({ ts: r.ts, metric: 'Memory', value: r.mem, baseline: memStats.mean, zScore: z, topProc: r.topProc });
+      }
+    }
+    if (r.temp !== undefined && tempStats.std > 0) {
+      const z = (r.temp - tempStats.mean) / tempStats.std;
+      if (z >= 2.5) {
+        anomalies.push({ ts: r.ts, metric: 'Temperature', value: r.temp, baseline: tempStats.mean, zScore: z, topProc: r.topProc });
+      }
+    }
+  }
+
+  console.log(`  Analyzed ${chalk.bold(rows.length)} samples since ${chalk.bold(sinceStr)}.`);
+  if (anomalies.length === 0) {
+    console.log(chalk.green('  ✔ No statistical anomalies detected in this time range.\n'));
+    return;
+  }
+
+  console.log(chalk.yellow(`  ⚠ Found ${anomalies.length} anomaly spike event(s):\n`));
+  for (const a of anomalies.slice(0, 15)) {
+    const timeFormatted = a.ts.toLocaleString();
+    const severityColor = a.zScore >= 3.5 ? chalk.red : chalk.yellow;
+    const unit = a.metric === 'Temperature' ? '°C' : '%';
+    console.log(`  • [${chalk.dim(timeFormatted)}] ${severityColor(a.metric)} spike: ${chalk.bold(a.value.toFixed(1) + unit)} (baseline: ${a.baseline.toFixed(1)}${unit}, +${a.zScore.toFixed(1)}σ)`);
+    if (a.topProc) {
+      console.log(chalk.dim(`     Top Process: ${a.topProc}`));
+    }
+  }
+
+  if (anomalies.length > 15) {
+    console.log(chalk.dim(`  ... and ${anomalies.length - 15} more anomaly events.`));
+  }
+  console.log();
+}

package/src/brewHealth.ts

@@ -0,0 +1,88 @@
+import chalk from 'chalk';
+import { run } from './monitors/run.js';
+
+export interface BrewHealthInfo {
+  installedCount: number;
+  outdatedCount: number;
+  cellarSize: string;
+  doctorWarnings: string[];
+  brewAvailable: boolean;
+}
+
+export async function getBrewHealth(): Promise<BrewHealthInfo> {
+  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 };
+    }
+
+    // Outdated count without triggering brew update
+    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('==>'));
+
+    // Installed list count
+    const listRaw = await run('brew list --formula -1 2>&1', '');
+    const listLines = listRaw.trim().split('\n').filter(l => l.length > 0);
+
+    // Disk usage of cellar
+    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';
+    }
+
+    // Doctor warnings
+    const doctorRaw = await run('brew doctor 2>&1', '');
+    const doctorWarnings: string[] = [];
+    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 };
+  }
+}
+
+export async function printBrewHealthReport(): Promise<void> {
+  console.log(chalk.bold('\n  pyre brew — Homebrew Health Summary\n'));
+  const health = await getBrewHealth();
+
+  if (!health.brewAvailable) {
+    console.log(chalk.yellow('  ⚠ Homebrew is not installed or not available on PATH.\n'));
+    return;
+  }
+
+  console.log(`  📦 Installed Formulae: ${chalk.bold(health.installedCount)}`);
+  console.log(`  ⏳ Outdated Packages:   ${health.outdatedCount > 0 ? chalk.yellow.bold(health.outdatedCount) : chalk.green('0 (Up to date)')}`);
+  console.log(`  💾 Cellar Disk Usage:  ${chalk.bold(health.cellarSize)}`);
+
+  console.log();
+  if (health.doctorWarnings.length === 0) {
+    console.log(chalk.green('  ✔ brew doctor: No warnings detected system-wide.'));
+  } else {
+    console.log(chalk.yellow(`  ⚠ brew doctor warnings (${health.doctorWarnings.length}):`));
+    for (const warn of health.doctorWarnings.slice(0, 5)) {
+      console.log(chalk.dim(`     • ${warn}`));
+    }
+    if (health.doctorWarnings.length > 5) {
+      console.log(chalk.dim(`     ... and ${health.doctorWarnings.length - 5} more.`));
+    }
+  }
+  console.log();
+}

package/src/doctor.ts

@@ -86,7 +86,83 @@ export async function runDoctor(): Promise<DoctorCheck[]> {
     });
   }
 
-  // 4. Config file integrity
+  // 4. Gatekeeper Status (spctl)
+  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.',
+    });
+  }
+
+  // 5. System Integrity Protection (SIP / csrutil)
+  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.',
+    });
+  }
+
+  // 6. XProtect Definition 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.',
+    });
+  }
+
+  // 7. Config file integrity
   try {
     const cfg = readConfig();
     checks.push({

package/src/easy_features.test.ts

@@ -0,0 +1,43 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { parseSystemExtensionsOutput } from './extensions.js';
+import { saveProfile, loadProfile, listProfiles } from './state/config.js';
+import { sparkline } from './sparkline.js';
+
+describe('System Extensions Parser (Feature A7)', () => {
+  it('should parse system extensions categories and active extensions', () => {
+    const mockOutput = `
+--- category com.apple.system_extension.network_extension
+* * UBF8T346G9 com.crowdstrike.falcon.Agent (1.0/1) [activated enabled]
+`;
+    const result = parseSystemExtensionsOutput(mockOutput);
+    assert.strictEqual(result.length, 1);
+    assert.strictEqual(result[0].category, 'com.apple.system_extension.network_extension');
+    assert.strictEqual(result[0].extensions.length, 1);
+    assert.strictEqual(result[0].extensions[0].bundleId, 'com.crowdstrike.falcon.Agent');
+    assert.strictEqual(result[0].extensions[0].teamId, 'UBF8T346G9');
+  });
+
+  it('should handle empty extensions output without crashing', () => {
+    const result = parseSystemExtensionsOutput('');
+    assert.ok(Array.isArray(result));
+  });
+});
+
+describe('Config Profiles (Feature D5)', () => {
+  it('should save, list, and load profiles', () => {
+    const testName = 'unit-test-profile';
+    saveProfile(testName);
+    const profiles = listProfiles();
+    assert.ok(profiles.includes(testName));
+
+    loadProfile(testName);
+  });
+});
+
+describe('Plain text sparkline (Feature F3)', () => {
+  it('should format sparkline in plain text mode', () => {
+    const res = sparkline([10, 20, 30], { plainText: true });
+    assert.strictEqual(res, '[10.0 -> 30.0 (Δ:+20.0)]');
+  });
+});

package/src/extensions.ts

@@ -0,0 +1,83 @@
+import chalk from 'chalk';
+import { run } from './monitors/run.js';
+
+export interface SystemExtensionInfo {
+  teamId: string;
+  bundleId: string;
+  version: string;
+  state: string;
+  category: string;
+}
+
+export async function getSystemExtensions(): Promise<{ category: string; extensions: SystemExtensionInfo[] }[]> {
+  try {
+    const raw = await run('systemextensionsctl list 2>&1', '');
+    return parseSystemExtensionsOutput(raw);
+  } catch (err) {
+    return [];
+  }
+}
+
+export function parseSystemExtensionsOutput(output: string): { category: string; extensions: SystemExtensionInfo[] }[] {
+  const result: { category: string; extensions: SystemExtensionInfo[] }[] = [];
+  let currentCategory = 'Other Extensions';
+  let currentList: SystemExtensionInfo[] = [];
+
+  const lines = output.split('\n');
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+
+    if (trimmed.startsWith('--- category') || trimmed.startsWith('--- ')) {
+      if (currentList.length > 0 || result.length > 0) {
+        result.push({ category: currentCategory, extensions: currentList });
+        currentList = [];
+      }
+      const catMatch = trimmed.match(/category\s+([\w\.-]+)/i);
+      currentCategory = catMatch ? catMatch[1] : trimmed.replace(/^-+\s*/, '').replace(/\s*-+$/, '');
+      continue;
+    }
+
+    const extMatch = trimmed.match(/^(?:\*\s*)*([A-Z0-9]{10}|\?\?\?\?\?\?\?\?\?\?)\s+([\w\.-]+)\s+\(([^)]+)\)\s+\[([^\]]+)\]/i);
+    if (extMatch) {
+      currentList.push({
+        teamId: extMatch[1],
+        bundleId: extMatch[2],
+        version: extMatch[3],
+        state: extMatch[4],
+        category: currentCategory,
+      });
+    }
+  }
+
+  if (currentList.length > 0 || result.length === 0) {
+    result.push({ category: currentCategory, extensions: currentList });
+  }
+
+  return result.filter(group => group.extensions.length > 0 || result.length === 1);
+}
+
+export async function printExtensionsReport(): Promise<void> {
+  console.log(chalk.bold('\n  pyre extensions — System Extensions Inspector\n'));
+  const categories = await getSystemExtensions();
+
+  let totalCount = 0;
+  for (const cat of categories) {
+    totalCount += cat.extensions.length;
+    console.log(chalk.cyan.bold(`  📂 ${cat.category}`));
+    if (cat.extensions.length === 0) {
+      console.log(chalk.dim('     (No extensions registered in this category)'));
+      continue;
+    }
+    for (const ext of cat.extensions) {
+      const stateColor = ext.state.includes('activated') || ext.state.includes('enabled') ? chalk.green : chalk.yellow;
+      console.log(`     • ${chalk.bold(ext.bundleId)} (${ext.version})`);
+      console.log(chalk.dim(`       Team: ${ext.teamId} | State: `) + stateColor(ext.state));
+    }
+    console.log();
+  }
+
+  if (totalCount === 0) {
+    console.log(chalk.dim('  No active system extensions detected on this system.\n'));
+  }
+}