@kangwifi-pro/waliwa 1.0.0

package/src/socket/ws-socket.ts

@@ -0,0 +1,355 @@
+/**
+ * Waliwa - WebSocket layer untuk WhatsApp Web Multi-Device
+ *
+ * Connect ke wss://web.whatsapp.com/ws/chat dengan Noise protocol encrypted frames.
+ * RAM optimization: gunakan buffer pooling, hindari Buffer.concat berlebihan,
+ * drain queue ASAP.
+ */
+
+import WebSocket from 'ws';
+import { EventEmitter } from 'events';
+import {
+  NoiseHandshake,
+  TrafficCipher
+} from '../core/noise.js';
+import { concatBytes, getRandomBytes } from '../core/crypto.js';
+import type { WALogger } from '../types/index.js';
+import { SilentLogger } from '../utils/logger.js';
+
+export type WAWebSocketEvent =
+  | 'open'
+  | 'message'
+  | 'close'
+  | 'error'
+  | 'handshake:done'
+  | 'handshake:error';
+
+export interface WAWebSocketOptions {
+  url: string;
+  logger?: WALogger;
+  /** Browser identification for client payload */
+  browser?: [string, string, string];
+  /** Connect timeout ms */
+  connectTimeoutMs?: number;
+  /** Keep alive interval ms */
+  keepAliveIntervalMs?: number;
+  /** Static key pair untuk Noise (persistent across sessions) */
+  noiseKey?: { private: Uint8Array; public: Uint8Array };
+  /** RAM optimization level (1-3) */
+  ramLevel?: 1 | 2 | 3;
+}
+
+const DEFAULT_WA_URL = 'wss://web.whatsapp.com/ws/chat';
+const DEFAULT_BROWSER: [string, string, string] = ['Waliwa', 'WA', '1.0.0'];
+
+// ============== Frame Buffer Pool (RAM optimization) ==============
+
+/**
+ * Buffer pool untuk reuse buffer daripada alokasi ulang.
+ * RAM-friendly pattern untuk high-throughput message processing.
+ */
+class BufferPool {
+  private pool: Uint8Array[] = [];
+  private readonly maxSize: number;
+  private readonly bufferSize: number;
+
+  constructor(bufferSize: number = 4096, maxPoolSize: number = 16) {
+    this.bufferSize = bufferSize;
+    this.maxSize = maxPoolSize;
+  }
+
+  acquire(): Uint8Array {
+    const buf = this.pool.pop();
+    return buf ?? new Uint8Array(this.bufferSize);
+  }
+
+  release(buf: Uint8Array): void {
+    if (this.pool.length < this.maxSize) {
+      this.pool.push(buf);
+    }
+  }
+}
+
+// ============== WA WebSocket ==============
+
+export class WAWebSocket extends EventEmitter {
+  private ws: WebSocket | null = null;
+  private url: string;
+  private logger: WALogger;
+  private browser: [string, string, string];
+  private connectTimeoutMs: number;
+  private keepAliveIntervalMs: number;
+  private noiseKey?: { private: Uint8Array; public: Uint8Array };
+  private ramLevel: 1 | 2 | 3;
+
+  private trafficCipher: TrafficCipher | null = null;
+  private handshake: NoiseHandshake | null = null;
+  private keepAliveTimer: NodeJS.Timeout | null = null;
+  private connectTimer: NodeJS.Timeout | null = null;
+  private isOpen: boolean = false;
+  private isHandshakeDone: boolean = false;
+  private recvBuffer: number[] = [];
+  private bufferPool: BufferPool;
+
+  constructor(opts: WAWebSocketOptions) {
+    super();
+    this.url = opts.url || DEFAULT_WA_URL;
+    this.logger = opts.logger ?? new SilentLogger();
+    this.browser = opts.browser ?? DEFAULT_BROWSER;
+    this.connectTimeoutMs = opts.connectTimeoutMs ?? 20000;
+    this.keepAliveIntervalMs = opts.keepAliveIntervalMs ?? 20000;
+    this.noiseKey = opts.noiseKey;
+    this.ramLevel = opts.ramLevel ?? 2;
+    this.bufferPool = new BufferPool(8192, this.ramLevel === 3 ? 32 : 16);
+  }
+
+  /**
+   * Connect ke WhatsApp WebSocket server
+   */
+  async connect(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.logger.info(`Connecting to ${this.url}`);
+      this.ws = new WebSocket(this.url, {
+        origin: 'https://web.whatsapp.com',
+        headers: {
+          'Origin': 'https://web.whatsapp.com',
+          'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+        },
+        perMessageDeflate: false, // Hindari CPU overhead untuk RAM efficiency
+        maxPayload: 16 * 1024 * 1024 // 16MB max payload
+      });
+
+      // Connect timeout
+      this.connectTimer = setTimeout(() => {
+        if (!this.isOpen) {
+          this.ws?.terminate();
+          reject(new Error('WebSocket connect timeout'));
+        }
+      }, this.connectTimeoutMs);
+
+      this.ws.on('open', () => {
+        this.logger.info('WebSocket connected, performing Noise handshake');
+        this.isOpen = true;
+        if (this.connectTimer) {
+          clearTimeout(this.connectTimer);
+          this.connectTimer = null;
+        }
+        this.startHandshake().then(() => {
+          this.isHandshakeDone = true;
+          this.emit('handshake:done');
+          this.startKeepAlive();
+          resolve();
+        }).catch(err => {
+          this.logger.error(`Handshake failed: ${err.message}`);
+          this.emit('handshake:error', err);
+          reject(err);
+        });
+      });
+
+      this.ws.on('message', (data: Buffer) => this.handleMessage(data));
+      this.ws.on('close', (code: number, reason: Buffer) => {
+        this.logger.warn(`WebSocket closed: ${code} ${reason.toString()}`);
+        this.isOpen = false;
+        this.isHandshakeDone = false;
+        this.stopKeepAlive();
+        this.emit('close', code, reason.toString());
+      });
+      this.ws.on('error', (err: Error) => {
+        this.logger.error(`WebSocket error: ${err.message}`);
+        this.emit('error', err);
+        if (!this.isOpen) {
+          if (this.connectTimer) {
+            clearTimeout(this.connectTimer);
+            this.connectTimer = null;
+          }
+          reject(err);
+        }
+      });
+    });
+  }
+
+  /**
+   * Start Noise Protocol XX handshake
+   */
+  private async startHandshake(): Promise<void> {
+    this.handshake = new NoiseHandshake(this.noiseKey, true);
+
+    // Build client hello: ephemeral + encrypted static + encrypted payload
+    const clientPayload = this.buildClientPayload();
+    const clientHello = this.handshake.buildClientHello(clientPayload);
+
+    // Wrap dengan WA frame header
+    const frame = NoiseHandshake.encodeFrame(clientHello);
+    this.ws!.send(Buffer.from(frame));
+
+    // Wait for server response
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error('Handshake response timeout'));
+      }, 15000);
+
+      const onceHandler = (data: Buffer) => {
+        clearTimeout(timeout);
+        this.ws!.off('message', onceHandler);
+        try {
+          this.processHandshakeResponse(data);
+          resolve();
+        } catch (err) {
+          reject(err);
+        }
+      };
+      this.ws!.once('message', onceHandler);
+    });
+  }
+
+  /**
+   * Process handshake response dari server
+   */
+  private processHandshakeResponse(data: Buffer): void {
+    if (!this.handshake) throw new Error('No handshake state');
+
+    // Strip WA header (7 bytes: WA + version + length)
+    const payload = data.subarray(7);
+    this.handshake.readResponderHandshake(payload);
+
+    // Finalize - dapatkan traffic keys
+    const { sendKey, recvKey } = this.handshake.finalize();
+    this.trafficCipher = new TrafficCipher(sendKey, recvKey);
+    this.logger.debug('Noise handshake completed, traffic keys derived');
+  }
+
+  /**
+   * Build client payload - browser info + pairing static key
+   */
+  private buildClientPayload(): Uint8Array {
+    const enc = new TextEncoder();
+    const parts: Uint8Array[] = [];
+
+    parts.push(enc.encode(this.browser[0]));
+    parts.push(enc.encode(this.browser[1]));
+    parts.push(enc.encode(this.browser[2]));
+
+    // Generate pairing static key (atau reuse dari creds)
+    const pairingKey = this.noiseKey ?? this.generatePairingKey();
+    parts.push(pairingKey.public);
+
+    // Encode as length-prefixed
+    const result: number[] = [];
+    for (const p of parts) {
+      result.push(p.length);
+      for (let i = 0; i < p.length; i++) result.push(p[i]);
+    }
+    return new Uint8Array(result);
+  }
+
+  private generatePairingKey(): { private: Uint8Array; public: Uint8Array } {
+    const { generateCurveKeyPair } = require('../core/crypto.js');
+    return generateCurveKeyPair();
+  }
+
+  /**
+   * Handle incoming message - decrypt jika handshake done
+   */
+  private handleMessage(data: Buffer): void {
+    if (!this.isHandshakeDone) {
+      // Should be handled by handshake
+      return;
+    }
+    try {
+      // Strip WA header (7 bytes) dan decrypt
+      const payload = data.subarray(7);
+      const plaintext = this.trafficCipher!.decrypt(payload);
+      this.emit('message', plaintext);
+    } catch (err: any) {
+      this.logger.error(`Message decrypt failed: ${err.message}`);
+      this.emit('error', err);
+    }
+  }
+
+  /**
+   * Send encrypted frame ke server
+   */
+  send(plaintext: Uint8Array): void {
+    if (!this.isHandshakeDone || !this.trafficCipher) {
+      throw new Error('Cannot send before handshake complete');
+    }
+    const ciphertext = this.trafficCipher.encrypt(plaintext);
+    const frame = NoiseHandshake.encodeFrame(ciphertext);
+    this.ws!.send(Buffer.from(frame));
+  }
+
+  /**
+   * Start keep-alive ping
+   */
+  private startKeepAlive(): void {
+    this.stopKeepAlive();
+    this.keepAliveTimer = setInterval(() => {
+      if (this.isOpen && this.isHandshakeDone) {
+        // Send ping sebagai binary node "iq" type "get" query "ping"
+        const pingFrame = this.buildPingFrame();
+        try {
+          this.send(pingFrame);
+        } catch (err: any) {
+          this.logger.warn(`Keep-alive ping failed: ${err.message}`);
+        }
+      }
+    }, this.keepAliveIntervalMs);
+  }
+
+  private stopKeepAlive(): void {
+    if (this.keepAliveTimer) {
+      clearInterval(this.keepAliveTimer);
+      this.keepAliveTimer = null;
+    }
+  }
+
+  /**
+   * Build ping frame: <iq type="get"><ping/></iq>
+   */
+  private buildPingFrame(): Uint8Array {
+    // Simple binary ping: tag=iq, attrs={type:get}, content=ping node
+    const { encodeBinaryNode } = require('../core/binary.js');
+    const node = {
+      tag: 'iq',
+      attrs: { type: 'get', id: this.generateId() },
+      content: [{ tag: 'ping', attrs: {} }]
+    };
+    return encodeBinaryNode(node);
+  }
+
+  private generateId(): string {
+    return Date.now().toString(36) + Math.random().toString(36).substr(2, 8);
+  }
+
+  /**
+   * Close WebSocket connection
+   */
+  close(code: number = 1000, reason: string = 'normal'): void {
+    this.stopKeepAlive();
+    if (this.connectTimer) {
+      clearTimeout(this.connectTimer);
+      this.connectTimer = null;
+    }
+    this.isOpen = false;
+    this.isHandshakeDone = false;
+    if (this.ws) {
+      this.ws.close(code, reason);
+    }
+  }
+
+  /**
+   * Get connection state
+   */
+  isConnected(): boolean {
+    return this.isOpen && this.isHandshakeDone;
+  }
+
+  /**
+   * Get traffic cipher (untuk debug)
+   */
+  getTrafficCipher(): TrafficCipher | null {
+    return this.trafficCipher;
+  }
+}
+
+export default WAWebSocket;