pyre-cli 3.0.0 → 3.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pyre-cli",
-  "version": "3.0.0",
+  "version": "3.2.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

@@ -69,14 +69,14 @@ async function main() {
     if (cmd === 'live') {
       program.args.shift();
     }
-    await showSplash();
+    const splashPromise = showSplash();
     const interval = parseFloat(opts.interval) || 2;
     await startLive({
       interval,
       detailed: opts.detailed,
       exportDir: opts.exportDir,
       autoLog: opts.log,
-    });
+    }, splashPromise);
     return;
   }
 

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;
@@ -118,6 +199,33 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
    state.intervalHandle = setInterval(tick, state.interval * 1000);
  }
 
+  async function doWarmup() {
+    try {
+      const data = await collectAll({ detailed: state.detailed, processLimit: processRowBudget() });
+      state.lastData = data;
+
+      const temp = data.cpu.temperature ?? data.thermal.temperatures?.cpu_die ?? null;
+      state.history.push({
+        cpuUsage: data.cpu.usage,
+        memUsage: data.memory.usagePercent,
+        temp,
+        rxBytes: data.network.rxBytes,
+        txBytes: data.network.txBytes,
+        gpuUtil: data.gpu?.utilization,
+        powerWatts: data.power?.combinedWatts ?? data.power?.cpuWatts ?? 0,
+        rxPackets: data.network.rxPackets,
+        txPackets: data.network.txPackets,
+        connections: data.network.connections ?? 0,
+      });
+
+      writeLogRow(data);
+      checkAlerts(data);
+      syncP2PEvents();
+    } catch {
+      // skip bad warmup
+    }
+  }
+
   async function tick() {
     if (state.paused) return;
     try {
@@ -140,6 +248,7 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
 
       writeLogRow(data);
       checkAlerts(data);
+      syncP2PEvents();
       render();
     } catch {
       // skip bad tick
@@ -153,7 +262,7 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
   * rendering interval.  Idempotent — calling while already
   * running is a no-op.
   */
-  export async function startLive(opts: LiveOptions) {
+  export async function startLive(opts: LiveOptions, splashPromise?: Promise<void>) {
     if (state.running) return;
     state.running = true;
     state.paused = false;
@@ -165,6 +274,12 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
     state.history.reset();
     state.history.setMaxLen(Math.max(20, Math.min(200, state.termWidth - 30)));
 
+    const warmupPromise = doWarmup();
+
+    if (splashPromise) {
+      await splashPromise;
+    }
+
     process.stdout.write('\x1b[?1049h');
     process.stdout.write('\x1b[?25l');
     process.stdout.write('\x1b[2J\x1b[H');
@@ -174,7 +289,9 @@ function killProcess(pidStr: string, signal: string = 'SIGTERM') {
       process.stdout.write('\x1b[?1000h');
     }
 
-    await tick();
+    await warmupPromise;
+    render();
+
     restartTicker();
 
     if (opts.autoLog) startLogging();
@@ -252,6 +369,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 +490,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 +548,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/p2p/server.ts

@@ -84,12 +84,35 @@ export class P2PServer {
   private rateLimitMap: Map<string, RateLimitEntry> = new Map();
   private auditStream: fs.WriteStream | null = null;
   private hmacKey: string;
+  private peerEvents: { type: string; detail: string; ts: number }[] = [];
+  private boundAddress = '';
 
   constructor(options: P2PServerOptions) {
     this.options = options;
     this.hmacKey = deriveHMACKey(options.password);
   }
 
+  get peerEventHistory(): { type: string; detail: string; ts: number }[] {
+    return this.peerEvents;
+  }
+
+  private log(msg: string): void {
+    if (this.options.onLog) {
+      this.options.onLog(msg.replace(/\x1b\[[0-9;]*m/g, ''));
+    } else {
+      console.log(msg);
+    }
+  }
+
+  private emitPeerEvent(type: string, detail: string): void {
+    const evt = { type, detail, ts: Date.now() };
+    this.peerEvents.push(evt);
+    if (this.peerEvents.length > 200) this.peerEvents.shift();
+    if (this.options.onPeerEvent) {
+      this.options.onPeerEvent(evt as any);
+    }
+  }
+
   get info(): P2PConnectionInfo {
     return {
       host: this.options.host,
@@ -105,7 +128,7 @@ export class P2PServer {
         const logFile = `${this.options.auditLog}/p2p-audit.log`;
         this.auditStream = fs.createWriteStream(logFile, { flags: 'a' });
       } catch {
-        console.log(chalk.yellow('Warning: could not open audit log'));
+        this.log(chalk.yellow('Warning: could not open audit log'));
       }
     }
 
@@ -130,14 +153,16 @@ export class P2PServer {
         this.running = true;
         const addr = this.server?.address();
         const bound = addr ? (typeof addr === 'object' ? `${addr.address}:${addr.port}` : String(addr)) : 'unknown';
+        this.boundAddress = typeof addr === 'object' && addr ? addr.address : String(addr);
         const protocol = useTLS ? 'TLS' : 'TCP';
-        console.log(chalk.green(`P2P server listening on ${bound} (${protocol})`));
-        console.log(chalk.dim(`  Password: ${this.options.password}`));
-        console.log(chalk.dim(`  Interval: ${this.options.intervalMs}ms`));
+        this.log(chalk.green(`P2P server listening on ${bound} (${protocol})`));
+        this.log(chalk.dim(`  Password: ${this.options.password}`));
+        this.log(chalk.dim(`  Interval: ${this.options.intervalMs}ms`));
         const allowedIPs = this.options.allowedIPs ?? [];
         const deniedIPs = this.options.deniedIPs ?? [];
-        if (allowedIPs.length > 0) console.log(chalk.dim(`  Allowed IPs: ${allowedIPs.join(', ')}`));
-        if (deniedIPs.length > 0) console.log(chalk.dim(`  Denied IPs: ${deniedIPs.join(', ')}`));
+        if (allowedIPs.length > 0) this.log(chalk.dim(`  Allowed IPs: ${allowedIPs.join(', ')}`));
+        if (deniedIPs.length > 0) this.log(chalk.dim(`  Denied IPs: ${deniedIPs.join(', ')}`));
+        this.emitPeerEvent('connect', `Server listening on ${bound}`);
         resolve();
       });
     });
@@ -150,6 +175,7 @@ export class P2PServer {
     }
     this.peers.clear();
     this.rateLimitMap.clear();
+    this.peerEvents = [];
     if (this.server) {
       this.server.close();
       this.server = null;
@@ -210,14 +236,16 @@ export class P2PServer {
 
     if (!isIPAllowed(ip, allowedIPs, deniedIPs)) {
       this.audit(ip, 'BLOCKED', 'IP not allowed');
-      console.log(chalk.yellow(`Blocked IP: ${ip}`));
+      this.log(chalk.yellow(`Blocked IP: ${ip}`));
+      this.emitPeerEvent('blocked', ip);
       socket.destroy();
       return;
     }
 
     if (!this.checkRateLimit(ip)) {
       this.audit(ip, 'RATE_LIMITED', 'Too many auth attempts');
-      console.log(chalk.yellow(`Rate limit exceeded for IP: ${ip}`));
+      this.log(chalk.yellow(`Rate limit exceeded for IP: ${ip}`));
+      this.emitPeerEvent('rate_limited', ip);
       socket.destroy();
       return;
     }
@@ -238,8 +266,9 @@ export class P2PServer {
     const remoteAddr = socket.remoteAddress
       ? `${socket.remoteAddress}:${socket.remotePort}`
       : 'unknown';
-    console.log(chalk.cyan(`Peer connected: ${remoteAddr}`));
+    this.log(chalk.cyan(`Peer connected: ${remoteAddr}`));
     this.audit(ip, 'CONNECT', remoteAddr);
+    this.emitPeerEvent('connect', remoteAddr);
 
     socket.on('data', (data) => this.onData(peer, data));
     socket.on('close', () => this.onPeerClose(peer));
@@ -276,6 +305,7 @@ export class P2PServer {
       if (msg.kind !== 'auth') {
         peer.socket.write(signMessage('auth-fail', { ok: false, reason: 'Expected auth message first' }, this.hmacKey));
         this.disconnectPeer(peer, 'Expected auth message');
+        this.emitPeerEvent('error', `Expected auth message from ${peer.ip}`);
         return;
       }
 
@@ -283,6 +313,7 @@ export class P2PServer {
       if (!authPayload.passwordHash || !authPayload.nonce) {
         peer.socket.write(signMessage('auth-fail', { ok: false, reason: 'Invalid auth payload' }, this.hmacKey));
         this.disconnectPeer(peer, 'Invalid auth payload');
+        this.emitPeerEvent('error', `Invalid auth payload from ${peer.ip}`);
         return;
       }
 
@@ -290,6 +321,7 @@ export class P2PServer {
         this.audit(peer.ip, 'AUTH_FAIL', 'Nonce mismatch');
         peer.socket.write(signMessage('auth-fail', { ok: false, reason: 'Invalid nonce' }, this.hmacKey));
         this.disconnectPeer(peer, 'Invalid nonce');
+        this.emitPeerEvent('error', `Invalid nonce from ${peer.ip}`);
         return;
       }
 
@@ -298,6 +330,7 @@ export class P2PServer {
         this.audit(peer.ip, 'AUTH_FAIL', 'Invalid password hash');
         peer.socket.write(signMessage('auth-fail', { ok: false, reason: 'Invalid password' }, this.hmacKey));
         this.disconnectPeer(peer, 'Authentication failed');
+        this.emitPeerEvent('error', `Invalid password from ${peer.ip}`);
         return;
       }
 
@@ -305,8 +338,9 @@ export class P2PServer {
       this.cleanupRateLimit(peer.ip);
       peer.pendingNonce = null;
       peer.socket.write(signMessage('auth-ok', { ok: true }, this.hmacKey));
-      console.log(chalk.green(`Peer authenticated: ${peer.socket.remoteAddress}`));
+      this.log(chalk.green(`Peer authenticated: ${peer.socket.remoteAddress}`));
       this.audit(peer.ip, 'AUTH_OK', 'Challenge-response successful');
+      this.emitPeerEvent('auth', peer.socket.remoteAddress ?? peer.ip);
       this.startDataStream(peer);
       this.startPing(peer);
     } catch {
@@ -345,18 +379,21 @@ export class P2PServer {
 
   private onPeerClose(peer: Peer): void {
     this.cleanupPeer(peer);
-    console.log(chalk.yellow(`Peer disconnected: ${peer.socket.remoteAddress}`));
+    this.log(chalk.yellow(`Peer disconnected: ${peer.socket.remoteAddress}`));
+    this.emitPeerEvent('disconnect', peer.socket.remoteAddress ?? peer.ip);
     this.audit(peer.ip, 'DISCONNECT', 'Peer closed connection');
   }
 
   private onPeerError(peer: Peer, err: Error): void {
     const code = (err as any).code;
     if (code === 'ECONNRESET') {
-      console.log(chalk.yellow(`Peer connection reset: ${peer.socket.remoteAddress}`));
+      this.log(chalk.yellow(`Peer connection reset: ${peer.socket.remoteAddress}`));
       this.audit(peer.ip, 'ERROR', 'Connection reset');
+      this.emitPeerEvent('error', `connection reset: ${peer.socket.remoteAddress}`);
     } else {
-      console.log(chalk.red(`Peer error: ${err.message}`));
+      this.log(chalk.red(`Peer error: ${err.message}`));
       this.audit(peer.ip, 'ERROR', err.message);
+      this.emitPeerEvent('error', err.message);
     }
     this.cleanupPeer(peer);
   }

package/src/p2p/types.ts

@@ -72,6 +72,8 @@ export interface P2PServerOptions {
   deniedIPs?: string[];
   auditLog?: string;
   hmacKey?: string;
+  onLog?: (msg: string) => void;
+  onPeerEvent?: (event: { type: 'connect' | 'auth' | 'disconnect' | 'error' | 'blocked' | 'rate_limited'; detail: string; ts: number }) => void;
 }
 
 export interface P2PClientOptions {