pyre-cli 1.3.0 → 2.0.0

package/src/p2p/server.ts

@@ -0,0 +1,219 @@
+import net from 'node:net';
+import chalk from 'chalk';
+import { collectAll } from '../monitors/index.js';
+import { encodeAuthOk, encodeAuthFail, encodeData, encodePing, encodePong, encodeDisconnect } from './protocol.js';
+import type { P2PServerOptions, P2PConnectionInfo } from './types.js';
+
+interface Peer {
+  socket: net.Socket;
+  authenticated: boolean;
+  intervalHandle: NodeJS.Timeout | null;
+  pingHandle: NodeJS.Timeout | null;
+  readBuffer: Buffer;
+  readExpectingHeader: boolean;
+  readMessageLength: number;
+}
+
+const HEADER_SIZE = 4;
+
+function readMessageFromPeer(peer: Peer): Buffer | null {
+  while (peer.readBuffer.length > 0) {
+    if (peer.readExpectingHeader) {
+      if (peer.readBuffer.length >= HEADER_SIZE) {
+        peer.readMessageLength = peer.readBuffer.readUInt32BE(0);
+        peer.readBuffer = peer.readBuffer.subarray(HEADER_SIZE);
+        peer.readExpectingHeader = false;
+      } else {
+        break;
+      }
+    }
+
+    if (!peer.readExpectingHeader) {
+      if (peer.readBuffer.length >= peer.readMessageLength) {
+        const body = peer.readBuffer.subarray(0, peer.readMessageLength);
+        peer.readBuffer = peer.readBuffer.subarray(peer.readMessageLength);
+        peer.readExpectingHeader = true;
+        return body;
+      } else {
+        break;
+      }
+    }
+  }
+  return null;
+}
+
+export class P2PServer {
+  private server: net.Server | null = null;
+  private peers: Map<net.Socket, Peer> = new Map();
+  private options: P2PServerOptions;
+  private running = false;
+
+  constructor(options: P2PServerOptions) {
+    this.options = options;
+  }
+
+  get info(): P2PConnectionInfo {
+    return {
+      host: this.options.host,
+      port: this.options.port,
+      peersConnected: this.peers.size,
+    };
+  }
+
+  async start(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.server = net.createServer((socket) => this.onConnection(socket));
+      this.server.on('error', (err) => reject(err));
+      this.server.listen(this.options.port, this.options.host, () => {
+        this.running = true;
+        const addr = this.server?.address();
+        const bound = addr ? (typeof addr === 'object' ? `${addr.address}:${addr.port}` : String(addr)) : 'unknown';
+        console.log(chalk.green(`P2P server listening on ${bound}`));
+        console.log(chalk.dim(`  Password: ${this.options.password}`));
+        console.log(chalk.dim(`  Interval: ${this.options.intervalMs}ms`));
+        resolve();
+      });
+    });
+  }
+
+  stop(): void {
+    this.running = false;
+    for (const peer of this.peers.values()) {
+      this.disconnectPeer(peer, 'Server shutting down');
+    }
+    this.peers.clear();
+    if (this.server) {
+      this.server.close();
+      this.server = null;
+    }
+  }
+
+  private onConnection(socket: net.Socket): void {
+    const peer: Peer = {
+      socket,
+      authenticated: false,
+      intervalHandle: null,
+      pingHandle: null,
+      readBuffer: Buffer.alloc(0),
+      readExpectingHeader: true,
+      readMessageLength: 0,
+    };
+    this.peers.set(socket, peer);
+
+    const remoteAddr = socket.remoteAddress
+      ? `${socket.remoteAddress}:${socket.remotePort}`
+      : 'unknown';
+    console.log(chalk.cyan(`Peer connected: ${remoteAddr}`));
+
+    socket.on('data', (data) => this.onData(peer, data));
+    socket.on('close', () => this.onPeerClose(peer));
+    socket.on('error', (err) => this.onPeerError(peer, err));
+
+    socket.setTimeout(30000);
+    socket.on('timeout', () => {
+      if (!peer.authenticated) {
+        this.disconnectPeer(peer, 'Authentication timeout');
+      }
+    });
+  }
+
+  private onData(peer: Peer, data: Buffer): void {
+    peer.readBuffer = Buffer.concat([peer.readBuffer, data]);
+
+    if (!peer.authenticated) {
+      const body = readMessageFromPeer(peer);
+      if (body) {
+        this.handleAuthMessage(peer, body);
+      }
+      return;
+    }
+  }
+
+  private handleAuthMessage(peer: Peer, body: Buffer): void {
+    try {
+      const msg = JSON.parse(body.toString('utf-8'));
+      if (msg.kind === 'auth' && typeof msg.payload?.password === 'string') {
+        if (msg.payload.password === this.options.password) {
+          peer.authenticated = true;
+          peer.socket.write(encodeAuthOk());
+          console.log(chalk.green(`Peer authenticated: ${peer.socket.remoteAddress}`));
+          this.startDataStream(peer);
+          this.startPing(peer);
+        } else {
+          peer.socket.write(encodeAuthFail('Invalid password'));
+          this.disconnectPeer(peer, 'Authentication failed');
+        }
+      } else {
+        peer.socket.write(encodeAuthFail('Expected auth message first'));
+        this.disconnectPeer(peer, 'Expected auth message');
+      }
+    } catch {
+      peer.socket.write(encodeAuthFail('Invalid message format'));
+      this.disconnectPeer(peer, 'Invalid message format');
+    }
+  }
+
+  private startDataStream(peer: Peer): void {
+    const send = async () => {
+      if (!peer.authenticated || peer.socket.destroyed) return;
+      try {
+        const data = await collectAll({ detailed: this.options.detailed });
+        peer.socket.write(encodeData(data));
+      } catch {
+        // skip failed tick
+      }
+    };
+
+    send();
+    peer.intervalHandle = setInterval(send, this.options.intervalMs);
+  }
+
+  private startPing(peer: Peer): void {
+    peer.pingHandle = setInterval(() => {
+      if (peer.socket.destroyed) return;
+      peer.socket.write(encodePing());
+    }, 5000);
+  }
+
+  private onPeerClose(peer: Peer): void {
+    this.cleanupPeer(peer);
+    console.log(chalk.yellow(`Peer disconnected: ${peer.socket.remoteAddress}`));
+  }
+
+  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}`));
+    } else {
+      console.log(chalk.red(`Peer error: ${err.message}`));
+    }
+    this.cleanupPeer(peer);
+  }
+
+  private disconnectPeer(peer: Peer, reason: string): void {
+    try {
+      peer.socket.write(encodeDisconnect(reason));
+    } catch {
+      // socket may already be closed
+    }
+    peer.socket.destroy();
+  }
+
+  private cleanupPeer(peer: Peer): void {
+    if (peer.intervalHandle) {
+      clearInterval(peer.intervalHandle);
+      peer.intervalHandle = null;
+    }
+    if (peer.pingHandle) {
+      clearInterval(peer.pingHandle);
+      peer.pingHandle = null;
+    }
+    this.peers.delete(peer.socket);
+  }
+}
+
+export async function startP2PServer(options: P2PServerOptions): Promise<P2PServer> {
+  const server = new P2PServer(options);
+  await server.start();
+  return server;
+}

package/src/p2p/types.ts

@@ -0,0 +1,71 @@
+/**
+ * P2P live data transfer protocol types.
+ *
+ * Defines the message shapes exchanged between a pyre server
+ * (host) and a pyre client (peer) over a TCP connection.
+ */
+
+export type P2PMessageKind = 'auth' | 'auth-ok' | 'auth-fail' | 'data' | 'ping' | 'pong' | 'disconnect';
+
+export interface P2PMessage {
+  kind: P2PMessageKind;
+  payload: unknown;
+}
+
+export interface AuthMessage {
+  password: string;
+}
+
+export interface AuthOkMessage {
+  ok: true;
+}
+
+export interface AuthFailMessage {
+  ok: false;
+  reason: string;
+}
+
+export interface DataMessage {
+  stats: import('../monitors/types.js').StatsData;
+}
+
+export interface PingMessage {
+  ts: number;
+}
+
+export interface PongMessage {
+  ts: number;
+}
+
+export interface DisconnectMessage {
+  reason: string;
+}
+
+export type P2PPayload =
+  | AuthMessage
+  | AuthOkMessage
+  | AuthFailMessage
+  | DataMessage
+  | PingMessage
+  | PongMessage
+  | DisconnectMessage;
+
+export interface P2PServerOptions {
+  host: string;
+  port: number;
+  password: string;
+  intervalMs: number;
+  detailed: boolean;
+}
+
+export interface P2PClientOptions {
+  host: string;
+  port: number;
+  password: string;
+}
+
+export interface P2PConnectionInfo {
+  host: string;
+  port: number;
+  peersConnected: number;
+}

package/src/sparkline.ts

@@ -0,0 +1,34 @@
+const BLOCKS = '▁▂▃▄▅▆▇█';
+
+/**
+ * Render a series of numbers as a compact unicode sparkline.
+ *
+ * Values are normalised against `min`/`max` (auto-computed
+ * from the data if not supplied).  The output uses eight
+ * Unicode block characters to represent the range, making
+ * it suitable for inline terminal graphs.
+ *
+ * @param values - Numeric series to render.
+ * @param opts.min - Minimum value for normalisation.
+ * @param opts.max - Maximum value for normalisation.
+ * @returns A string of block characters whose length equals `values.length`.
+ *
+ * @example
+ * ```ts
+ * sparkline([10, 20, 15, 30, 25]); // "▁▂▃▅▄"
+ * ```
+ */
+export function sparkline(values: number[], opts: { min?: number; max?: number } = {}): string {
+  if (!values.length) return '';
+  const min = opts.min ?? Math.min(...values);
+  const max = opts.max ?? Math.max(...values);
+  const range = max - min || 1;
+
+  return values
+    .map(v => {
+      const idx = Math.round(((v - min) / range) * (BLOCKS.length - 1));
+      const clamped = Math.min(BLOCKS.length - 1, Math.max(0, idx));
+      return BLOCKS[clamped];
+    })
+    .join('');
+}

package/src/splash.ts

@@ -0,0 +1,102 @@
+/**
+ * ASCII Splash Screen implementation based on the doom-fire effect.
+ */
+import chalk from 'chalk';
+
+const MAXV = 36;
+const CHAR_RAMP = [' ', '.', '`', ',', ':', ';', '+', '*', '?', '%', '#', '@'];
+
+// Colors for the fire effect
+const palette = [
+  '#0a0505', '#1a0806', '#2a0b06', '#3f1004', '#591404', '#791804', '#9e1c04', '#c92004',
+  '#d63004', '#e34004', '#f05004', '#fd6004', '#ff7004', '#ff8004', '#ff9004', '#ffa004',
+  '#ffb004', '#ffc004', '#ffd004', '#ffe004', '#fff004', '#fff820', '#ffff40', '#ffff60',
+  '#ffff80', '#ffffa0', '#ffffc0', '#ffffe0', '#ffffff', '#ffffff', '#ffffff', '#ffffff',
+  '#ffffff', '#ffffff', '#ffffff', '#ffffff'
+];
+
+function getRgb(hex: string) {
+  const r = parseInt(hex.slice(1, 3), 16);
+  const g = parseInt(hex.slice(3, 5), 16);
+  const b = parseInt(hex.slice(5, 7), 16);
+  return { r, g, b };
+}
+
+const rgbPalette = palette.map(getRgb);
+
+function getChar(val: number) {
+  const idx = Math.min(CHAR_RAMP.length - 1, Math.floor((val / (MAXV + 1)) * CHAR_RAMP.length));
+  return CHAR_RAMP[idx];
+}
+
+export async function showSplash() {
+  const cols = 60;
+  const rows = 15;
+  let fire = new Uint8Array(cols * rows);
+
+  // Clear screen
+  process.stdout.write('\x1b[2J');
+  const termRows = process.stdout.rows || 24;
+  const termCols = process.stdout.columns || 80;
+  const startRow = Math.max(0, Math.floor((termRows - rows) / 2));
+  const startCol = Math.max(0, Math.floor((termCols - cols) / 2));
+
+  return new Promise<void>((resolve) => {
+    const interval = setInterval(() => {
+      // Bottom row heat
+      for (let x = 0; x < cols; x++) {
+        fire[(rows - 1) * cols + x] = MAXV - Math.floor(Math.random() * 4);
+      }
+
+      // Spread fire
+      for (let y = rows - 1; y >= 1; y--) {
+        for (let x = 0; x < cols; x++) {
+          const src = y * cols + x;
+          const val = fire[src];
+          if (val === 0) {
+            fire[(y - 1) * cols + x] = 0;
+            continue;
+          }
+          const decay = Math.floor(Math.random() * 3);
+          const drift = Math.floor(Math.random() * 3) - 1;
+          let nx = x + drift;
+          if (nx < 0) nx = 0; else if (nx >= cols) nx = cols - 1;
+          fire[(y - 1) * cols + nx] = Math.max(0, val - decay);
+        }
+      }
+
+      // Draw
+      let output = '';
+      for (let i = 0; i < startRow; i++) output += '\n';
+
+      for (let y = 0; y < rows; y++) {
+        output += ' '.repeat(startCol);
+        for (let x = 0; x < cols; x++) {
+          const v = fire[y * cols + x];
+          const color = rgbPalette[Math.min(v, rgbPalette.length - 1)];
+          output += chalk.rgb(color.r, color.g, color.b)(getChar(v));
+        }
+        output += '\n';
+      }
+      output += ' '.repeat(Math.max(0, startCol + (cols - 45) / 2)) + chalk.bold.white('🔥 pyre — system monitor (warming up sensors...)\n');
+      output += ' '.repeat(Math.max(0, startCol + (cols - 25) / 2)) + chalk.dim('[Press Enter to continue]');
+      
+      // Clear viewport area and redraw
+      process.stdout.write(`\x1b[H${output}`);
+    }, 65);
+
+    const onEnter = () => {
+      process.stdin.removeListener('data', onEnter);
+      clearInterval(interval);
+      process.stdout.write('\x1b[2J\x1b[H');
+      resolve();
+    };
+
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on('data', onEnter);
+
+    // Auto-exit after 5s
+    setTimeout(onEnter, 5000);
+  });
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": false,
+    "sourceMap": false,
+    "noEmit": false
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}