@kangwifi-pro/waliwa 1.0.0

package/src/socket/hybrid.ts

@@ -0,0 +1,414 @@
+/**
+ * Waliwa - Mobile API socket layer
+ *
+ * Companion device pairing via phone number + code (no QR scan needed).
+ * Mengikuti WhatsApp Mobile API registration flow:
+ * 1. Request pairing code untuk phone number
+ * 2. User input code di WA mobile app
+ * 3. Server pair device, return identity keys
+ * 4. Switch ke WA Web protocol untuk ongoing communication
+ *
+ * Hybrid approach: pairing via Mobile API, communication via WA Web WS
+ */
+
+import { EventEmitter } from 'events';
+import { WAWebSocket } from './ws-socket.js';
+import { NoiseHandshake, TrafficCipher } from '../core/noise.js';
+import { generateCurveKeyPair, getRandomBytes, hkdfDerive } from '../core/crypto.js';
+import { encodeBinaryNode, decodeBinaryNode, BinaryNode } from '../core/binary.js';
+import { generatePairingCode, parsePairingResult, PairingCodeExpiry } from '../auth/pairing-code.js';
+import { SilentLogger } from '../utils/logger.js';
+import type {
+  AuthenticationCreds,
+  PairingCodeResult,
+  WALogger,
+  WaliwaConfig,
+  ConnectionUpdate
+} from '../types/index.js';
+
+// ============== Mobile Socket ==============
+
+export interface MobileSocketOptions {
+  phoneNumber: string;
+  creds: AuthenticationCreds;
+  logger?: WALogger;
+  /** Browser identification */
+  browser?: [string, string, string];
+  /** WA WebSocket URL setelah pairing */
+  waWsUrl?: string;
+  connectTimeoutMs?: number;
+  ramLevel?: 1 | 2 | 3;
+}
+
+/**
+ * Mobile API socket - handles companion device pairing via phone number
+ *
+ * Flow:
+ * 1. connect() - init WA WebSocket
+ * 2. requestPairing() - generate pairing code untuk user
+ * 3. wait for user to input code di mobile app
+ * 4. server sends pairing confirmation
+ * 5. switch ke normal WA Web communication
+ */
+export class MobileAPISocket extends EventEmitter {
+  private phoneNumber: string;
+  private creds: AuthenticationCreds;
+  private logger: WALogger;
+  private browser: [string, string, string];
+  private waWsUrl: string;
+  private connectTimeoutMs: number;
+  private ramLevel: 1 | 2 | 3;
+
+  private ws: WAWebSocket | null = null;
+  private pairingExpiry: PairingCodeExpiry | null = null;
+  private isPairing: boolean = false;
+
+  constructor(opts: MobileSocketOptions) {
+    super();
+    this.phoneNumber = opts.phoneNumber;
+    this.creds = opts.creds;
+    this.logger = opts.logger ?? new SilentLogger();
+    this.browser = opts.browser ?? ['Waliwa', 'WA', '1.0.0'];
+    this.waWsUrl = opts.waWsUrl ?? 'wss://web.whatsapp.com/ws/chat';
+    this.connectTimeoutMs = opts.connectTimeoutMs ?? 30000;
+    this.ramLevel = opts.ramLevel ?? 2;
+  }
+
+  /**
+   * Connect dan start pairing flow
+   */
+  async connect(): Promise<PairingCodeResult> {
+    this.logger.info(`Starting Mobile API pairing untuk phone: ${this.phoneNumber}`);
+
+    // Init WA WebSocket dengan Noise handshake
+    this.ws = new WAWebSocket({
+      url: this.waWsUrl,
+      logger: this.logger,
+      browser: this.browser,
+      connectTimeoutMs: this.connectTimeoutMs,
+      noiseKey: this.creds.noiseKey,
+      ramLevel: this.ramLevel
+    });
+
+    // Listen for incoming nodes
+    this.ws.on('message', (data: Uint8Array) => this.handleIncomingData(data));
+    this.ws.on('close', (code: number, reason: string) => {
+      this.logger.warn(`Mobile socket closed: ${code} ${reason}`);
+      this.emit('close', code, reason);
+    });
+    this.ws.on('error', (err: Error) => {
+      this.logger.error(`Mobile socket error: ${err.message}`);
+      this.emit('error', err);
+    });
+
+    await this.ws.connect();
+    this.logger.info('WebSocket connected, generating pairing code');
+
+    // Generate pairing code
+    const pairingResult = generatePairingCode(this.phoneNumber, this.creds, this.logger);
+
+    // Setup expiry
+    this.pairingExpiry = new PairingCodeExpiry(
+      pairingResult.expiresAt,
+      () => {
+        this.logger.warn('Pairing code expired');
+        this.emit('pairing:expired');
+      }
+    );
+    this.pairingExpiry.start();
+
+    // Send pairing request ke server
+    await this.sendPairingRequest(pairingResult);
+
+    this.isPairing = true;
+    return pairingResult;
+  }
+
+  /**
+   * Send pairing request ke server
+   */
+  private async sendPairingRequest(pairing: PairingCodeResult): Promise<void> {
+    if (!this.creds.pairingKey) {
+      throw new Error('No pairing key in creds');
+    }
+
+    const pairNode: BinaryNode = {
+      tag: 'iq',
+      attrs: {
+        type: 'set',
+        to: 's.whatsapp.net',
+        id: `pair-${Date.now()}`
+      },
+      content: [
+        {
+          tag: 'pair',
+          attrs: {
+            code: pairing.code.replace('-', ''),
+            phone: pairing.phoneNumber,
+            pubkey: Buffer.from(this.creds.pairingKey.public).toString('base64'),
+            platform: this.browser[0]
+          }
+        }
+      ]
+    };
+
+    this.ws!.send(encodeBinaryNode(pairNode));
+    this.logger.debug(`Pairing request sent for ${pairing.phoneNumber}`);
+  }
+
+  /**
+   * Handle incoming data
+   */
+  private handleIncomingData(data: Uint8Array): void {
+    try {
+      const node = decodeBinaryNode(data);
+      if (!node) return;
+
+      // Pairing response
+      if (node.tag === 'iq' && node.attrs?.id?.startsWith('pair-')) {
+        const result = parsePairingResult(node);
+        if (result.success) {
+          this.logger.info(`Pairing successful: paired with ${result.jid}`);
+          // Update creds
+          this.creds.registered = true;
+          if (result.jid) {
+            this.creds.me = result.jid;
+          }
+          if (result.identityKey) {
+            // Store server-side identity
+            this.logger.debug('Got server identity key');
+          }
+          if (this.pairingExpiry) {
+            this.pairingExpiry.cancel();
+            this.pairingExpiry = null;
+          }
+          this.isPairing = false;
+          this.emit('paired', result);
+          this.emit('connection.update', {
+            connection: 'open',
+            isNewLogin: true
+          } as ConnectionUpdate);
+        } else {
+          this.logger.error(`Pairing failed: ${result.error}`);
+          this.emit('pairing:error', new Error(result.error));
+        }
+        return;
+      }
+
+      // Re-emit other nodes untuk processing selanjutnya
+      this.emit('message', node);
+    } catch (err: any) {
+      this.logger.error(`Failed to process data: ${err.message}`);
+    }
+  }
+
+  /**
+   * Send raw data via WebSocket
+   */
+  send(data: Uint8Array): void {
+    if (!this.ws || !this.ws.isConnected()) {
+      throw new Error('Socket not connected');
+    }
+    this.ws.send(data);
+  }
+
+  /**
+   * Get underlying WA WebSocket (untuk pas-pairing switch ke WA Web mode)
+   */
+  getWebSocket(): WAWebSocket | null {
+    return this.ws;
+  }
+
+  /**
+   * Close socket
+   */
+  async close(): Promise<void> {
+    if (this.pairingExpiry) {
+      this.pairingExpiry.cancel();
+      this.pairingExpiry = null;
+    }
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.isPairing = false;
+  }
+
+  isPairingInProgress(): boolean {
+    return this.isPairing;
+  }
+}
+
+// ============== Hybrid Socket Manager ==============
+
+export interface HybridSocketOptions extends WaliwaConfig {
+  /** Primary mode: 'web' (QR) atau 'mobile' (pairing code) */
+  primaryMode?: 'web' | 'mobile';
+  /** Phone number (required jika primaryMode='mobile') */
+  phoneNumber?: string;
+  /** Auto-fallback ke other mode jika primary gagal */
+  autoFallback?: boolean;
+}
+
+/**
+ * Hybrid socket manager - otomatis switch antara WA Web (QR) dan Mobile API (pairing)
+ *
+ * - Primary mode: coba connect dengan mode utama
+ * - Fallback: jika gagal setelah maxRetries, switch ke mode lain
+ * - Mode switching transparent ke caller
+ */
+export class HybridSocketManager extends EventEmitter {
+  private opts: Required<HybridSocketOptions>;
+  private currentMode: 'web' | 'mobile';
+  private currentSocket: WAWebSocket | MobileAPISocket | null = null;
+  private retryCount: number = 0;
+
+  constructor(opts: HybridSocketOptions) {
+    super();
+    this.opts = {
+      ...opts,
+      primaryMode: opts.primaryMode ?? (opts.mobile ? 'mobile' : 'web'),
+      autoFallback: opts.autoFallback ?? true,
+      phoneNumber: opts.phoneNumber ?? '',
+      wsURL: opts.wsURL ?? 'wss://web.whatsapp.com/ws/chat',
+      connectTimeoutMs: opts.connectTimeoutMs ?? 20000,
+      keepAliveIntervalMs: opts.keepAliveIntervalMs ?? 20000,
+      ramOptimizationLevel: opts.ramOptimizationLevel ?? 2,
+      browser: opts.browser ?? ['Waliwa', 'WA', '1.0.0'],
+      printQRInTerminal: opts.printQRInTerminal ?? false,
+      mobile: opts.mobile ?? false,
+      syncFullHistory: opts.syncFullHistory ?? false,
+      maxMsgRetryCount: opts.maxMsgRetryCount ?? 5,
+      maxReconnectAttempts: opts.maxReconnectAttempts ?? 10,
+      reconnectInterval: opts.reconnectInterval ?? 2000,
+      markOnlineOnConnect: opts.markOnlineOnConnect ?? true,
+      fetchAgent: opts.fetchAgent
+    } as any;
+    this.currentMode = this.opts.primaryMode;
+  }
+
+  /**
+   * Connect dengan hybrid mode
+   */
+  async connect(): Promise<any> {
+    if (this.currentMode === 'mobile') {
+      if (!this.opts.phoneNumber) {
+        if (this.opts.autoFallback) {
+          this.logger().info('No phone number provided, falling back to QR mode');
+          this.currentMode = 'web';
+          return this.connect();
+        }
+        throw new Error('phoneNumber required untuk Mobile API mode');
+      }
+
+      const mobileSocket = new MobileAPISocket({
+        phoneNumber: this.opts.phoneNumber!,
+        creds: this.opts.authState!.creds,
+        logger: this.logger(),
+        browser: this.opts.browser!,
+        waWsUrl: this.opts.wsURL!,
+        connectTimeoutMs: this.opts.connectTimeoutMs!,
+        ramLevel: this.opts.ramOptimizationLevel!
+      });
+
+      mobileSocket.on('paired', (result) => this.emit('paired', result));
+      mobileSocket.on('pairing:error', (err) => this.handleModeError(err));
+      mobileSocket.on('pairing:expired', () => this.handleModeError(new Error('Pairing expired')));
+      mobileSocket.on('connection.update', (update) => this.emit('connection.update', update));
+      mobileSocket.on('message', (node) => this.emit('message', node));
+
+      this.currentSocket = mobileSocket;
+      return mobileSocket.connect();
+    } else {
+      // Web mode
+      const wsSocket = new WAWebSocket({
+        url: this.opts.wsURL!,
+        logger: this.logger(),
+        browser: this.opts.browser!,
+        connectTimeoutMs: this.opts.connectTimeoutMs!,
+        keepAliveIntervalMs: this.opts.keepAliveIntervalMs!,
+        noiseKey: this.opts.authState!.creds.noiseKey,
+        ramLevel: this.opts.ramOptimizationLevel!
+      });
+
+      wsSocket.on('message', (data: Uint8Array) => this.emit('message', data));
+      wsSocket.on('close', (code: number, reason: string) => {
+        this.emit('close', code, reason);
+      });
+      wsSocket.on('error', (err: Error) => this.handleModeError(err));
+
+      this.currentSocket = wsSocket;
+      return wsSocket.connect();
+    }
+  }
+
+  /**
+   * Handle error dari current socket - mungkin switch mode
+   */
+  private handleModeError(err: Error): void {
+    this.retryCount++;
+    this.logger().error(`Socket error (${this.currentMode} mode): ${err.message}`);
+
+    if (this.opts.autoFallback && this.retryCount >= 3) {
+      // Switch mode
+      const newMode = this.currentMode === 'web' ? 'mobile' : 'web';
+      this.logger().warn(`Switching from ${this.currentMode} to ${newMode} mode after ${this.retryCount} retries`);
+      this.currentMode = newMode;
+      this.retryCount = 0;
+
+      // Close current dan reconnect
+      if (this.currentSocket) {
+        if (this.currentSocket instanceof MobileAPISocket) {
+          this.currentSocket.close();
+        } else {
+          this.currentSocket.close();
+        }
+        this.currentSocket = null;
+      }
+
+      // Reconnect dengan mode baru
+      this.connect().catch(reconnectErr => {
+        this.logger().error(`Reconnect failed: ${reconnectErr.message}`);
+      });
+    }
+  }
+
+  /**
+   * Send data via current socket
+   */
+  send(data: Uint8Array): void {
+    if (!this.currentSocket) {
+      throw new Error('No active socket');
+    }
+    if (this.currentSocket instanceof MobileAPISocket) {
+      this.currentSocket.send(data);
+    } else {
+      this.currentSocket.send(data);
+    }
+  }
+
+  /**
+   * Close socket
+   */
+  async close(): Promise<void> {
+    if (this.currentSocket) {
+      if (this.currentSocket instanceof MobileAPISocket) {
+        await this.currentSocket.close();
+      } else {
+        this.currentSocket.close();
+      }
+      this.currentSocket = null;
+    }
+  }
+
+  /**
+   * Get current mode
+   */
+  getCurrentMode(): 'web' | 'mobile' {
+    return this.currentMode;
+  }
+
+  private logger(): WALogger {
+    return this.opts.logger ?? new SilentLogger();
+  }
+}