pyre-cli 6.0.0 → 7.0.0

package/src/formatters/render.ts

@@ -10,7 +10,7 @@
  * all layout-related code is co-located.
  */
 import chalk from 'chalk';
-import { sparkline, multiRowSparkline } from '../sparkline.js';
+import { sparkline, multiRowSparkline, brailleGraph } from '../sparkline.js';
 import type { History } from '../history.js';
 import type { StatsData, VisibleItems, TableOptions, AnomalyAlert } from './types.js';
 import { THEMES, type ThemeName, type ThemeColors } from './themes.js';
@@ -90,8 +90,8 @@ export function panel(
   } else if (visLen(topInner) < innerW) {
     topInner = topInner + '─'.repeat(innerW - visLen(topInner));
   }
-  const top = borderAccent('┌' + topInner + '┐');
-  const bottom = borderAccent('└' + '─'.repeat(innerW) + '┘');
+  const top = borderAccent('╭' + topInner + '╮');
+  const bottom = borderAccent('╰' + '─'.repeat(innerW) + '╯');
   const body: string[] = [];
   for (let i = 0; i < h; i++) {
     const line = lines[i] ?? '';
@@ -103,12 +103,19 @@ export function panel(
 export function gaugeBar(percent: number, width = 12): string {
   const w = Math.max(1, width);
   const pct = Math.min(100, Math.max(0, percent));
-  const filled = Math.round((pct / 100) * w);
-  const empty = w - filled;
-  const filledStr = '█'.repeat(filled);
-  const emptyStr = '░'.repeat(empty);
+  const totalEighths = Math.round((pct / 100) * w * 8);
+  const fullBlocks = Math.floor(totalEighths / 8);
+  const remainder = totalEighths % 8;
+  const blocks = [' ', '▏', '▎', '▍', '▌', '▋', '▊', '▉', '█'];
+  
+  let str = '█'.repeat(fullBlocks);
+  if (fullBlocks < w && remainder > 0) {
+    str += blocks[remainder];
+  }
+  const empty = Math.max(0, w - visLen(str));
+  
   const color = pct > 85 ? chalk.red : pct > 65 ? chalk.yellow : chalk.cyan;
-  return color(filledStr) + chalk.dim(emptyStr);
+  return color(str) + chalk.dim('─'.repeat(empty));
 }
 
 /** Join equal-or-uneven-height panel blocks side by side with a gap. */
@@ -141,23 +148,40 @@ function statRow(label: string, value: string, width = 9): string {
 }
 
 function bar(percent: number, width = 20): string {
-  const filled = Math.round((Math.min(100, Math.max(0, percent)) / 100) * width);
-  const empty = width - filled;
-  const filledStr = '█'.repeat(Math.max(0, filled));
-  const emptyStr = '░'.repeat(Math.max(0, empty));
+  const w = Math.max(1, width);
+  const pct = Math.min(100, Math.max(0, percent));
+  const totalEighths = Math.round((pct / 100) * w * 8);
+  const fullBlocks = Math.floor(totalEighths / 8);
+  const remainder = totalEighths % 8;
+  const blocks = [' ', '▏', '▎', '▍', '▌', '▋', '▊', '▉', '█'];
+  
+  let str = '█'.repeat(fullBlocks);
+  if (fullBlocks < w && remainder > 0) {
+    str += blocks[remainder];
+  }
+  const empty = Math.max(0, w - visLen(str));
   const color = percent > 90 ? chalk.red : percent > 70 ? chalk.yellow : chalk.green;
-  return color(filledStr + emptyStr);
+  return color(str) + chalk.dim('─'.repeat(empty));
 }
 
 function gaugeRow(label: string, percent: number, contentWidth: number): string {
   const labelW = 9;
   const pctText = `${Math.round(percent)}%`;
   const barW = Math.max(6, contentWidth - labelW - pctText.length - 1);
-  const filled = Math.round((Math.min(100, Math.max(0, percent)) / 100) * barW);
-  const empty = barW - filled;
-  const barStr = '█'.repeat(Math.max(0, filled)) + '░'.repeat(Math.max(0, empty));
-  const color = percent > 90 ? chalk.red : percent > 70 ? chalk.yellow : chalk.green;
-  return `${chalk.dim(label.padEnd(labelW))}${color(barStr)} ${pctText}`;
+  const pct = Math.min(100, Math.max(0, percent));
+  
+  const totalEighths = Math.round((pct / 100) * barW * 8);
+  const fullBlocks = Math.floor(totalEighths / 8);
+  const remainder = totalEighths % 8;
+  const blocks = [' ', '▏', '▎', '▍', '▌', '▋', '▊', '▉', '█'];
+  
+  let str = '█'.repeat(fullBlocks);
+  if (fullBlocks < barW && remainder > 0) {
+    str += blocks[remainder];
+  }
+  const empty = Math.max(0, barW - visLen(str));
+  const color = pct > 90 ? chalk.red : pct > 70 ? chalk.yellow : chalk.green;
+  return `${chalk.dim(label.padEnd(labelW))}${color(str)}${chalk.dim('─'.repeat(empty))} ${pctText}`;
 }
 
 export function thermalColor(pressureLevel: number) {
@@ -360,6 +384,7 @@ export const TAB_DEFS: { id: string; label: string; key: string }[] = [
   { id: 'disk', label: 'Disk', key: '0' },
   { id: 'process', label: 'Process', key: 'P' },
   { id: 'p2p', label: 'P2P', key: 'R' },
+  { id: 'anomalies', label: 'Anomalies', key: 'A' },
 ];
 
 /** The number of leading columns of indent before the tab bar's first character (see `tabBar`). */
@@ -662,6 +687,20 @@ function activeDetailLines(data: StatsData, activePanel: string, width: number,
       }
       return processTableLines(limited, width - 4, theme.border);
     }
+    case 'anomalies': {
+      if (!opts.anomalyHistory || opts.anomalyHistory.length === 0) return ['No anomalies detected yet.'];
+      const lines: string[] = [];
+      // Sort by timestamp descending
+      const sorted = [...opts.anomalyHistory].sort((a, b) => (b.timestamp?.getTime() || 0) - (a.timestamp?.getTime() || 0));
+      for (const a of sorted) {
+        const color = a.severity === 'critical' ? chalk.red.bold : chalk.yellow;
+        const direction = a.zScore > 0 ? '↑ spike' : '↓ drop';
+        const valStr = a.metric.toLowerCase().includes('net') ? `${formatBytes(a.value)}/s` : `${a.value.toFixed(1)}%`;
+        const timeStr = a.timestamp ? a.timestamp.toLocaleTimeString() : '';
+        lines.push(color(` ${timeStr.padEnd(10)} ⚠ ${a.metric.padEnd(8)}: ${valStr.padEnd(12)} (${direction}, σ=${a.zScore.toFixed(1)})`));
+      }
+      return lines;
+    }
     default:
       return null;
   }
@@ -714,7 +753,7 @@ function btopCpuBox(data: StatsData, width: number, theme: ThemeColors, opts: Ta
     if (data.cpu.coreUsage && data.cpu.coreUsage.length) {
       const coreColW = Math.floor((rightW - 1) / 2);
       const half = Math.ceil(data.cpu.coreUsage.length / 2);
-      for (let i = 0; i < Math.min(2, half); i++) {
+      for (let i = 0; i < half; i++) {
         const u1 = data.cpu.coreUsage[i];
         const u2 = data.cpu.coreUsage[i + half];
         const c1BarW = Math.max(3, coreColW - 8);
@@ -735,7 +774,9 @@ function btopCpuBox(data: StatsData, width: number, theme: ThemeColors, opts: Ta
     lines.push(chalk.bold(truncatePlain(data.cpu.brand, contentWidth)));
     lines.push(`CPU ${gaugeBar(data.cpu.usage, Math.max(4, contentWidth - 12))} ${data.cpu.usage.toFixed(0)}%`);
     if (opts.history?.cpuUsage.length) {
-      lines.push(theme.cpu(sparkline(opts.history.cpuUsage, { min: 0, max: 100 })));
+      const gMode = opts.graphMode || 'spark';
+      const gStr = gMode === 'bar' ? sparkline(opts.history.cpuUsage, { min: 0, max: 100 }) : brailleGraph(opts.history.cpuUsage, { min: 0, max: 100 });
+      lines.push(theme.cpu(gStr));
     }
     lines.push(`Load: ${data.cpu.loadAvg.map(l => l.toFixed(2)).join(' ')}`);
     return panel('1 cpu', lines, width, theme.cpu, theme.border, lines.length, rightTitle);
@@ -745,46 +786,62 @@ function btopCpuBox(data: StatsData, width: number, theme: ThemeColors, opts: Ta
 function btopLeftColumn(data: StatsData, width: number, theme: ThemeColors, opts: TableOptions): string[] {
   const contentWidth = width - 4;
   const out: string[] = [];
+  const layout = opts.panelLayout || ['mem', 'disk', 'net'];
+
+  for (const panelName of layout) {
+    if (panelName === 'mem') {
+      // --- Box 1: 2 mem ---
+      const memLines: string[] = [];
+      memLines.push(`RAM [${gaugeBar(data.memory.usagePercent, Math.max(4, contentWidth - 12))}] ${data.memory.usagePercent}%`);
+      memLines.push(`Used: ${formatBytes(data.memory.used)} / ${formatBytes(data.memory.total)}`);
+      memLines.push(`Free: ${formatBytes(data.memory.free)} · Cache: ${formatBytes(data.memory.total - data.memory.free - data.memory.used)}`);
+      if (data.memory.swapTotal > 0) {
+        const swapPct = Math.round((data.memory.swapUsed / data.memory.swapTotal) * 100);
+        memLines.push(`Swap [${gaugeBar(swapPct, Math.max(4, contentWidth - 12))}] ${swapPct}%`);
+      }
+      out.push(...panel('2 mem', memLines, width, theme.mem, theme.border, memLines.length, `${formatBytes(data.memory.used)}`));
+    } else if (panelName === 'disk' && data.disk.length) {
+      // --- Box 2: 0 disk ---
+      const diskLines: string[] = [];
+      for (const d of data.disk.slice(0, 2)) {
+        const capNum = parseInt(d.capacity, 10) || 0;
+        const mountShort = truncatePlain(d.mountpoint, 8);
+        let ioStr = '';
+        if (d.readBytesSec !== undefined || d.writeBytesSec !== undefined) {
+          const rStr = formatBytes(d.readBytesSec || 0);
+          const wStr = formatBytes(d.writeBytesSec || 0);
+          ioStr = ` R:${rStr}/s W:${wStr}/s`;
+        }
+        diskLines.push(`${mountShort} ${d.used}/${d.size} [${gaugeBar(capNum, Math.max(3, contentWidth - 18 - ioStr.length))}] ${d.capacity}${ioStr}`);
+      }
+      const totalRead = data.disk.reduce((acc, d) => acc + (d.readBytesSec || 0), 0);
+      const totalWrite = data.disk.reduce((acc, d) => acc + (d.writeBytesSec || 0), 0);
+      const diskHeaderRight = `R:${formatBytes(totalRead)}/s W:${formatBytes(totalWrite)}/s`;
+      out.push(...panel('0 disk io', diskLines, width, theme.disk, theme.border, diskLines.length, diskHeaderRight));
+    } else if (panelName === 'net') {
+      // --- Box 3: 7 net ---
+      const netLines: string[] = [];
+      const rxRate = opts.history?.netRxRate.length ? opts.history.netRxRate[opts.history.netRxRate.length - 1] : 0;
+      const txRate = opts.history?.netTxRate.length ? opts.history.netTxRate[opts.history.netTxRate.length - 1] : 0;
+
+      netLines.push(`down ▼ ${formatBytes(rxRate)}/s (${formatBytes(data.network.rxBytes)})`);
+      if (opts.history?.netRxRate.length) {
+        const gMode = opts.graphMode || 'spark';
+        const gStr = gMode === 'bar' ? sparkline(opts.history.netRxRate, {}) : brailleGraph(opts.history.netRxRate, {});
+        netLines.push(chalk.cyan(fitVisible(gStr, contentWidth)));
+      }
 
-  // --- Box 1: 2 mem ---
-  const memLines: string[] = [];
-  memLines.push(`RAM [${gaugeBar(data.memory.usagePercent, Math.max(4, contentWidth - 12))}] ${data.memory.usagePercent}%`);
-  memLines.push(`Used: ${formatBytes(data.memory.used)} / ${formatBytes(data.memory.total)}`);
-  memLines.push(`Free: ${formatBytes(data.memory.free)} · Cache: ${formatBytes(data.memory.total - data.memory.free - data.memory.used)}`);
-  if (data.memory.swapTotal > 0) {
-    const swapPct = Math.round((data.memory.swapUsed / data.memory.swapTotal) * 100);
-    memLines.push(`Swap [${gaugeBar(swapPct, Math.max(4, contentWidth - 12))}] ${swapPct}%`);
-  }
-  out.push(...panel('2 mem', memLines, width, theme.mem, theme.border, memLines.length, `${formatBytes(data.memory.used)}`));
-
-  // --- Box 2: 0 disk ---
-  if (data.disk.length) {
-    const diskLines: string[] = [];
-    for (const d of data.disk.slice(0, 2)) {
-      const capNum = parseInt(d.capacity, 10) || 0;
-      const mountShort = truncatePlain(d.mountpoint, 8);
-      diskLines.push(`${mountShort} ${d.used}/${d.size} [${gaugeBar(capNum, Math.max(3, contentWidth - 18))}] ${d.capacity}`);
-    }
-    out.push(...panel('0 disk io', diskLines, width, theme.disk, theme.border, diskLines.length));
-  }
-
-  // --- Box 3: 7 net ---
-  const netLines: string[] = [];
-  const rxRate = opts.history?.netRxRate.length ? opts.history.netRxRate[opts.history.netRxRate.length - 1] : 0;
-  const txRate = opts.history?.netTxRate.length ? opts.history.netTxRate[opts.history.netTxRate.length - 1] : 0;
-
-  netLines.push(`down ▼ ${formatBytes(rxRate)}/s (${formatBytes(data.network.rxBytes)})`);
-  if (opts.history?.netRxRate.length) {
-    netLines.push(chalk.cyan(fitVisible(sparkline(opts.history.netRxRate, {}), contentWidth)));
-  }
+      netLines.push(`up   ▲ ${formatBytes(txRate)}/s (${formatBytes(data.network.txBytes)})`);
+      if (opts.history?.netTxRate.length) {
+        const gMode = opts.graphMode || 'spark';
+        const gStr = gMode === 'bar' ? sparkline(opts.history.netTxRate, {}) : brailleGraph(opts.history.netTxRate, {});
+        netLines.push(theme.network(fitVisible(gStr, contentWidth)));
+      }
 
-  netLines.push(`up   ▲ ${formatBytes(txRate)}/s (${formatBytes(data.network.txBytes)})`);
-  if (opts.history?.netTxRate.length) {
-    netLines.push(theme.network(fitVisible(sparkline(opts.history.netTxRate, {}), contentWidth)));
+      out.push(...panel('7 net', netLines, width, theme.network, theme.border, netLines.length, `${data.network.interface}`));
+    }
   }
 
-  out.push(...panel('7 net', netLines, width, theme.network, theme.border, netLines.length, `${data.network.interface}`));
-
   return out;
 }
 

package/src/formatters/themes.ts

@@ -8,7 +8,11 @@
  */
 import chalk from 'chalk';
 
-export type ThemeName = 'default' | 'dracula' | 'cyberpunk' | 'monochrome' | 'nord' | 'gruvbox';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+export type ThemeName = string;
 
 export interface ThemeColors {
    border: (s: string) => string;
@@ -24,16 +28,7 @@ export interface ThemeColors {
    process: (s: string) => string;
 }
 
-/**
- * Built-in colour themes.
- *
- * - **default** — muted greys and cyan accents, safe for any terminal.
- * - **dracula**  — the popular Dracula dark palette.
- * - **cyberpunk** — high-contrast neon on black.
- * - **monochrome** — white-only, useful for colour-blind users or
- *   terminals without 256-colour support.
- */
-export const THEMES: Record<ThemeName, ThemeColors> = {
+export const BUILTIN_THEMES: Record<string, ThemeColors> = {
    default: {
      border: chalk.hex('#4b5563'),
      cpu: chalk.hex('#22d3ee'),
@@ -112,4 +107,44 @@ export const THEMES: Record<ThemeName, ThemeColors> = {
       graphs: chalk.hex('#fb4934'),
       process: chalk.hex('#ebdbb2'),
     },
-  };
+  };
+
+export function loadCustomThemes(): Record<string, ThemeColors> {
+  const themes = { ...BUILTIN_THEMES };
+  const themesDir = path.join(os.homedir(), '.config', 'pyre', 'themes');
+  try {
+    if (fs.existsSync(themesDir)) {
+      const files = fs.readdirSync(themesDir);
+      for (const file of files) {
+        if (file.endsWith('.json')) {
+          const name = path.basename(file, '.json');
+          try {
+            const raw = fs.readFileSync(path.join(themesDir, file), 'utf-8');
+            const data = JSON.parse(raw);
+            const buildColor = (val?: string) => (val ? (val.startsWith('#') ? chalk.hex(val) : (chalk as any)[val] || chalk.white) : chalk.white);
+            themes[name] = {
+              border: buildColor(data.border),
+              cpu: buildColor(data.cpu),
+              mem: buildColor(data.mem),
+              gpu: buildColor(data.gpu),
+              power: buildColor(data.power),
+              battery: buildColor(data.battery),
+              thermal: buildColor(data.thermal),
+              network: buildColor(data.network),
+              disk: buildColor(data.disk),
+              graphs: buildColor(data.graphs),
+              process: buildColor(data.process),
+            };
+          } catch {
+            // ignore bad theme file
+          }
+        }
+      }
+    }
+  } catch {
+    // ignore directory read error
+  }
+  return themes;
+}
+
+export const THEMES: Record<string, ThemeColors> = loadCustomThemes();

package/src/formatters/types.ts

@@ -48,6 +48,7 @@ export interface AnomalyAlert {
   value: number;
   zScore: number;
   severity: 'warning' | 'critical';
+  timestamp?: Date;
 }
 
 export interface TableOptions {
@@ -66,13 +67,17 @@ export interface TableOptions {
     /** Show process tree view instead of flat list. */
     treeView?: boolean;
     /** Active panel for detail/focus view. 'grid' means show all panels. */
-    activePanel?: 'grid' | 'cpu' | 'mem' | 'gpu' | 'power' | 'battery' | 'thermal' | 'network' | 'packets' | 'tasks' | 'disk' | 'process' | 'p2p';
+    activePanel?: 'grid' | 'cpu' | 'mem' | 'gpu' | 'power' | 'battery' | 'thermal' | 'network' | 'packets' | 'tasks' | 'disk' | 'process' | 'p2p' | 'anomalies';
     /** Active anomaly alerts from the statistical detector. */
     anomalies?: AnomalyAlert[];
+    /** Historical anomaly alerts for the anomalies tab. */
+    anomalyHistory?: AnomalyAlert[];
     /** Temperature display unit: 'c' or 'f'. */
     tempUnit?: 'c' | 'f';
     /** Rolling history instance for live graphs. */
     history?: History;
     /** Graph mode: 'spark' or 'bar'. */
     graphMode?: 'spark' | 'bar';
+    /** Panel layout order. */
+    panelLayout?: string[];
 }

package/src/historyCmd.ts

@@ -0,0 +1,71 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import chalk from 'chalk';
+import { sparkline } from './sparkline.js';
+
+export interface HistoryOptions {
+  days?: number;
+  dir?: string;
+}
+
+export function runHistoryCommand(opts: HistoryOptions = {}): void {
+  const days = opts.days || 7;
+  const dir = opts.dir || './pyre-exports';
+
+  console.log(chalk.bold(`\n  pyre history — Past ${days} Days Trend\n`));
+
+  if (!fs.existsSync(dir)) {
+    console.log(chalk.yellow(`  No logs directory found at ${dir}`));
+    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 in ${dir}`));
+    return;
+  }
+
+  const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;
+  const cpuPoints: number[] = [];
+  const memPoints: number[] = [];
+  const tempPoints: number[] = [];
+
+  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 >= 4) {
+          const tsStr = parts[0];
+          const ts = new Date(tsStr).getTime();
+          if (!isNaN(ts) && ts >= cutoff) {
+            const cpu = parseFloat(parts[1]);
+            const mem = parseFloat(parts[2]);
+            const temp = parseFloat(parts[3]);
+            if (!isNaN(cpu)) cpuPoints.push(cpu);
+            if (!isNaN(mem)) memPoints.push(mem);
+            if (!isNaN(temp)) tempPoints.push(temp);
+          }
+        }
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  if (cpuPoints.length === 0) {
+    console.log(chalk.yellow(`  No historical entries recorded within the last ${days} days.`));
+    return;
+  }
+
+  console.log(`  Data Points: ${cpuPoints.length} logged snapshots`);
+  console.log(`  CPU Usage:   ${sparkline(cpuPoints, { min: 0, max: 100 })} (${(cpuPoints.reduce((a, b) => a + b, 0) / cpuPoints.length).toFixed(1)}% avg)`);
+  console.log(`  Memory:      ${sparkline(memPoints, { min: 0, max: 100 })} (${(memPoints.reduce((a, b) => a + b, 0) / memPoints.length).toFixed(1)}% avg)`);
+  if (tempPoints.length) {
+    console.log(`  Temperature: ${sparkline(tempPoints)} (${(tempPoints.reduce((a, b) => a + b, 0) / tempPoints.length).toFixed(1)}°C avg)`);
+  }
+  console.log();
+}

package/src/index.ts

@@ -17,8 +17,13 @@ import { formatTable, formatJson, formatCsv, formatTsv, formatHtml, formatMarkdo
 import { startLive, stopLive } from './live/index.js';
 import { showSplash } from './splash.js';
 import { P2PServer, P2PClient } from './p2p/index.js';
-import { readConfig } from './state/config.js';
-import { CONFIG_FILE } from './state/config.js';
+import { runDoctor, printDoctorReport } from './doctor.js';
+import { generateZshCompletions, generateBashCompletions, generateFishCompletions } from './completions.js';
+import { runHistoryCommand } from './historyCmd.js';
+import { runDiffCommand } from './diffCmd.js';
+import { readConfig, CONFIG_FILE } from './state/config.js';
+import { generateXbarPlugin } from './xbar.js';
+import { runFleetCommand } from './fleet.js';
 
 const config = readConfig();
 
@@ -62,6 +67,8 @@ program
     .option('--p2p-deny <ips>', 'Comma-separated list of denied IPs')
     .option('--p2p-audit-log <dir>', 'Directory for P2P audit logs')
     .option('--p2p-hmac-key <key>', 'HMAC key for message signing (default: derived from password)')
+    .option('--webhook-url <url>', 'URL to POST to on alert')
+    .option('--alert-cmd <cmd>', 'Command to execute on alert')
     .option('--port <port>', 'Port number for web server mode', '3000');
 
 program.parse(process.argv);
@@ -83,6 +90,21 @@ function sanitizeHost(host: string): string {
 
 function detectLocalIP(): string | null {
   const ifaces = os.networkInterfaces();
+  const prioritizedNames = ['en0', 'en1', 'wlan0', 'eth0'];
+  
+  // 1. Try prioritized active interfaces
+  for (const name of prioritizedNames) {
+    const addrs = ifaces[name];
+    if (addrs) {
+      for (const addr of addrs) {
+        if (addr.family === 'IPv4' && !addr.internal) {
+          return addr.address;
+        }
+      }
+    }
+  }
+
+  // 2. Fallback to any non-internal IPv4
   for (const [, addrs] of Object.entries(ifaces)) {
     if (!addrs) continue;
     for (const addr of addrs) {
@@ -123,8 +145,21 @@ async function runServerCommand(): Promise<void> {
 async function main() {
   const cmd = program.args[0];
 
-  if (cmd === 'info') {
-    await runInfoCommand();
+  if (cmd === 'history') {
+    const daysIdx = program.args.indexOf('--days');
+    const days = daysIdx !== -1 ? parseInt(program.args[daysIdx + 1], 10) || 7 : 7;
+    runHistoryCommand({ days });
+    return;
+  }
+
+  if (cmd === 'diff') {
+    const file1 = program.args[1];
+    const file2 = program.args[2];
+    if (!file1 || !file2) {
+      console.log(chalk.red('Usage: pyre diff <snapshot1.json> <snapshot2.json>'));
+      process.exit(1);
+    }
+    runDiffCommand(file1, file2);
     return;
   }
 
@@ -172,8 +207,26 @@ async function main() {
     return;
   }
 
-  const alertCpu = opts.alertCpu ? parseInt(opts.alertCpu, 10) : undefined;
-  const alertTemp = opts.alertTemp ? parseInt(opts.alertTemp, 10) : undefined;
+  if (cmd === 'xbar') {
+    generateXbarPlugin();
+    return;
+  }
+
+  if (cmd === 'fleet') {
+    const hosts = program.args.slice(1);
+    if (hosts.length === 0) {
+      console.error(chalk.red('Usage: pyre fleet <host1> [host2] ...'));
+      process.exit(1);
+    }
+    runFleetCommand(hosts);
+    return;
+  }
+
+  if (opts.alertCpu) config.cpuAlertPct = Number(opts.alertCpu);
+  if (opts.alertTemp) config.tempAlertC = Number(opts.alertTemp);
+  if (opts.webhookUrl) config.webhookUrl = opts.webhookUrl;
+  if (opts.alertCmd) config.alertCmd = opts.alertCmd;
+  if (opts.exportDir) config.exportDir = opts.exportDir;
   const tempUnit = opts.tempUnit === 'f' ? 'f' : 'c';
 
   if (cmd === 'live' || (!isExportMode() && !opts.once && cmd !== 'p2p')) {
@@ -196,8 +249,8 @@ async function main() {
       theme: opts.theme || config.theme,
       exportDir: opts.exportDir || config.exportDir,
       autoLog: opts.log || config.autoLog,
-      alertCpu,
-      alertTemp,
+      alertCpu: config.cpuAlertPct,
+      alertTemp: config.tempAlertC,
       tempUnit,
     }, splashPromise);
     return;
@@ -494,17 +547,56 @@ async function runWebCommand(): Promise<void> {
 
   const server = http.createServer(async (req, res) => {
     const url = req.url || '/';
+
+    // 1. Health check endpoint
+    if (url === '/health' || url === '/api/health') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ status: 'ok', uptime: process.uptime(), timestamp: new Date().toISOString() }));
+      return;
+    }
+
+    // 3. Real-time Server-Sent Events (SSE) stream endpoint
+    if (url === '/api/stream') {
+      res.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        'Connection': 'keep-alive',
+        'Access-Control-Allow-Origin': '*',
+      });
+
+      const sendStats = async () => {
+        try {
+          const data = await collectAll({ detailed: true });
+          res.write(`data: ${JSON.stringify(data)}\n\n`);
+        } catch {
+          // ignore stream collect error
+        }
+      };
+
+      sendStats();
+      const intervalId = setInterval(sendStats, 2000);
+
+      req.on('close', () => {
+        clearInterval(intervalId);
+      });
+      return;
+    }
+
+    // 4. Static/Dynamic HTML live dashboard & API snapshot endpoints
     if (url === '/' || url === '/index.html') {
+      res.writeHead(200, { 'Content-Type': 'text/html' });
+      const data = await collectAll({ detailed: true });
+      const htmlContent = formatHtml(data);
+      res.end(htmlContent);
+    } else if (url === '/setup') {
       res.writeHead(200, { 'Content-Type': 'text/html' });
       const indexPath = path.join(process.cwd(), 'index.html');
-      let htmlContent = '';
       if (fs.existsSync(indexPath)) {
-        htmlContent = fs.readFileSync(indexPath, 'utf-8');
+        res.end(fs.readFileSync(indexPath, 'utf-8'));
       } else {
         const data = await collectAll({ detailed: true });
-        htmlContent = formatHtml(data);
+        res.end(formatHtml(data));
       }
-      res.end(htmlContent);
     } else if (url === '/api' || url === '/api/stats' || url === '/data') {
       const data = await collectAll({ detailed: true });
       res.writeHead(200, {
@@ -519,11 +611,30 @@ async function runWebCommand(): Promise<void> {
     }
   });
 
+  server.on('error', (err: any) => {
+    if (err.code === 'EADDRINUSE') {
+      console.log(chalk.red(`\nError: Port ${port} is already in use.`));
+      console.log(chalk.yellow(`  Try specifying a different port using --port <port>, e.g.:`));
+      console.log(chalk.dim(`  npx tsx src/index.ts web --port ${port + 1}\n`));
+      process.exit(1);
+    } else {
+      console.log(chalk.red(`Server error: ${err.message}`));
+      process.exit(1);
+    }
+  });
+
+  const ip = detectLocalIP() || 'localhost';
+
   server.listen(port, '0.0.0.0', () => {
     console.log(chalk.bold(`\n  pyre web server running on port ${port}`));
-    console.log(chalk.dim(`  Dashboard: http://0.0.0.0:${port}/`));
-    console.log(chalk.dim(`  API:       http://0.0.0.0:${port}/api`));
-    console.log(chalk.dim('  Press Ctrl+C to stop\n'));
+    console.log(chalk.dim(`  Local URL:   http://localhost:${port}/`));
+    console.log(chalk.hex('#ff6a39').bold(`  Network URL: http://${ip}:${port}/  (Accessible on same Wi-Fi / LAN)`));
+    console.log(chalk.dim(`  API:         http://${ip}:${port}/api`));
+    console.log(chalk.dim(`  SSE Stream:  http://${ip}:${port}/api/stream`));
+    console.log(chalk.yellow(`\n  Troubleshooting connection from phone/other devices:`));
+    console.log(chalk.dim(`  1. macOS Firewall: System Settings -> Network -> Firewall -> Allow incoming node/pyre connections`));
+    console.log(chalk.dim(`  2. Wi-Fi Router: Ensure "AP Isolation" / "Guest Mode" is OFF on your Wi-Fi router`));
+    console.log(chalk.dim(`  3. Verify phone is connected to the exact same Wi-Fi network\n`));
   });
 
   process.once('SIGINT', () => {

package/src/live/input.ts

@@ -189,12 +189,20 @@ function handleInputModeKey(str: string, key: readline.Key) {
 
    if (key.name === 'backspace') {
      state.inputBuffer = state.inputBuffer.slice(0, -1);
+     if (state.inputMode === 'filter') {
+       state.processFilter = state.inputBuffer;
+       invalidateTableCache();
+     }
      render();
      return;
    }
 
    if (str && str.length === 1 && !key.ctrl && !key.meta) {
      state.inputBuffer += str;
+     if (state.inputMode === 'filter') {
+       state.processFilter = state.inputBuffer;
+       invalidateTableCache();
+     }
      render();
    }
  }