pyre-cli 1.4.0 → 2.0.0

package/src/p2p/protocol.ts

@@ -0,0 +1,71 @@
+import type { P2PMessage, P2PMessageKind, P2PPayload } from './types.js';
+import type { StatsData } from '../monitors/types.js';
+
+const HEADER_SIZE = 4;
+const MAX_MESSAGE_SIZE = 16 * 1024 * 1024;
+
+function buildMessage(kind: P2PMessageKind, payload: P2PPayload): Buffer {
+  const envelope: P2PMessage = { kind, payload };
+  const body = Buffer.from(JSON.stringify(envelope), 'utf-8');
+  const header = Buffer.alloc(HEADER_SIZE);
+  header.writeUInt32BE(body.length, 0);
+  return Buffer.concat([header, body]);
+}
+
+export function encodeAuth(password: string): Buffer {
+  return buildMessage('auth', { password });
+}
+
+export function encodeAuthOk(): Buffer {
+  return buildMessage('auth-ok', { ok: true });
+}
+
+export function encodeAuthFail(reason: string): Buffer {
+  return buildMessage('auth-fail', { ok: false, reason });
+}
+
+export function encodeData(stats: StatsData): Buffer {
+  return buildMessage('data', { stats });
+}
+
+export function encodePing(): Buffer {
+  return buildMessage('ping', { ts: Date.now() });
+}
+
+export function encodePong(ts: number): Buffer {
+  return buildMessage('pong', { ts });
+}
+
+export function encodeDisconnect(reason: string): Buffer {
+  return buildMessage('disconnect', { reason });
+}
+
+export function decodeMessage(buf: Buffer): P2PMessage {
+  const str = buf.toString('utf-8');
+  const msg: P2PMessage = JSON.parse(str);
+  return msg;
+}
+
+export function readMessage(stream: { read(n: number): Buffer | null }): Buffer | null {
+  const header = stream.read(HEADER_SIZE);
+  if (!header || header.length < HEADER_SIZE) return null;
+  const length = header.readUInt32BE(0);
+  if (length > MAX_MESSAGE_SIZE) {
+    throw new Error(`Message too large: ${length} bytes`);
+  }
+  const body = stream.read(length);
+  if (!body || body.length < length) return null;
+  return body;
+}
+
+export function readAll(stream: { read(n: number): Buffer | null }, total: number): Buffer {
+  const chunks: Buffer[] = [];
+  let remaining = total;
+  while (remaining > 0) {
+    const chunk = stream.read(remaining);
+    if (!chunk) break;
+    chunks.push(chunk);
+    remaining -= chunk.length;
+  }
+  return Buffer.concat(chunks);
+}

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;
+}