pyre-cli 2.0.0 → 3.1.0

package/package.json

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

package/src/formatters/index.ts

@@ -11,7 +11,7 @@
  * - `render.ts` — dashboard layout, cards, tables, and the main `formatTable`
  * - `output.ts` — JSON/CSV/TSV export and sparkline graph rendering
  */
-export { formatTable, clampWidth, gridColumns, thermalColor, capacityColor, getTabHitboxes, TAB_BAR_ROW, TAB_DEFS } from './render.js';
+export { formatTable, clampWidth, gridColumns, thermalColor, capacityColor, getTabHitboxes, TAB_BAR_ROW, TAB_DEFS, panel } from './render.js';
 export { formatJson, formatCsv, formatTsv, formatGraphs } from './output.js';
 export type { ThemeName, ThemeColors, VisibleItems, TableOptions } from './types.js';
 export { THEMES } from './themes.js';

package/src/formatters/render.ts

@@ -275,7 +275,8 @@ export const TAB_DEFS: { id: string; label: string; key: string }[] = [
   { id: 'packets', label: 'Packets', key: '8' },
   { id: 'tasks', label: 'Tasks', key: '9' },
   { id: 'disk', label: 'Disk', key: '0' },
-  { id: 'process', label: 'Process', key: 'p' },
+  { id: 'process', label: 'Process', key: 'P' },
+  { id: 'p2p', label: 'P2P', key: 'R' },
 ];
 
 /** The number of leading columns of indent before the tab bar's first character (see `tabBar`). */

package/src/index.ts

@@ -37,7 +37,17 @@ program
     .option('--limit <n>', 'Max number of processes to include in --once/--json/--csv/--tsv snapshots (0 = all)', '10')
     .option('--p2p-host <host>', 'P2P host address (server: bind address, client: server address)', '0.0.0.0')
     .option('--p2p-port <port>', 'P2P port number', '9876')
-    .option('--p2p-password <password>', 'Password for P2P authentication');
+    .option('--p2p-password <password>', 'Password for P2P authentication')
+    .option('--p2p-tls', 'Enable TLS encryption for P2P connections')
+    .option('--p2p-cert <file>', 'TLS certificate file (PEM) for P2P server')
+    .option('--p2p-key <file>', 'TLS private key file (PEM) for P2P server')
+    .option('--p2p-ca <file>', 'TLS CA certificate file (PEM) for P2P client')
+    .option('--p2p-insecure', 'Skip TLS certificate verification (client only)')
+    .option('--p2p-rate-limit <n>', 'Max auth attempts per IP per minute (default: 5)', '5')
+    .option('--p2p-allow <ips>', 'Comma-separated list of allowed IPs (empty = all)')
+    .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)');
 
 program.parse(process.argv);
 
@@ -116,20 +126,56 @@ async function runP2PServer(): Promise<void> {
   const password = opts.p2pPassword || '';
   const interval = parseFloat(opts.interval) || 2;
   const detailed = !!opts.detailed;
+  const tlsCert = opts.p2pCert;
+  const tlsKey = opts.p2pKey;
+  const tlsCA = opts.p2pCA;
+  const rateLimit = parseInt(opts.p2pRateLimit, 10) || 5;
+  const allowList = opts.p2pAllow ? opts.p2pAllow.split(',').map((s: string) => s.trim()).filter(Boolean) : [];
+  const denyList = opts.p2pDeny ? opts.p2pDeny.split(',').map((s: string) => s.trim()).filter(Boolean) : [];
 
   if (!password) {
     console.log(chalk.red('Error: a password is required for P2P server mode. Use --p2p-password <password>'));
     process.exit(1);
   }
 
-  const server = new P2PServer({ host, port, password, intervalMs: interval * 1000, detailed });
+  if (tlsCert && !tlsKey) {
+    console.log(chalk.red('Error: --p2p-key is required when --p2p-cert is specified'));
+    process.exit(1);
+  }
+  if (tlsKey && !tlsCert) {
+    console.log(chalk.red('Error: --p2p-cert is required when --p2p-key is specified'));
+    process.exit(1);
+  }
+
+  const server = new P2PServer({
+    host,
+    port,
+    password,
+    intervalMs: interval * 1000,
+    detailed,
+    tlsCert,
+    tlsKey,
+    tlsCA,
+    rateLimitMaxAttempts: rateLimit,
+    rateLimitWindowMs: 60000,
+    allowedIPs: allowList,
+    deniedIPs: denyList,
+    auditLog: opts.p2pAuditLog,
+    hmacKey: opts.p2pHmacKey,
+  });
+
+  const tlsEnabled = !!(tlsCert && tlsKey);
 
   console.log(chalk.bold(`\n  pyre P2P Server`));
   console.log(chalk.dim(`  Host: ${host}`));
   console.log(chalk.dim(`  Port: ${port}`));
+  console.log(chalk.dim(`  Protocol: ${tlsEnabled ? 'TLS' : 'TCP'}`));
   console.log(chalk.dim(`  Password: ${password}`));
   console.log(chalk.dim(`  Interval: ${interval}s`));
   console.log(chalk.dim(`  Detailed: ${detailed ? 'on' : 'off'}`));
+  console.log(chalk.dim(`  Rate limit: ${rateLimit} attempts/min`));
+  if (allowList.length > 0) console.log(chalk.dim(`  Allowed IPs: ${allowList.join(', ')}`));
+  if (denyList.length > 0) console.log(chalk.dim(`  Denied IPs: ${denyList.join(', ')}`));
   console.log(chalk.dim(`  Waiting for peers...\n`));
 
   await server.start();
@@ -158,13 +204,25 @@ async function runP2PConnect(): Promise<void> {
   const host = opts.p2pHost || '127.0.0.1';
   const port = parseInt(opts.p2pPort, 10) || 9876;
   const password = opts.p2pPassword || '';
+  const useTLS = !!opts.p2pTls;
+  const tlsCA = opts.p2pCA;
+  const tlsInsecure = !!opts.p2pInsecure;
 
   if (!password) {
     console.log(chalk.red('Error: a password is required for P2P connect mode. Use --p2p-password <password>'));
     process.exit(1);
   }
 
-  const client = new P2PClient({ host, port, password });
+  const client = new P2PClient({
+    host,
+    port,
+    password,
+    tls: useTLS,
+    tlsCA,
+    tlsInsecure,
+    auditLog: opts.p2pAuditLog,
+    hmacKey: opts.p2pHmacKey,
+  });
 
   client.setOnStatus((msg) => {
     process.stdout.write(`\r${chalk.dim(msg)}${' '.repeat(40)}\r`);
@@ -183,7 +241,9 @@ async function runP2PConnect(): Promise<void> {
     }));
   });
 
+  const protocolLabel = useTLS ? 'TLS' : 'TCP';
   console.log(chalk.bold(`\n  pyre P2P Client`));
+  console.log(chalk.dim(`  Protocol: ${protocolLabel}`));
   console.log(chalk.dim(`  Connecting to ${host}:${port}...`));
   console.log(chalk.dim(`  Press Ctrl+C to disconnect\n`));
 

package/src/live/input.ts

@@ -14,6 +14,7 @@ import { state, setStatus } from './state.js';
 import { exportSnapshot, startLogging, stopLogging, toggleLogging, writeLogRow } from './export.js';
 import { render, footerLine, checkAlerts, processRowBudget } from './render.js';
 import type { LiveOptions, ExportFormat, InputMode, SortMode, GraphMode } from './types.js';
+import { startP2PServer } from '../p2p/index.js';
 
 function handleInputModeKey(str: string, key: readline.Key) {
    if (key.name === 'escape') {
@@ -67,6 +68,36 @@ function handleInputModeKey(str: string, key: readline.Key) {
       return;
     }
 
+     if (state.inputMode === 'p2p') {
+      if (key.name === 'escape') {
+        state.inputMode = null;
+        state.inputBuffer = '';
+        render();
+        return;
+      }
+      if (key.name === 'return') {
+        const password = state.inputBuffer.trim();
+        if (password) {
+          state.p2pPassword = password;
+          startP2PServerFromTUI();
+        }
+        state.inputMode = null;
+        state.inputBuffer = '';
+        render();
+        return;
+      }
+      if (key.name === 'backspace') {
+        state.inputBuffer = state.inputBuffer.slice(0, -1);
+        render();
+        return;
+      }
+      if (str && str.length === 1 && !key.ctrl && !key.meta) {
+        state.inputBuffer += str;
+        render();
+      }
+      return;
+    }
+
    if (key.name === 'return') {
      if (state.inputMode === 'filter') {
        state.processFilter = state.inputBuffer.trim();
@@ -106,6 +137,56 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
    }
   }
 
+  async function startP2PServerFromTUI() {
+    if (state.p2pServerRunning) return;
+    try {
+      const server = await startP2PServer({
+        host: '0.0.0.0',
+        port: state.p2pPort,
+        password: state.p2pPassword,
+        intervalMs: state.interval * 1000,
+        detailed: state.detailed,
+        onLog: (msg: string) => setStatus(msg, 5000),
+        onPeerEvent: (evt) => {
+          state.p2pEvents.push(evt);
+          if (state.p2pEvents.length > 200) state.p2pEvents.shift();
+        },
+      });
+      state.p2pServer = server as any;
+      state.p2pServerRunning = true;
+      state.p2pBind = (server as any).boundAddress || '0.0.0.0';
+      state.p2pEvents = [];
+      setStatus(`P2P server started on ${state.p2pBind}:${state.p2pPort}`);
+      render();
+    } catch (err: any) {
+      setStatus(`P2P server failed: ${err.message}`);
+      state.p2pServerRunning = false;
+      state.p2pServer = null;
+      state.p2pBind = '';
+      render();
+    }
+  }
+
+  function syncP2PEvents() {
+    if (!state.p2pServer) return;
+    const history = state.p2pServer.peerEventHistory;
+    if (history && history !== state.p2pEvents) {
+      state.p2pEvents = history;
+    }
+  }
+
+  function stopP2PServer() {
+    if (!state.p2pServer) return;
+    try {
+      state.p2pServer.stop();
+    } catch {
+      // ignore stop errors
+    }
+    state.p2pServer = null;
+    state.p2pServerRunning = false;
+    setStatus('P2P server stopped');
+  }
+
   function onResize() {
    state.termWidth = process.stdout.columns || 80;
    state.termHeight = process.stdout.rows || 24;
@@ -140,6 +221,7 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
 
       writeLogRow(data);
       checkAlerts(data);
+      syncP2PEvents();
       render();
     } catch {
       // skip bad tick
@@ -252,6 +334,17 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
       }
 
       switch (key.name) {
+        case 'r':
+          if (state.p2pServerRunning) {
+            stopP2PServer();
+            setStatus('P2P server stopped');
+            render();
+          } else {
+            state.inputMode = 'p2p';
+            state.inputBuffer = state.p2pPassword;
+            render();
+          }
+          return;
         case 'q':
           stopLive();
           break;
@@ -362,7 +455,7 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
   }
 
   function tabKeyToId(str: string): string | null {
-    const map: Record<string, string> = { '1': 'cpu', '2': 'mem', '3': 'gpu', '4': 'power', '5': 'battery', '6': 'thermal', '7': 'network', '8': 'packets', '9': 'tasks', '0': 'disk', 'p': 'process' };
+    const map: Record<string, string> = { '1': 'cpu', '2': 'mem', '3': 'gpu', '4': 'power', '5': 'battery', '6': 'thermal', '7': 'network', '8': 'packets', '9': 'tasks', '0': 'disk', 'p': 'process', 'r': 'p2p' };
     return map[str] ?? null;
   }
 
@@ -420,6 +513,11 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
       state.logStream.end();
       state.logStream = null;
     }
+    if (state.p2pServer) {
+      state.p2pServer.stop();
+      state.p2pServer = null;
+      state.p2pServerRunning = false;
+    }
     if (state.keypressHandler) {
       process.stdin.removeListener('keypress', state.keypressHandler);
       state.keypressHandler = null;

package/src/live/render.ts

@@ -7,7 +7,7 @@
  * `state.ts`.
  */
 import chalk from 'chalk';
-import { formatTable, formatGraphs, gridColumns, THEMES, type ThemeName } from '../formatters/index.js';
+import { formatTable, formatGraphs, gridColumns, THEMES, type ThemeName, panel } from '../formatters/index.js';
 import { state, setStatus, SIGNAL_OPTIONS } from './state.js';
 import type { StatsData } from '../monitors/index.js';
 
@@ -25,6 +25,33 @@ function processRowBudget(): number {
   return Math.max(3, Math.min(40, state.termHeight - reserved));
 }
 
+function p2pPanelLines(): { title: string; body: string[] } {
+  const events = state.p2pServer ? state.p2pServer.peerEventHistory : state.p2pEvents;
+  const body: string[] = [];
+  const bindAddr = state.p2pBind || `0.0.0.0:${state.p2pPort}`;
+
+  body.push(`Status:   ${state.p2pServerRunning ? chalk.green('Running') : chalk.red('Stopped')}`);
+  body.push(`Bind:     ${bindAddr}`);
+  body.push(`Password: ${state.p2pPassword}`);
+  body.push('');
+
+  const typeColor = (t: string) => {
+    if (t === 'auth') return chalk.green;
+    if (t === 'disconnect') return chalk.yellow;
+    if (t === 'error' || t === 'blocked' || t === 'rate_limited') return chalk.red;
+    return chalk.cyan;
+  };
+  body.push(chalk.dim('Events (most recent):'));
+  const recent = events.slice(-20).reverse();
+  for (const evt of recent) {
+    const time = new Date(evt.ts).toLocaleTimeString();
+    body.push(`${chalk.dim(time)} ${typeColor(evt.type)(evt.type.padEnd(14))} ${evt.detail}`);
+  }
+
+  const title = `P2P · ${state.p2pServerRunning ? 'ON' : 'OFF'} · ${events.length} events`;
+  return { title, body };
+}
+
 function renderCustomizerOverlay(): string {
    const themesList = Object.keys(THEMES) as ThemeName[];
    const lines = [
@@ -57,20 +84,27 @@ function renderCustomizerOverlay(): string {
 function render() {
   if (!state.lastData) return;
   const lines: string[] = [];
-  lines.push(
-    formatTable(state.lastData, {
-      width: state.termWidth,
-      sortBy: state.sortMode,
-      filter: state.processFilter || undefined,
-      processLimit: processRowBudget(),
-      theme: state.currentTheme,
-      visible: state.visiblePanels,
-      treeView: state.treeView,
-      activePanel: state.activePanel,
-    })
-  );
-
-  if (state.showGraphs) {
+  const theme = THEMES[state.currentTheme] || THEMES.default;
+
+  if (state.activePanel === 'p2p') {
+    const panelLines = p2pPanelLines();
+    lines.push(...panel(panelLines.title, panelLines.body, state.termWidth, theme.process, theme.border));
+  } else {
+    lines.push(
+      formatTable(state.lastData, {
+        width: state.termWidth,
+        sortBy: state.sortMode,
+        filter: state.processFilter || undefined,
+        processLimit: processRowBudget(),
+        theme: state.currentTheme,
+        visible: state.visiblePanels,
+        treeView: state.treeView,
+        activePanel: state.activePanel,
+      })
+    );
+  }
+
+  if (state.showGraphs && state.activePanel !== 'p2p') {
     lines.push('');
     lines.push(formatGraphs(state.history, state.termWidth, state.currentTheme, state.graphMode));
   }
@@ -90,9 +124,11 @@ function render() {
        lines.push(chalk.cyan(`  Signal: ${state.inputBuffer}_`));
        lines.push(chalk.dim(`  ${sigList}`));
        lines.push(chalk.dim('  ↑/↓ to select, Enter to confirm, Esc to cancel'));
+     } else if (state.inputMode === 'p2p') {
+       lines.push(chalk.cyan(`  P2P password (${state.p2pPort}): ${state.inputBuffer}_  (enter to start, esc to cancel)`));
      } else if (state.statusMessage) {
        lines.push(`  ${state.statusMessage}`);
-     }
+    }
 
   process.stdout.write('\x1b[2J\x1b[H');
   process.stdout.write(lines.join('\n'));
@@ -102,22 +138,23 @@ function footerLine(): string {
    const keys: [string, string][] = [
      ['q', 'quit'],
      ['c', 'customize UI'],
-     ['p', state.paused ? 'resume' : 'pause'],
-      ['g', state.showGraphs ? 'hide graphs' : 'show graphs'],
-      ['b', `graph:${state.graphMode}`],
-      ['d', state.detailed ? 'basic' : 'detailed'],
-      ['←/→', 'tab'],
-      ['1-9', 'panels'],
-      ['s', `sort:${state.sortMode}`],
-      ['/', 'filter'],
-      ['k', 'kill'],
-      ['S', 'signal'],
-      ['t', state.treeView ? 'flat' : 'tree'],
-      ['e', 'export'],
-      ['l', state.logging ? 'stop log' : 'log'],
-      ['f', state.exportFormat],
-      ['+/-', `${state.interval}s`],
-    ];
+     ['r', state.p2pServerRunning ? 'stop p2p' : 'start p2p'],
+      ['p', state.paused ? 'resume' : 'pause'],
+       ['g', state.showGraphs ? 'hide graphs' : 'show graphs'],
+       ['b', `graph:${state.graphMode}`],
+       ['d', state.detailed ? 'basic' : 'detailed'],
+       ['←/→', 'tab'],
+       ['1-9', 'panels'],
+       ['s', `sort:${state.sortMode}`],
+       ['/', 'filter'],
+       ['k', 'kill'],
+       ['S', 'signal'],
+       ['t', state.treeView ? 'flat' : 'tree'],
+       ['e', 'export'],
+       ['l', state.logging ? 'stop log' : 'log'],
+       ['f', state.exportFormat],
+       ['+/-', `${state.interval}s`],
+     ];
     const keyStr = keys.map(([k, label]) => `${chalk.hex('#50fa7b').bold(k)} ${chalk.dim(label)}`).join(chalk.dim('  |  '));
 
 
@@ -125,6 +162,7 @@ function footerLine(): string {
    if (state.paused) badges.push(chalk.yellow.bold('⏸ PAUSED'));
    if (state.logging) badges.push(chalk.red.bold('● REC'));
    if (state.activePanel !== 'grid') badges.push(chalk.cyan.bold(`◉ ${state.activePanel.toUpperCase()}`));
+     if (state.p2pServerRunning) badges.push(chalk.green.bold(`P2P ${state.p2pBind || '0.0.0.0'}:${state.p2pPort}`));
    const badgeStr = badges.join('  ');
 
    return badgeStr ? `${keyStr}    ${badgeStr}` : keyStr;

package/src/live/state.ts

@@ -75,21 +75,28 @@ const state = {
    CPU_ALERT_PCT: 90,
    TEMP_ALERT_C: 95,
    alerted: false,
-   activePanel: 'grid' as 'grid' | 'cpu' | 'mem' | 'gpu' | 'power' | 'battery' | 'thermal' | 'network' | 'packets' | 'tasks' | 'disk' | 'process',
-   mouseEnabled: true,
-    PANEL_TABS: [
-      { id: 'cpu', label: 'CPU', key: '1' },
-      { id: 'mem', label: 'Memory', key: '2' },
-      { id: 'gpu', label: 'GPU', key: '3' },
-      { id: 'power', label: 'Power', key: '4' },
-      { id: 'battery', label: 'Battery', key: '5' },
-      { id: 'thermal', label: 'Thermal', key: '6' },
-      { id: 'network', label: 'Network', key: '7' },
-      { id: 'packets', label: 'Packets', key: '8' },
-      { id: 'tasks', label: 'Tasks', key: '9' },
-      { id: 'disk', label: 'Disk', key: '0' },
-      { id: 'process', label: 'Process', key: 'P' },
-    ] as const,
+   activePanel: 'grid' as 'grid' | 'cpu' | 'mem' | 'gpu' | 'power' | 'battery' | 'thermal' | 'network' | 'packets' | 'tasks' | 'disk' | 'process' | 'p2p',
+    mouseEnabled: true,
+      PANEL_TABS: [
+        { id: 'cpu', label: 'CPU', key: '1' },
+        { id: 'mem', label: 'Memory', key: '2' },
+        { id: 'gpu', label: 'GPU', key: '3' },
+        { id: 'power', label: 'Power', key: '4' },
+        { id: 'battery', label: 'Battery', key: '5' },
+        { id: 'thermal', label: 'Thermal', key: '6' },
+        { id: 'network', label: 'Network', key: '7' },
+        { id: 'packets', label: 'Packets', key: '8' },
+        { id: 'tasks', label: 'Tasks', key: '9' },
+        { id: 'disk', label: 'Disk', key: '0' },
+        { id: 'process', label: 'Process', key: 'P' },
+        { id: 'p2p', label: 'P2P', key: 'R' },
+      ] as const,
+     p2pEvents: [] as { type: string; detail: string; ts: number }[],
+     p2pBind: '',
+     p2pServer: null as { stop: () => void; peerEventHistory: { type: string; detail: string; ts: number }[] } | null,
+     p2pServerRunning: false,
+     p2pPort: 9876,
+     p2pPassword: 'pyre',
   };
 
 function setStatus(msg: string, ms = 3000) {

package/src/live/types.ts

@@ -14,7 +14,7 @@ export interface LiveOptions {
 
 export type ExportFormat = 'json' | 'csv' | 'tsv';
 
-type InputMode = null | 'filter' | 'kill' | 'signal' | 'customizer';
+type InputMode = null | 'filter' | 'kill' | 'signal' | 'customizer' | 'p2p';
 
 type SortMode = 'cpu' | 'mem' | 'pid' | 'user' | 'command' | 'state' | 'threads' | 'runtime';
 

package/src/monitors/collectors.ts

@@ -627,7 +627,7 @@ export async function collectPackets(): Promise<PacketData | null> {
      let topProcesses: { pid: number; command: string; rxBytes: number; txBytes: number }[] = [];
      let allProcesses: { pid: number; command: string; rxBytes: number; txBytes: number; rxPackets?: number; txPackets?: number }[] = [];
      try {
-        const lsof = (await run('lsof -i -n -P -r 1 2>/dev/null | tail -n +2 | awk \'{print $1, $2}\' | sort | uniq -c | sort -rn', '')).trim();
+         const lsof = (await run('lsof -i -n -P 2>/dev/null | tail -n +2 | awk \'{print $1, $2}\' | sort | uniq -c | sort -rn', '')).trim();
         const lsofLines = lsof.split('\n');
         topProcesses = lsofLines.map(line => {
           const parts = line.trim().split(/\s+/);