pyre-cli 6.0.0 → 7.0.0

package/package.json

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

package/src/anomalies.ts

@@ -13,6 +13,7 @@ export interface AnomalyAlert {
   value: number;
   zScore: number;
   severity: 'warning' | 'critical';
+  timestamp?: Date;
 }
 
 const ZSCORE_THRESHOLD = 2.5;

package/src/completions.ts

@@ -0,0 +1,118 @@
+export function generateZshCompletions(): string {
+  return `#compdef pyre
+
+_pyre() {
+    local -a commands
+    commands=(
+        'live:Start interactive live monitoring dashboard'
+        'info:Display static system overview'
+        'doctor:Run system permissions and diagnostic checks'
+        'web:Launch web dashboard server'
+        'config:Show or reset configuration options'
+        'p2p:P2P streaming server or client'
+        'ssh:Stream metrics over SSH'
+        'bench:Benchmark command while logging system stats'
+        'completions:Generate shell completion scripts'
+    )
+
+    _arguments -s \\
+        '(-j --json)'{-j,--json}'[Output snapshot as JSON]' \\
+        '--html[Output snapshot as HTML]' \\
+        '--md[Output snapshot as Markdown]' \\
+        '(-c --csv)'{-c,--csv}'[Output snapshot as CSV]' \\
+        '(-t --tsv)'{-t,--tsv}'[Output snapshot as TSV]' \\
+        '--detailed[Include detailed system info and sensor readings]' \\
+        '--theme[Default theme]:theme:(default dracula cyberpunk monochrome nord gruvbox)' \\
+        '--interval[Refresh interval in seconds]:seconds:' \\
+        '--once[Show a single static snapshot]' \\
+        '--out[Write snapshot output to file]:file:_files' \\
+        '--export-dir[Directory for snapshot exports and logs]:directory:_files -/' \\
+        '--log[Start continuous CSV logging]' \\
+        '--tree[Show process tree view]' \\
+        '--sort[Sort processes by]:key:(cpu mem pid user command state threads runtime)' \\
+        '--packets[Include packet monitor panel]' \\
+        '--limit[Max processes to include]:count:' \\
+        '--alert-cpu[CPU alert threshold pct]:pct:' \\
+        '--alert-temp[CPU alert threshold temp C]:temp:' \\
+        '--temp-unit[Temperature display unit]:unit:(c f)' \\
+        '*::command:->command'
+
+    case $state in
+        command)
+            _describe -t commands 'pyre command' commands
+            ;;
+    esac
+}
+
+_pyre "$@"
+`;
+}
+
+export function generateBashCompletions(): string {
+  return `# bash completion for pyre
+
+_pyre_completions() {
+    local cur prev opts commands
+    COMPREPLY=()
+    cur="\${COMP_WORDS[COMP_CWORD]}"
+    prev="\${COMP_WORDS[COMP_CWORD-1]}"
+    commands="live info doctor web config p2p ssh bench completions"
+    opts="--json --html --md --csv --tsv --detailed --theme --interval --once --out --export-dir --log --tree --sort --packets --limit --alert-cpu --alert-temp --temp-unit"
+
+    case "\${prev}" in
+        --theme)
+            COMPREPLY=( $(compgen -W "default dracula cyberpunk monochrome nord gruvbox" -- \${cur}) )
+            return 0
+            ;;
+        --sort)
+            COMPREPLY=( $(compgen -W "cpu mem pid user command state threads runtime" -- \${cur}) )
+            return 0
+            ;;
+        --temp-unit)
+            COMPREPLY=( $(compgen -W "c f" -- \${cur}) )
+            return 0
+            ;;
+        config)
+            COMPREPLY=( $(compgen -W "show reset" -- \${cur}) )
+            return 0
+            ;;
+        p2p)
+            COMPREPLY=( $(compgen -W "server connect" -- \${cur}) )
+            return 0
+            ;;
+    esac
+
+    if [[ \${cur} == -* ]] ; then
+        COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+        return 0
+    fi
+
+    COMPREPLY=( $(compgen -W "\${commands}" -- \${cur}) )
+}
+
+complete -F _pyre_completions pyre
+`;
+}
+
+export function generateFishCompletions(): string {
+  return `# fish completion for pyre
+
+complete -c pyre -n "__fish_use_subcommand" -a live -d "Start interactive live monitoring dashboard"
+complete -c pyre -n "__fish_use_subcommand" -a info -d "Display static system overview"
+complete -c pyre -n "__fish_use_subcommand" -a doctor -d "Run system diagnostics"
+complete -c pyre -n "__fish_use_subcommand" -a web -d "Launch web dashboard server"
+complete -c pyre -n "__fish_use_subcommand" -a config -d "Show or reset configuration options"
+complete -c pyre -n "__fish_use_subcommand" -a p2p -d "P2P streaming mode"
+complete -c pyre -n "__fish_use_subcommand" -a completions -d "Generate shell completions"
+
+complete -c pyre -l json -s j -d "Output snapshot as JSON"
+complete -c pyre -l html -d "Output snapshot as HTML"
+complete -c pyre -l md -d "Output snapshot as Markdown"
+complete -c pyre -l csv -s c -d "Output snapshot as CSV"
+complete -c pyre -l tsv -s t -d "Output snapshot as TSV"
+complete -c pyre -l detailed -d "Include detailed system info and sensor readings"
+complete -c pyre -l theme -x -a "default dracula cyberpunk monochrome nord gruvbox" -d "Set color theme"
+complete -c pyre -l sort -x -a "cpu mem pid user command state threads runtime" -d "Sort processes by key"
+complete -c pyre -l temp-unit -x -a "c f" -d "Temperature unit"
+`;
+}

package/src/diffCmd.ts

@@ -0,0 +1,36 @@
+import fs from 'node:fs';
+import chalk from 'chalk';
+import type { StatsData } from './monitors/types.js';
+
+export function runDiffCommand(file1: string, file2: string): void {
+  console.log(chalk.bold(`\n  pyre diff — Snapshot Comparison\n`));
+  console.log(chalk.dim(`  Snapshot A: ${file1}`));
+  console.log(chalk.dim(`  Snapshot B: ${file2}\n`));
+
+  try {
+    const dataA: StatsData = JSON.parse(fs.readFileSync(file1, 'utf-8'));
+    const dataB: StatsData = JSON.parse(fs.readFileSync(file2, 'utf-8'));
+
+    const diffNum = (label: string, valA: number, valB: number, unit = '') => {
+      const delta = valB - valA;
+      const sign = delta > 0 ? '+' : '';
+      const color = delta > 0 ? chalk.red : delta < 0 ? chalk.green : chalk.dim;
+      console.log(`  ${label.padEnd(20)} ${valA.toFixed(1)}${unit} ➔ ${valB.toFixed(1)}${unit} (${color(sign + delta.toFixed(1) + unit)})`);
+    };
+
+    diffNum('CPU Usage', dataA.cpu.usage, dataB.cpu.usage, '%');
+    diffNum('Memory Usage', dataA.memory.usagePercent, dataB.memory.usagePercent, '%');
+    if (dataA.cpu.temperature && dataB.cpu.temperature) {
+      diffNum('CPU Temp', dataA.cpu.temperature, dataB.cpu.temperature, '°C');
+    }
+    if (dataA.gpu && dataB.gpu) {
+      diffNum('GPU Util', dataA.gpu.utilization, dataB.gpu.utilization, '%');
+    }
+    diffNum('Network RX Packets', dataA.network.rxPackets, dataB.network.rxPackets);
+    diffNum('Network TX Packets', dataA.network.txPackets, dataB.network.txPackets);
+
+    console.log();
+  } catch (err: any) {
+    console.log(chalk.red(`Failed to compare snapshots: ${err.message}`));
+  }
+}

package/src/doctor.ts

@@ -0,0 +1,123 @@
+import chalk from 'chalk';
+import { run } from './monitors/run.js';
+import { readConfig, CONFIG_FILE } from './state/config.js';
+
+export interface DoctorCheck {
+  name: string;
+  status: 'ok' | 'warn' | 'error';
+  message: string;
+  details?: string;
+}
+
+export async function runDoctor(): Promise<DoctorCheck[]> {
+  const checks: DoctorCheck[] = [];
+
+  // 1. Sudo / Powermetrics Access
+  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.',
+    });
+  }
+
+  // 2. TCC / System Permissions
+  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.',
+    });
+  }
+
+  // 3. Network Reachability for P2P
+  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.',
+    });
+  }
+
+  // 4. Config file integrity
+  try {
+    const cfg = readConfig();
+    checks.push({
+      name: 'Configuration File',
+      status: 'ok',
+      message: `Config file valid (${CONFIG_FILE}).`,
+    });
+  } catch (err: any) {
+    checks.push({
+      name: 'Configuration File',
+      status: 'error',
+      message: 'Failed to parse config file.',
+      details: err.message,
+    });
+  }
+
+  return checks;
+}
+
+export function printDoctorReport(checks: DoctorCheck[]): void {
+  console.log(chalk.bold('\n  pyre doctor — System Diagnostics\n'));
+
+  for (const check of checks) {
+    let icon = chalk.green('✔');
+    if (check.status === 'warn') icon = chalk.yellow('⚠');
+    if (check.status === 'error') icon = chalk.red('✖');
+
+    console.log(`  ${icon} ${chalk.bold(check.name.padEnd(26))} ${check.message}`);
+    if (check.details) {
+      console.log(chalk.dim(`     ↳ ${check.details}`));
+    }
+  }
+  console.log();
+}

package/src/fleet.ts

@@ -0,0 +1,31 @@
+import { execSync } from 'node:child_process';
+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 }[] = [];
+
+  for (const host of hosts) {
+    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 });
+    } catch (e: any) {
+      results.push({ host, error: e.message });
+    }
+  }
+
+  // Very basic grid layout for fleet
+  for (const result of results) {
+    console.log(chalk.bold.blue(`\n=== ${result.host} ===\n`));
+    if (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' }));
+    }
+  }
+}

package/src/formatters/output.ts

@@ -159,21 +159,118 @@ export function formatHtml(data: StatsData): string {
 <meta name="viewport" content="width=device-width, initial-scale=1.0">
 <title>pyre — ${data.header.hostname}</title>
 <style>
-  body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; background: #1e1e2e; color: #cdd6f4; margin: 0; padding: 24px; }
-  h1 { color: #ff6a39; margin-bottom: 4px; }
-  .meta { color: #a6adc8; margin-bottom: 24px; }
-  h2 { color: #89b4fa; margin-top: 28px; border-bottom: 1px solid #313244; padding-bottom: 6px; }
-  table { width: 100%; border-collapse: collapse; margin-bottom: 16px; }
-  td { padding: 6px 10px; border-bottom: 1px solid #313244; vertical-align: top; }
-  td.label { color: #a6adc8; width: 22%; font-weight: 500; }
-  td.value { color: #cdd6f4; }
+  body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; background: #0a0908; color: #efe9dc; margin: 0; padding: 24px; }
+  h1 { color: #ff6a39; margin-bottom: 4px; font-weight: 800; letter-spacing: -0.02em; }
+  .meta { color: #9c9384; margin-bottom: 24px; font-size: 0.9rem; }
+  h2 { color: #ffb130; margin-top: 28px; border-bottom: 1px solid #211d18; padding-bottom: 6px; font-size: 1.1rem; }
+  table { width: 100%; border-collapse: collapse; margin-bottom: 16px; font-family: monospace; }
+  td { padding: 8px 12px; border-bottom: 1px solid #1a1712; vertical-align: top; font-size: 0.9rem; }
+  td.label { color: #9c9384; width: 22%; font-weight: 600; }
+  td.value { color: #efe9dc; }
   tr:last-child td { border-bottom: none; }
 </style>
 </head>
 <body>
-  <h1>PYRE</h1>
-  <div class="meta">${escapeHtml(data.header.hostname)} · ${escapeHtml(data.header.os)} · up ${escapeHtml(data.header.uptime)} · ${escapeHtml(data.timestamp)}</div>
+  <h1>PYRE <span style="font-size:0.5em; color:#82c774; font-weight:normal;">● LIVE PORTAL</span></h1>
+  <div class="meta" id="header-meta">${escapeHtml(data.header.hostname)} · ${escapeHtml(data.header.os)} · up ${escapeHtml(data.header.uptime)} · <span id="timestamp-val">${escapeHtml(data.timestamp)}</span></div>
+  <div id="portal-content">
   ${sections.join('\n  ')}
+  </div>
+
+  <script>
+    function renderStats(data) {
+      if (!data) return;
+      const tsEl = document.getElementById('timestamp-val');
+      if (tsEl && data.timestamp) tsEl.textContent = data.timestamp;
+
+      function formatBytes(bytes) {
+        if (!bytes || bytes < 0) return '0 B';
+        if (bytes < 1024) return bytes + ' B';
+        if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + ' KB';
+        if (bytes < 1024 * 1024 * 1024) return (bytes / (1024 * 1024)).toFixed(1) + ' MB';
+        return (bytes / (1024 * 1024 * 1024)).toFixed(2) + ' GB';
+      }
+
+      function row(label, val) {
+        return '<tr><td class="label">' + label + '</td><td class="value">' + val + '</td></tr>';
+      }
+
+      let html = '';
+
+      // CPU & Memory
+      html += '<h2>CPU & Memory</h2><table>';
+      if (data.cpu) {
+        html += row('Brand', data.cpu.brand || 'Unknown');
+        html += row('Cores', (data.cpu.physicalCores || '') + '/' + (data.cpu.cores || '') + ' (phys/log)');
+        html += row('Usage', (data.cpu.usage || 0) + '%');
+        if (data.cpu.loadAvg) html += row('Load Avg', data.cpu.loadAvg.map(l => l.toFixed(2)).join(' '));
+        if (data.cpu.temperature) html += row('Temperature', data.cpu.temperature.toFixed(1) + '°C');
+      }
+      if (data.memory) {
+        html += row('Memory Usage', data.memory.usagePercent + '% (' + formatBytes(data.memory.used) + ' / ' + formatBytes(data.memory.total) + ')');
+        html += row('Swap Used', formatBytes(data.memory.swapUsed) + ' / ' + formatBytes(data.memory.swapTotal));
+      }
+      html += '</table>';
+
+      // GPU
+      if (data.gpu) {
+        html += '<h2>GPU</h2><table>';
+        html += row('Model', data.gpu.model || '');
+        html += row('Utilization', (data.gpu.utilization || 0) + '%');
+        html += row('Memory', formatBytes(data.gpu.memory));
+        if (data.gpu.temperature) html += row('Temperature', data.gpu.temperature.toFixed(1) + '°C');
+        html += '</table>';
+      }
+
+      // Network
+      if (data.network) {
+        html += '<h2>Network</h2><table>';
+        html += row('Interface', (data.network.interface || '') + ' (' + (data.network.ip || '') + ')');
+        html += row('RX', formatBytes(data.network.rxBytes) + ' / ' + (data.network.rxPackets || 0) + ' pkt');
+        html += row('TX', formatBytes(data.network.txBytes) + ' / ' + (data.network.txPackets || 0) + ' pkt');
+        html += '</table>';
+      }
+
+      // Disk
+      if (data.disk && data.disk.length) {
+        html += '<h2>Disk</h2><table>';
+        data.disk.forEach(d => {
+          let io = '';
+          if (d.readBytesSec !== undefined || d.writeBytesSec !== undefined) {
+            io = ' | R: ' + formatBytes(d.readBytesSec || 0) + '/s W: ' + formatBytes(d.writeBytesSec || 0) + '/s';
+          }
+          html += row(d.mountpoint, d.used + ' / ' + d.size + ' (' + d.capacity + ')' + io);
+        });
+        html += '</table>';
+      }
+
+      // Processes
+      if (data.processes && data.processes.length) {
+        html += '<h2>Processes (Top ' + Math.min(50, data.processes.length) + ')</h2><table>';
+        data.processes.slice(0, 50).forEach(p => {
+          html += row(String(p.pid), p.user + ' &nbsp; CPU: ' + p.cpu.toFixed(1) + '% &nbsp; MEM: ' + p.mem.toFixed(1) + '% &nbsp; ' + p.command);
+        });
+        html += '</table>';
+      }
+
+      const contentEl = document.getElementById('portal-content');
+      if (contentEl) contentEl.innerHTML = html;
+    }
+
+    if (window.EventSource) {
+      const evtSource = new EventSource('/api/stream');
+      evtSource.onmessage = function(event) {
+        try {
+          const data = JSON.parse(event.data);
+          renderStats(data);
+        } catch(e) {}
+      };
+    } else {
+      setInterval(function() {
+        fetch('/api').then(r => r.json()).then(renderStats).catch(function(){});
+      }, 2000);
+    }
+  </script>
 </body>
 </html>`;
 }