@kangwifi-pro/waliwa 1.0.0

package/src/socket/wa-socket.ts

@@ -0,0 +1,1347 @@
+/**
+ * Waliwa - Main WASocket interface
+ * Entry point untuk WhatsApp bot - gabungin semua components (WebSocket, Auth, Messages, Groups, Calls)
+ *
+ * API Baileys-style dengan RAM optimization:
+ * - Lazy initialization
+ * - Buffer pooling
+ * - Debounced writes
+ * - Event-driven (no polling overhead)
+ */
+
+import { WAWebSocket } from '../socket/ws-socket.js';
+import { WAWebSocketOptions } from '../socket/ws-socket.js';
+import { NoiseHandshake } from '../core/noise.js';
+import { decodeBinaryNode, encodeBinaryNode, BinaryNode } from '../core/binary.js';
+import { WAEventEmitter } from '../events/emitter.js';
+import {
+  MessageSender,
+  MessageReceiver,
+  PendingMessageTracker,
+  buildReadReceiptNode,
+  buildChatPresenceNode
+} from '../messages/send.js';
+import {
+  MediaUploader,
+  MediaDownloader
+} from '../messages/media.js';
+import { GroupManager } from '../groups/management.js';
+import { CallHandler } from '../calls/handler.js';
+import { FileAuthState } from '../auth/auth-state.js';
+import { generateQRCodeData, QRRefreshManager } from '../auth/qr-code.js';
+import { generatePairingCode, normalizePhoneNumber } from '../auth/pairing-code.js';
+import { jidToString } from '../utils/jid.js';
+import { defaultLogger, SilentLogger } from '../utils/logger.js';
+import { retry, RateLimiter } from '../utils/retry.js';
+// SKDM imports
+import { SKDM } from '../skdm/index.js';
+// Fixes imports
+import {
+  ConnectionHeartbeat,
+  IdempotencyCache,
+  GroupEventCoalescer,
+  HistorySyncManager,
+  DecryptionRetryQueue,
+  MessageQueue,
+  ChunkedMediaUploader,
+  SmarterReconnector
+} from '../fixes/index.js';
+// Features imports
+import {
+  HealthMonitor,
+  WebhookManager,
+  CircuitBreaker,
+  RateLimitTracker,
+  MessagePersistence
+} from '../features/index.js';
+// Recovery imports
+import {
+  RecoveryManager,
+  mapCodeToReason,
+  type RecoveryConfig,
+  type DisconnectReason
+} from '../recovery/index.js';
+import type {
+  WaliwaConfig,
+  ConnectionUpdate,
+  QRGenerationData,
+  PairingCodeResult,
+  MessageContent,
+  WAMessage,
+  WAMessageKey,
+  JIDLike,
+  SendMessageResult,
+  WAGroupMetadata,
+  GroupCreateOptions,
+  WACallEvent,
+  PresenceType,
+  MessageStatus,
+  AuthenticationCreds,
+  WAChat,
+  ContactRecord,
+  GroupParticipantUpdate,
+  WALogger,
+  MessageType,
+  MessageUpsertType,
+  AuthState
+} from '../types/index.js';
+
+// ============== WASocket ==============
+
+export interface WASocket {
+  // Connection
+  /** Event emitter untuk semua WhatsApp events */
+  ev: WAEventEmitter;
+  /** Auth state */
+  authState: AuthState;
+  /** Logger */
+  user: { id: string; name?: string } | undefined;
+
+  // Auth methods
+  /** Logout dan clear session */
+  logout(): Promise<void>;
+  /** Refetch QR code */
+  refreshQR(): Promise<QRGenerationData>;
+  /** Request pairing code (Mobile API mode) */
+  requestPairingCode(phoneNumber: string): Promise<PairingCodeResult>;
+
+  // Message methods
+  sendMessage(jid: JIDLike, content: MessageContent, opts?: any): Promise<SendMessageResult>;
+  forwardMessage(to: JIDLike, message: WAMessage): Promise<SendMessageResult>;
+  deleteMessage(jid: JIDLike, key: WAMessageKey, opts?: { revokeEveryone?: boolean }): Promise<SendMessageResult>;
+  reactToMessage(jid: JIDLike, key: WAMessageKey, emoji: string): Promise<SendMessageResult>;
+  /** Send read receipt */
+  sendReadReceipt(jid: JIDLike, messageIds: string[], participant?: JIDLike): Promise<void>;
+  /** Send typing indicator */
+  sendPresenceUpdate(jid: JIDLike, presence: PresenceType): Promise<void>;
+  /** Update presence (online/offline) */
+  updatePresence(presence: 'available' | 'unavailable'): Promise<void>;
+
+  // Media
+  uploadMedia(media: Buffer | Uint8Array, mediaType: string, mimetype: string, fileName?: string): Promise<any>;
+  downloadMedia(url: string, mediaKey: Uint8Array, mediaType: string, mimetype: string, fileName?: string): Promise<any>;
+
+  // Group methods
+  groupCreate(opts: GroupCreateOptions): Promise<WAGroupMetadata>;
+  groupMetadata(jid: JIDLike): Promise<WAGroupMetadata>;
+  groupUpdateSubject(jid: JIDLike, subject: string): Promise<void>;
+  groupUpdateDescription(jid: JIDLike, desc: string): Promise<void>;
+  groupParticipantsUpdate(jid: JIDLike, participants: JIDLike[], action: 'add' | 'remove' | 'promote' | 'demote'): Promise<void>;
+  groupLeave(jid: JIDLike): Promise<void>;
+  groupInviteCode(jid: JIDLike): Promise<string>;
+  groupRevokeInvite(jid: JIDLike): Promise<string>;
+  groupJoinViaCode(code: string): Promise<JIDLike>;
+  groupSettingUpdate(jid: JIDLike, setting: 'restrict' | 'announce', value: boolean): Promise<void>;
+
+  // Call methods
+  rejectCall(callId: string, from: JIDLike): Promise<void>;
+
+  // Chat methods
+  chatModify(modification: any, jid: JIDLike): Promise<void>;
+  /** Mark chat sebagai read */
+  readChat(jid: JIDLike): Promise<void>;
+  /** Archive chat */
+  archiveChat(jid: JIDLike, archive: boolean): Promise<void>;
+  /** Mute chat */
+  muteChat(jid: JIDLike, durationMs: number): Promise<void>;
+  /** Pin chat */
+  pinChat(jid: JIDLike, durationMs: number): Promise<void>;
+  /** Delete chat */
+  deleteChat(jid: JIDLike): Promise<void>;
+
+  // Presence
+  presenceSubscribe(jids: JIDLike[]): Promise<void>;
+
+  // Connection management
+  end(newConnection?: boolean): Promise<void>;
+  /** Get connection state */
+  getConnectionState(): 'close' | 'open' | 'connecting';
+}
+
+// ============== WASocket Implementation ==============
+
+export class WASocketImpl implements WASocket {
+  ev: WAEventEmitter;
+  authState: AuthState;
+  user: { id: string; name?: string } | undefined;
+  private logger: WALogger;
+  private ws: WAWebSocket | null = null;
+  private config: WaliwaConfig & {
+    wsURL: string;
+    browser: [string, string, string];
+    reconnectInterval: number;
+    maxReconnectAttempts: number;
+    syncFullHistory: boolean;
+    maxMsgRetryCount: number;
+    connectTimeoutMs: number;
+    keepAliveIntervalMs: number;
+    ramOptimizationLevel: 1 | 2 | 3;
+    markOnlineOnConnect: boolean;
+    printQRInTerminal: boolean;
+    mobile: boolean;
+    phoneNumber?: string;
+  };
+  private messageSender: MessageSender;
+  private messageReceiver: MessageReceiver;
+  private mediaUploader: MediaUploader;
+  private mediaDownloader: MediaDownloader;
+  private groupManager: GroupManager | null = null;
+  private callHandler: CallHandler | null = null;
+  private pendingTracker: PendingMessageTracker;
+  private iqHandlers: Map<string, (node: BinaryNode) => void> = new Map();
+  private qrRefreshManager: QRRefreshManager | null = null;
+  private rateLimiter: RateLimiter;
+  private connectionState: 'close' | 'open' | 'connecting' = 'close';
+
+  // SKDM
+  public skdm: SKDM | null = null;
+
+  // Fixes
+  private heartbeat: ConnectionHeartbeat | null = null;
+  private idempotencyCache: IdempotencyCache;
+  private groupEventCoalescer: GroupEventCoalescer | null = null;
+  private historySyncManager: HistorySyncManager;
+  private decryptionRetryQueue: DecryptionRetryQueue | null = null;
+  private messageQueue: MessageQueue;
+  private chunkedUploader: ChunkedMediaUploader;
+  private reconnector: SmarterReconnector | null = null;
+
+  // Features
+  public healthMonitor: HealthMonitor;
+  public webhookManager: WebhookManager;
+  public circuitBreaker: CircuitBreaker;
+  public rateLimitTracker: RateLimitTracker;
+  public messagePersistence: MessagePersistence;
+
+  // Recovery (Multi-Branch SKDM Recovery)
+  public recoveryManager: RecoveryManager;
+
+  // Auto-recovery timer
+  private reconnectTimer: NodeJS.Timeout | null = null;
+  private reconnectAttempts: number = 0;
+
+  constructor(config: WaliwaConfig = {}, authState: AuthState) {
+    this.ev = new WAEventEmitter();
+    this.authState = authState;
+    this.logger = config.logger ?? defaultLogger;
+
+    // Default config
+    this.config = {
+      authState,
+      logger: this.logger,
+      printQRInTerminal: config.printQRInTerminal ?? false,
+      mobile: config.mobile ?? false,
+      phoneNumber: config.phoneNumber,
+      browser: config.browser ?? ['Waliwa', 'WA', '1.0.0'],
+      reconnectInterval: config.reconnectInterval ?? 2000,
+      maxReconnectAttempts: config.maxReconnectAttempts ?? 10,
+      syncFullHistory: config.syncFullHistory ?? false,
+      maxMsgRetryCount: config.maxMsgRetryCount ?? 5,
+      wsURL: config.wsURL ?? 'wss://web.whatsapp.com/ws/chat',
+      connectTimeoutMs: config.connectTimeoutMs ?? 20000,
+      keepAliveIntervalMs: config.keepAliveIntervalMs ?? 20000,
+      ramOptimizationLevel: config.ramOptimizationLevel ?? 2,
+      markOnlineOnConnect: config.markOnlineOnConnect ?? true,
+      fetchAgent: config.fetchAgent
+    };
+
+    this.pendingTracker = new PendingMessageTracker();
+    this.messageSender = new MessageSender({
+      send: (data) => this.send(data),
+      logger: this.logger,
+      tracker: this.pendingTracker
+    });
+    this.messageReceiver = new MessageReceiver({
+      logger: this.logger,
+      onMessage: (messages, type) => {
+        this.ev.emit('message.upsert', { messages, type });
+      },
+      onStatusUpdate: (key, status) => {
+        this.ev.emit('message.update', {
+          messages: [{ key, status } as any],
+          keys: [key]
+        });
+      }
+    });
+    this.mediaUploader = new MediaUploader({
+      logger: this.logger,
+      httpAgent: this.config.fetchAgent
+    });
+    this.mediaDownloader = new MediaDownloader({
+      logger: this.logger,
+      httpAgent: this.config.fetchAgent
+    });
+
+    // Rate limiter: 20 messages/sec
+    this.rateLimiter = new RateLimiter(20);
+
+    // Initialize fixes (Baileys issues)
+    this.idempotencyCache = new IdempotencyCache(10000, 24 * 60 * 60 * 1000, this.logger);
+    this.historySyncManager = new HistorySyncManager(this.logger);
+    this.messageQueue = new MessageQueue(10, this.logger);
+    this.chunkedUploader = new ChunkedMediaUploader({ logger: this.logger });
+
+    // Initialize features
+    this.healthMonitor = new HealthMonitor({ logger: this.logger });
+    this.webhookManager = new WebhookManager({ logger: this.logger });
+    this.circuitBreaker = new CircuitBreaker({ logger: this.logger });
+    this.rateLimitTracker = new RateLimitTracker({ logger: this.logger });
+    this.messagePersistence = new MessagePersistence({ logger: this.logger });
+
+    // Initialize SKDM (Store Key Data Manager)
+    this.skdm = new SKDM(this.authState.creds, this.authState.keys, {
+      storageFolder: './auth',
+      logger: this.logger,
+      ...config
+    });
+
+    // Initialize Multi-Branch SKDM Recovery system
+    const recoveryConfig: RecoveryConfig = (config as any).recovery ?? {};
+    this.recoveryManager = new RecoveryManager({
+      enabled: recoveryConfig.enabled ?? true,
+      maxAttemptsPerBranch: recoveryConfig.maxAttemptsPerBranch ?? 3,
+      maxTotalAttempts: recoveryConfig.maxTotalAttempts ?? 20,
+      initialDelayMs: recoveryConfig.initialDelayMs ?? 1000,
+      maxDelayMs: recoveryConfig.maxDelayMs ?? 60000,
+      rateLimitedDelayMs: recoveryConfig.rateLimitedDelayMs ?? 300000,
+      logger: this.logger
+    });
+
+    // Bind recovery action handlers ke WASocket internals
+    this.setupRecoveryHandlers();
+
+    // Listen ke recovery events untuk forwarding ke main event emitter
+    this.recoveryManager.on('recovery:start', (info) => {
+      this.logger.info(`Recovery started: ${info.reason}`);
+      this.ev.emit('connection.update', {
+        connection: 'connecting',
+        lastDisconnect: { error: undefined, output: { code: info.code, reason: info.message } }
+      });
+    });
+
+    this.recoveryManager.on('recovery:success', (info) => {
+      this.logger.info(`Recovery succeeded: ${info.reason} (${info.totalAttempts} attempts)`);
+      this.healthMonitor.recordReconnect();
+    });
+
+    this.recoveryManager.on('recovery:failed', (info) => {
+      this.logger.error(`Recovery failed: ${info.reason} (fatal: ${info.fatal})`);
+      if (info.fatal) {
+        this.ev.emit('connection.update', {
+          connection: 'close',
+          lastDisconnect: {
+            error: new Error(`Fatal disconnect: ${info.reason}`),
+            output: { code: 0, reason: info.reason }
+          }
+        });
+      }
+    });
+  }
+
+  /**
+   * Setup recovery handlers - bind ke internal WASocket methods
+   */
+  private setupRecoveryHandlers(): void {
+    // Connect action
+    this.recoveryManager.connect = async (): Promise<boolean> => {
+      try {
+        if (this.ws) {
+          this.ws.close(4000, 'reconnect');
+          this.ws = null;
+        }
+        await this.connect();
+        return this.connectionState === 'open';
+      } catch (err: any) {
+        this.logger.error(`Recovery connect failed: ${err.message}`);
+        return false;
+      }
+    };
+
+    // Stream reconnect (resume from stream state)
+    this.recoveryManager.streamReconnect = async (): Promise<boolean> => {
+      try {
+        this.logger.info('Attempting stream reconnect (resume session)...');
+        // Reconnect tapi keep session state
+        if (this.ws) {
+          this.ws.close(4000, 'stream_reconnect');
+          this.ws = null;
+        }
+        // Quick reconnect dengan credentials yang sudah ada
+        await this.connect();
+        return this.connectionState === 'open';
+      } catch (err: any) {
+        this.logger.error(`Stream reconnect failed: ${err.message}`);
+        return false;
+      }
+    };
+
+    // Key refresh via SKDM
+    this.recoveryManager.refreshKeys = async (): Promise<void> => {
+      try {
+        this.logger.info('Refreshing Signal keys via SKDM...');
+        if (this.skdm) {
+          await this.skdm.preKeyManager.regeneratePreKeys();
+          this.skdm.markKeysDirty();
+          this.skdm.markCredsDirty();
+          await this.skdm.flush();
+        }
+      } catch (err: any) {
+        this.logger.error(`Key refresh failed: ${err.message}`);
+      }
+    };
+
+    // Pre-key fetch
+    this.recoveryManager.fetchPreKeys = async (): Promise<void> => {
+      try {
+        this.logger.info('Fetching pre-keys...');
+        if (this.skdm) {
+          await this.skdm.preKeyManager.regeneratePreKeys();
+          // Force upload ke server (will happen on next connect)
+        }
+      } catch (err: any) {
+        this.logger.error(`Pre-key fetch failed: ${err.message}`);
+      }
+    };
+
+    // Full re-auth (new QR)
+    this.recoveryManager.startFullReauth = async (): Promise<void> => {
+      try {
+        this.logger.info('Starting full re-authentication...');
+        // Clear existing creds untuk force new QR
+        if (this.skdm) {
+          // Keep noiseKey, tapi reset registration state
+          this.authState.creds.registered = false;
+          this.authState.creds.serverToken = undefined;
+          this.authState.creds.clientToken = undefined;
+          this.skdm.markCredsDirty();
+          await this.skdm.flush();
+        }
+        // Next connect akan trigger QR auth
+      } catch (err: any) {
+        this.logger.error(`Full re-auth setup failed: ${err.message}`);
+      }
+    };
+
+    // Update app version
+    this.recoveryManager.updateAppVersion = async (): Promise<void> => {
+      try {
+        this.logger.info('Updating app/browser version...');
+        // Bump version untuk bypass version-restricted endpoints
+        const versions = ['1.0.0', '1.1.0', '1.2.0', '2.0.0'];
+        const currentVersion = this.config.browser[2];
+        const currentIdx = versions.indexOf(currentVersion);
+        const newVersion = versions[Math.min(currentIdx + 1, versions.length - 1)] ?? '2.0.0';
+        this.config.browser = [this.config.browser[0], this.config.browser[1], newVersion];
+        this.logger.info(`App version updated to ${newVersion}`);
+      } catch (err: any) {
+        this.logger.error(`Update app version failed: ${err.message}`);
+      }
+    };
+  }
+
+  // ============== Connection ==============
+
+  /**
+   * Start connection ke WhatsApp server
+   */
+  async connect(): Promise<void> {
+    if (this.connectionState === 'open' || this.connectionState === 'connecting') {
+      return;
+    }
+
+    this.connectionState = 'connecting';
+    this.ev.emit('connection.update', { connection: 'connecting' });
+
+    try {
+      // Create WebSocket
+      this.ws = new WAWebSocket({
+        url: this.config.wsURL!,
+        logger: this.logger,
+        browser: this.config.browser!,
+        connectTimeoutMs: this.config.connectTimeoutMs!,
+        keepAliveIntervalMs: this.config.keepAliveIntervalMs!,
+        noiseKey: this.authState.creds.noiseKey,
+        ramLevel: this.config.ramOptimizationLevel!
+      });
+
+      // Listen for messages
+      this.ws.on('message', (data: Uint8Array) => this.handleIncomingData(data));
+      this.ws.on('close', (code: number, reason: string) => this.handleDisconnect(code, reason));
+      this.ws.on('error', (err: Error) => {
+        this.logger.error(`Socket error: ${err.message}`);
+        this.ev.emit('connection.update', {
+          connection: 'close',
+          lastDisconnect: { error: err, output: { code: 0, reason: err.message } }
+        });
+      });
+
+      await this.ws.connect();
+
+      this.connectionState = 'open';
+      this.logger.info('WhatsApp connection established');
+
+      // Initialize group manager & call handler
+      this.groupManager = new GroupManager({
+        send: (data) => this.send(data),
+        logger: this.logger,
+        registerIqHandler: (id, handler) => {
+          this.iqHandlers.set(id, handler);
+        }
+      });
+
+      this.callHandler = new CallHandler({
+        send: (data) => this.send(data),
+        logger: this.logger,
+        onCall: (event) => this.ev.emit('calls', event),
+        autoReject: false
+      });
+
+      // Start auth flow
+      if (!this.authState.creds.registered) {
+        if (this.config.mobile && this.config.phoneNumber) {
+          await this.requestPairingCode(this.config.phoneNumber);
+        } else {
+          await this.startQRAuth();
+        }
+      } else {
+        // Already registered - send login
+        await this.sendLogin();
+      }
+
+      // Initialize SKDM dan start background jobs
+      await this.skdm?.initialize();
+
+      // Start heartbeat (Baileys fix #4: connection hang)
+      this.heartbeat = new ConnectionHeartbeat({
+        sendPing: async () => {
+          // Send WA ping frame
+          const { encodeBinaryNode } = await import('../core/binary.js');
+          const pingNode = {
+            tag: 'iq',
+            attrs: { type: 'get', id: `ping-${Date.now()}` },
+            content: [{ tag: 'ping', attrs: {} }]
+          };
+          this.send(encodeBinaryNode(pingNode));
+        },
+        onDead: () => {
+          this.logger.error('Connection detected as dead, triggering reconnect');
+          this.handleDisconnect(4101, 'heartbeat dead');
+        },
+        logger: this.logger,
+        pingIntervalMs: this.config.keepAliveIntervalMs,
+        pongTimeoutMs: 10000,
+        maxMissedPongs: 3
+      });
+      this.heartbeat.start();
+
+      // Start group event coalescer (Baileys fix #7: group events missing)
+      this.groupEventCoalescer = new GroupEventCoalescer(
+        (events) => {
+          for (const event of events) {
+            this.ev.emit('group-participants.update', event);
+          }
+        },
+        100,
+        this.logger
+      );
+
+      // Start health monitor
+      this.healthMonitor.start(60000);
+      this.healthMonitor.recordPing();
+
+      // Send pending messages dari persistence (recover after restart)
+      const pendingMessages = this.messagePersistence.getPending();
+      if (pendingMessages.length > 0) {
+        this.logger.info(`Recovering ${pendingMessages.length} pending messages from persistence`);
+        for (const msg of pendingMessages) {
+          // Re-queue untuk send
+          this.sendMessage(msg.recipientJid, msg.content).catch(err => {
+            this.logger.error(`Failed to recover message ${msg.id}: ${err.message}`);
+          });
+        }
+      }
+
+      this.ev.emit('connection.update', { connection: 'open' });
+
+    } catch (err: any) {
+      this.connectionState = 'close';
+      this.logger.error(`Connect failed: ${err.message}`);
+      this.ev.emit('connection.update', {
+        connection: 'close',
+        lastDisconnect: { error: err, output: { code: 0, reason: err.message } }
+      });
+      throw err;
+    }
+  }
+
+  /**
+   * Handle incoming data dari WebSocket
+   */
+  private handleIncomingData(data: Uint8Array): void {
+    try {
+      const node = decodeBinaryNode(data);
+      if (!node) return;
+
+      // Record activity for heartbeat (Baileys fix #4)
+      this.heartbeat?.receivedPong();
+      this.healthMonitor.recordPing();
+      this.healthMonitor.recordReceive();
+
+      // Trigger webhook untuk incoming node (Features: webhook system)
+      this.webhookManager.trigger('node.received', { tag: node.tag, attrs: node.attrs });
+
+      // Check if it's an IQ response
+      if (node.tag === 'iq' && node.attrs?.id) {
+        // Check if it's a pong response
+        if (node.attrs.id?.startsWith('ping-')) {
+          this.heartbeat?.receivedPong();
+          return;
+        }
+        const handler = this.iqHandlers.get(node.attrs.id);
+        if (handler) {
+          this.iqHandlers.delete(node.attrs.id);
+          handler(node);
+          return;
+        }
+      }
+
+      // Handle by tag
+      switch (node.tag) {
+        case 'message': {
+          // Baileys fix #6: duplicate messages - check idempotency
+          const messageId = node.attrs?.id;
+          if (messageId && this.idempotencyCache.isDuplicate(messageId)) {
+            this.logger.debug(`Skipping duplicate message: ${messageId}`);
+            return;
+          }
+          this.messageReceiver.handleNode(node);
+          break;
+        }
+        case 'receipt':
+        case 'status':
+        case 'ack':
+          this.messageReceiver.handleNode(node);
+          break;
+        case 'call':
+          this.callHandler?.handleCallNode(node);
+          break;
+        case 'chat':
+          this.handleChatNode(node);
+          break;
+        case 'presence':
+          this.handlePresenceNode(node);
+          break;
+        case 'notification':
+          this.handleNotificationNode(node);
+          break;
+        case 'success':
+          this.logger.info('Authentication successful');
+          if (node.attrs?.user) {
+            this.user = { id: node.attrs.user, name: node.attrs.pushname };
+            this.authState.creds.me = node.attrs.user;
+            this.authState.creds.registered = true;
+            this.skdm?.markCredsDirty();
+          }
+          this.ev.emit('creds.update', this.authState.creds);
+          this.webhookManager.trigger('auth.success', { user: this.user });
+          break;
+        case 'failure':
+          this.logger.error('Authentication failed');
+          this.ev.emit('connection.update', {
+            connection: 'close',
+            lastDisconnect: { error: new Error('Auth failed'), output: node.attrs }
+          });
+          this.webhookManager.trigger('auth.failure', { attrs: node.attrs });
+          break;
+        default:
+          this.logger.trace(`Unhandled top-level node: ${node.tag}`);
+      }
+    } catch (err: any) {
+      this.logger.error(`Failed to process incoming data: ${err.message}`);
+    }
+  }
+
+  private handleChatNode(node: BinaryNode): void {
+    const attrs = node.attrs || {};
+    // Chat presence: typing, recording
+    const from = attrs.from;
+    if (attrs.type === 'composing' || attrs.type === 'recording' || attrs.type === 'paused') {
+      this.ev.emit('presence.update', {
+        jid: from,
+        presence: attrs.type as any
+      });
+    }
+  }
+
+  private handlePresenceNode(node: BinaryNode): void {
+    const attrs = node.attrs || {};
+    const from = attrs.from;
+    const type = attrs.type as PresenceType;
+    if (from && type) {
+      this.ev.emit('presence.update', {
+        jid: from,
+        presence: type,
+        t: attrs.t ? parseInt(attrs.t, 10) : undefined
+      });
+    }
+  }
+
+  private handleNotificationNode(node: BinaryNode): void {
+    const attrs = node.attrs || {};
+    const type = attrs.type;
+
+    if (Array.isArray(node.content)) {
+      for (const child of node.content) {
+        if (typeof child !== 'object' || !child.tag) continue;
+
+        switch (child.tag) {
+          case 'add':
+          case 'remove':
+          case 'promote':
+          case 'demote':
+            // Group participant update
+            const participants = Array.isArray(child.content)
+              ? child.content.filter(c => c?.tag === 'participant').map(c => c.attrs?.jid).filter(Boolean)
+              : [];
+            this.ev.emit('group-participants.update', {
+              id: attrs.from,
+              participants,
+              action: child.tag as any,
+              author: attrs.participant,
+              timestamp: Date.now()
+            });
+            break;
+          case 'subject':
+            // Group subject updated
+            this.ev.emit('groups.update', [{
+              id: attrs.from,
+              subject: child.attrs?.subject
+            }]);
+            break;
+        }
+      }
+    }
+  }
+
+  private handleDisconnect(code: number, reason: string): void {
+    this.connectionState = 'close';
+    this.pendingTracker.rejectAll(new Error(`Connection closed: ${code}`));
+
+    // Cleanup heartbeat
+    this.heartbeat?.stop();
+    this.heartbeat = null;
+
+    // Emit connection update
+    this.ev.emit('connection.update', {
+      connection: 'close',
+      lastDisconnect: {
+        error: undefined,
+        output: { code, reason }
+      }
+    });
+
+    // Skip recovery untuk intentional close (1000, 1001)
+    if (code === 1000 || code === 1001) {
+      this.logger.info('Intentional close, skipping recovery');
+      return;
+    }
+
+    // Skip jika recovery sudah in progress atau disabled
+    if (this.recoveryManager.isCurrentlyRecovering()) {
+      this.logger.warn('Recovery already in progress');
+      return;
+    }
+
+    // Map code ke DisconnectReason dan trigger multi-branch recovery
+    const disconnectReason: DisconnectReason = mapCodeToReason(code, reason);
+    this.logger.info(`Disconnect detected: ${disconnectReason} (code=${code}, reason=${reason})`);
+
+    // Trigger async recovery (non-blocking)
+    this.recoveryManager.recover(disconnectReason, code, reason).catch(err => {
+      this.logger.error(`Recovery manager error: ${err.message}`);
+    });
+  }
+
+  // ============== Auth ==============
+
+  /**
+   * Start QR-based authentication
+   */
+  private async startQRAuth(): Promise<void> {
+    const qrData = generateQRCodeData({
+      creds: this.authState.creds,
+      logger: this.logger,
+      printInTerminal: this.config.printQRInTerminal
+    });
+
+    this.ev.emit('qr.update', qrData);
+    this.ev.emit('connection.update', {
+      connection: 'connecting',
+      qr: qrData.qrString
+    });
+
+    // Setup refresh manager
+    this.qrRefreshManager = new QRRefreshManager(
+      (qr) => {
+        const newQr = generateQRCodeData({
+          creds: this.authState.creds,
+          logger: this.logger,
+          printInTerminal: this.config.printQRInTerminal
+        });
+        this.ev.emit('qr.update', newQr);
+        this.ev.emit('connection.update', {
+          connection: 'connecting',
+          qr: newQr.qrString
+        });
+      },
+      () => {
+        this.logger.warn('QR code timed out');
+        this.ev.emit('connection.update', {
+          connection: 'close',
+          lastDisconnect: {
+            error: new Error('QR timeout'),
+            output: { code: 0, reason: 'QR timeout' }
+          }
+        });
+      }
+    );
+    this.qrRefreshManager.start(qrData);
+  }
+
+  /**
+   * Send login message untuk existing session
+   */
+  private async sendLogin(): Promise<void> {
+    // Build login node dengan stored credentials
+    const loginNode: BinaryNode = {
+      tag: 'iq',
+      attrs: {
+        type: 'set',
+        to: 's.whatsapp.net',
+        id: `login-${Date.now()}`
+      },
+      content: [
+        {
+          tag: 'login',
+          attrs: {
+            user: this.authState.creds.me?.toString() ?? '',
+            serverToken: this.authState.creds.serverToken ?? '',
+            clientToken: this.authState.creds.clientToken ?? ''
+          }
+        }
+      ]
+    };
+    this.send(encodeBinaryNode(loginNode));
+  }
+
+  // ============== Internal Send ==============
+
+  private async send(data: Uint8Array): Promise<void> {
+    if (!this.ws || !this.ws.isConnected()) {
+      throw new Error('Cannot send: WebSocket not connected');
+    }
+    await this.rateLimiter.acquire();
+    this.ws.send(data);
+  }
+
+  // ============== Public API Methods ==============
+
+  async logout(): Promise<void> {
+    if (this.authState instanceof FileAuthState) {
+      await this.authState.clear();
+    }
+    await this.end(true);
+  }
+
+  async refreshQR(): Promise<QRGenerationData> {
+    const qrData = generateQRCodeData({
+      creds: this.authState.creds,
+      logger: this.logger,
+      printInTerminal: this.config.printQRInTerminal
+    });
+    this.ev.emit('qr.update', qrData);
+    return qrData;
+  }
+
+  async requestPairingCode(phoneNumber: string): Promise<PairingCodeResult> {
+    const cleanPhone = normalizePhoneNumber(phoneNumber);
+    const result = generatePairingCode(cleanPhone, this.authState.creds, this.logger);
+    this.ev.emit('pairing-code.update', result);
+    return result;
+  }
+
+  async sendMessage(jid: JIDLike, content: MessageContent, opts: any = {}): Promise<SendMessageResult> {
+    const recipientJid = jidToString(jid);
+
+    // Circuit breaker check (Features: circuit breaker)
+    if (!this.circuitBreaker.canSend(recipientJid)) {
+      const state = this.circuitBreaker.getState(recipientJid);
+      throw new Error(`Circuit breaker is ${state} for ${recipientJid} - too many failures`);
+    }
+
+    // Rate limit check (Features: rate limit tracker)
+    if (!this.rateLimitTracker.canSend(recipientJid)) {
+      const quota = this.rateLimitTracker.getRemainingQuota(recipientJid);
+      throw new Error(`Rate limit exceeded for ${recipientJid} (remaining: sec=${quota.second}, min=${quota.minute}, hr=${quota.hour})`);
+    }
+
+    // Persist message untuk survive restart (Features: message persistence)
+    const messageId = opts.messageId ?? `msg-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    this.messagePersistence.save({
+      id: messageId,
+      recipientJid,
+      content,
+      status: 'pending',
+      attempts: 0,
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    });
+
+    // Use message queue untuk serialize sends per recipient (Baileys fix #8: race condition)
+    const startTime = Date.now();
+    try {
+      const result = await this.messageQueue.enqueue(recipientJid, () =>
+        this.messageSender.sendMessage(jid, content, { ...opts, messageId })
+      );
+
+      // Update persistence
+      this.messagePersistence.update(messageId, {
+        status: 'sent',
+        attempts: 1
+      });
+
+      // Record success
+      this.circuitBreaker.recordSuccess(recipientJid);
+      this.healthMonitor.recordSend(Date.now() - startTime, true);
+
+      // Trigger webhook
+      this.webhookManager.trigger('message.sent', { jid: recipientJid, messageId });
+
+      return result;
+    } catch (err: any) {
+      this.messagePersistence.update(messageId, {
+        status: 'failed',
+        lastError: err.message,
+        attempts: 1
+      });
+      this.circuitBreaker.recordFailure(recipientJid);
+      this.healthMonitor.recordSend(0, false);
+
+      // Trigger webhook untuk failure
+      this.webhookManager.trigger('message.failed', { jid: recipientJid, messageId, error: err.message });
+
+      throw err;
+    }
+  }
+
+  async forwardMessage(to: JIDLike, message: WAMessage): Promise<SendMessageResult> {
+    return this.messageSender.forwardMessage(to, message);
+  }
+
+  async deleteMessage(jid: JIDLike, key: WAMessageKey, opts: { revokeEveryone?: boolean } = {}): Promise<SendMessageResult> {
+    return this.messageSender.deleteMessage(jid, key, opts);
+  }
+
+  async reactToMessage(jid: JIDLike, key: WAMessageKey, emoji: string): Promise<SendMessageResult> {
+    return this.messageSender.reactToMessage(jid, key, emoji);
+  }
+
+  async sendReadReceipt(jid: JIDLike, messageIds: string[], participant?: JIDLike): Promise<void> {
+    const node = buildReadReceiptNode(jid, messageIds, participant);
+    await this.send(encodeBinaryNode(node));
+  }
+
+  async sendPresenceUpdate(jid: JIDLike, presence: PresenceType): Promise<void> {
+    const node = buildChatPresenceNode(jid, presence as any);
+    await this.send(encodeBinaryNode(node));
+  }
+
+  async updatePresence(presence: 'available' | 'unavailable'): Promise<void> {
+    const node: BinaryNode = {
+      tag: 'presence',
+      attrs: { type: presence }
+    };
+    await this.send(encodeBinaryNode(node));
+  }
+
+  async uploadMedia(media: Buffer | Uint8Array, mediaType: string, mimetype: string, fileName?: string): Promise<any> {
+    return this.mediaUploader.upload(media, mediaType, mimetype, fileName);
+  }
+
+  async downloadMedia(url: string, mediaKey: Uint8Array, mediaType: string, mimetype: string, fileName?: string): Promise<any> {
+    return this.mediaDownloader.download(url, mediaKey, mediaType, mimetype, fileName);
+  }
+
+  // ============== Group Methods ==============
+
+  async groupCreate(opts: GroupCreateOptions): Promise<WAGroupMetadata> {
+    if (!this.groupManager) throw new Error('Group manager not initialized');
+    return this.groupManager.createGroup(opts);
+  }
+
+  async groupMetadata(jid: JIDLike): Promise<WAGroupMetadata> {
+    if (!this.groupManager) throw new Error('Group manager not initialized');
+    return this.groupManager.getGroupMetadata(jid);
+  }
+
+  async groupUpdateSubject(jid: JIDLike, subject: string): Promise<void> {
+    if (!this.groupManager) throw new Error('Group manager not initialized');
+    return this.groupManager.updateGroupSubject(jid, subject);
+  }
+
+  async groupUpdateDescription(jid: JIDLike, desc: string): Promise<void> {
+    if (!this.groupManager) throw new Error('Group manager not initialized');
+    return this.groupManager.updateGroupDescription(jid, desc);
+  }
+
+  async groupParticipantsUpdate(
+    jid: JIDLike,
+    participants: JIDLike[],
+    action: 'add' | 'remove' | 'promote' | 'demote'
+  ): Promise<void> {
+    if (!this.groupManager) throw new Error('Group manager not initialized');
+    switch (action) {
+      case 'add':
+        return this.groupManager.addParticipants(jid, participants);
+      case 'remove':
+        return this.groupManager.removeParticipants(jid, participants);
+      case 'promote':
+        return this.groupManager.promoteParticipants(jid, participants);
+      case 'demote':
+        return this.groupManager.demoteParticipants(jid, participants);
+    }
+  }
+
+  async groupLeave(jid: JIDLike): Promise<void> {
+    if (!this.groupManager) throw new Error('Group manager not initialized');
+    return this.groupManager.leaveGroup(jid);
+  }
+
+  async groupInviteCode(jid: JIDLike): Promise<string> {
+    if (!this.groupManager) throw new Error('Group manager not initialized');
+    return this.groupManager.getInviteCode(jid);
+  }
+
+  async groupRevokeInvite(jid: JIDLike): Promise<string> {
+    if (!this.groupManager) throw new Error('Group manager not initialized');
+    return this.groupManager.revokeInviteCode(jid);
+  }
+
+  async groupJoinViaCode(code: string): Promise<JIDLike> {
+    if (!this.groupManager) throw new Error('Group manager not initialized');
+    return this.groupManager.joinGroupViaCode(code);
+  }
+
+  async groupSettingUpdate(jid: JIDLike, setting: 'restrict' | 'announce', value: boolean): Promise<void> {
+    if (!this.groupManager) throw new Error('Group manager not initialized');
+    if (setting === 'restrict') {
+      return this.groupManager.setGroupRestrict(jid, value);
+    } else {
+      return this.groupManager.setGroupAnnounce(jid, value);
+    }
+  }
+
+  // ============== Call Methods ==============
+
+  async rejectCall(callId: string, from: JIDLike): Promise<void> {
+    if (!this.callHandler) throw new Error('Call handler not initialized');
+    return this.callHandler.rejectCall(callId, from);
+  }
+
+  // ============== Chat Methods ==============
+
+  async chatModify(modification: any, jid: JIDLike): Promise<void> {
+    const node: BinaryNode = {
+      tag: 'iq',
+      attrs: {
+        type: 'set',
+        to: jidToString(jid),
+        id: `chatmod-${Date.now()}`
+      },
+      content: [modification]
+    };
+    await this.send(encodeBinaryNode(node));
+  }
+
+  async readChat(jid: JIDLike): Promise<void> {
+    const node: BinaryNode = {
+      tag: 'iq',
+      attrs: {
+        type: 'set',
+        to: jidToString(jid),
+        id: `readchat-${Date.now()}`
+      },
+      content: [{
+        tag: 'markChatAsRead',
+        attrs: {}
+      }]
+    };
+    await this.send(encodeBinaryNode(node));
+  }
+
+  async archiveChat(jid: JIDLike, archive: boolean): Promise<void> {
+    const action = archive ? 'archive' : 'unarchive';
+    const node: BinaryNode = {
+      tag: 'iq',
+      attrs: {
+        type: 'set',
+        to: jidToString(jid),
+        id: `archive-${Date.now()}`
+      },
+      content: [{
+        tag: 'chat',
+        attrs: { action }
+      }]
+    };
+    await this.send(encodeBinaryNode(node));
+  }
+
+  async muteChat(jid: JIDLike, durationMs: number): Promise<void> {
+    const node: BinaryNode = {
+      tag: 'iq',
+      attrs: {
+        type: 'set',
+        to: jidToString(jid),
+        id: `mute-${Date.now()}`
+      },
+      content: [{
+        tag: 'mute',
+        attrs: {
+          action: 'mute',
+          muteDuration: Math.floor(durationMs / 1000).toString()
+        }
+      }]
+    };
+    await this.send(encodeBinaryNode(node));
+  }
+
+  async pinChat(jid: JIDLike, durationMs: number): Promise<void> {
+    const node: BinaryNode = {
+      tag: 'iq',
+      attrs: {
+        type: 'set',
+        to: jidToString(jid),
+        id: `pin-${Date.now()}`
+      },
+      content: [{
+        tag: 'pin',
+        attrs: {
+          type: 'pinV2',
+          pinDuration: Math.floor(durationMs / 1000).toString()
+        }
+      }]
+    };
+    await this.send(encodeBinaryNode(node));
+  }
+
+  async deleteChat(jid: JIDLike): Promise<void> {
+    const node: BinaryNode = {
+      tag: 'iq',
+      attrs: {
+        type: 'set',
+        to: jidToString(jid),
+        id: `delchat-${Date.now()}`
+      },
+      content: [{
+        tag: 'chat',
+        attrs: { action: 'clear' }
+      }]
+    };
+    await this.send(encodeBinaryNode(node));
+  }
+
+  async presenceSubscribe(jids: JIDLike[]): Promise<void> {
+    const node: BinaryNode = {
+      tag: 'iq',
+      attrs: {
+        type: 'set',
+        to: 's.whatsapp.net',
+        id: `presence-sub-${Date.now()}`
+      },
+      content: jids.map(j => ({
+        tag: 'user',
+        attrs: { jid: jidToString(j) }
+      }))
+    };
+    await this.send(encodeBinaryNode(node));
+  }
+
+  // ============== Connection Management ==============
+
+  async end(newConnection: boolean = false): Promise<void> {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.qrRefreshManager) {
+      this.qrRefreshManager.stop();
+      this.qrRefreshManager = null;
+    }
+    // Cancel ongoing recovery
+    this.recoveryManager?.cancel();
+    // Cleanup fixes
+    this.heartbeat?.stop();
+    this.heartbeat = null;
+    this.idempotencyCache.destroy();
+    this.groupEventCoalescer?.destroy();
+    this.groupEventCoalescer = null;
+    this.decryptionRetryQueue?.destroy();
+    this.decryptionRetryQueue = null;
+    this.messageQueue.clearAll();
+
+    // Cleanup features
+    this.healthMonitor.stop();
+    this.webhookManager.destroy();
+
+    // Cleanup SKDM
+    await this.skdm?.destroy();
+
+    this.pendingTracker.rejectAll(new Error('Connection ended'));
+    this.rateLimiter.destroy();
+    if (this.ws) {
+      this.ws.close(1000, 'normal');
+      this.ws = null;
+    }
+    this.connectionState = 'close';
+    this.ev.emit('connection.update', { connection: 'close' });
+  }
+
+  // ============== Public Accessors untuk SKDM & Features ==============
+
+  /**
+   * Get SKDM (Store Key Data Manager) instance
+   */
+  getSKDM(): SKDM | null {
+    return this.skdm;
+  }
+
+  /**
+   * Get health status
+   */
+  getHealth() {
+    return this.healthMonitor.getHealth();
+  }
+
+  /**
+   * Get SKDM stats (pre-keys, sessions, identities)
+   */
+  getSKDMStats() {
+    return this.skdm?.getStats();
+  }
+
+  /**
+   * Get system stats (queue size, circuit breakers, rate limits)
+   */
+  getSystemStats() {
+    return {
+      messageQueue: this.messageQueue.getStats(),
+      circuitBreakers: this.circuitBreaker.getOpenCircuits(),
+      rateLimits: this.rateLimitTracker.getStats(),
+      webhooks: this.webhookManager.getStats(),
+      messagePersistence: {
+        total: this.messagePersistence.size(),
+        pending: this.messagePersistence.getPending().length,
+        failed: this.messagePersistence.getFailed().length
+      },
+      idempotency: this.idempotencyCache.getStats(),
+      historySync: this.historySyncManager.getStats(),
+      health: this.healthMonitor.getHealth(),
+      recovery: this.recoveryManager.getStats()
+    };
+  }
+
+  /**
+   * Get recovery stats - shows recovery success/failure rate per disconnect reason
+   */
+  getRecoveryStats() {
+    return this.recoveryManager.getStats();
+  }
+
+  /**
+   * Get current recovery context (jika lagi recovering)
+   */
+  getCurrentRecovery() {
+    return this.recoveryManager.getCurrentContext();
+  }
+
+  /**
+   * Check apakah lagi dalam proses recovery
+   */
+  isRecovering(): boolean {
+    return this.recoveryManager.isCurrentlyRecovering();
+  }
+
+  /**
+   * Manually trigger recovery untuk a reason (untuk testing)
+   */
+  async triggerRecovery(reason: DisconnectReason, code?: number, message?: string): Promise<boolean> {
+    return this.recoveryManager.recover(reason, code, message);
+  }
+
+  /**
+   * Register webhook
+   */
+  registerWebhook(config: import('../features/index.js').WebhookConfig): void {
+    this.webhookManager.register(config);
+  }
+
+  /**
+   * Retry failed messages dari persistence
+   */
+  async retryFailedMessages(): Promise<void> {
+    const failed = this.messagePersistence.getFailed();
+    this.logger.info(`Retrying ${failed.length} failed messages`);
+    for (const msg of failed) {
+      this.messagePersistence.update(msg.id, { status: 'pending' });
+      try {
+        await this.sendMessage(msg.recipientJid, msg.content);
+      } catch (err: any) {
+        this.logger.error(`Retry failed for ${msg.id}: ${err.message}`);
+      }
+    }
+  }
+
+  /**
+   * Reset circuit breaker untuk a recipient
+   */
+  resetCircuitBreaker(recipientJid: string): void {
+    this.circuitBreaker.reset(recipientJid);
+  }
+
+  getConnectionState(): 'close' | 'open' | 'connecting' {
+    return this.connectionState;
+  }
+}
+
+// ============== Factory Function ==============
+
+/**
+ * Create WhatsApp socket - main entry point
+ * Mirip Baileys' makeWASocket()
+ *
+ * @example
+ * ```ts
+ * import { makeWASocket, useFileAuthState } from 'waliwa';
+ *
+ * const { state } = await useFileAuthState('./auth');
+ * const sock = makeWASocket({ authState: state, printQRInTerminal: true });
+ * await sock.connect();
+ *
+ * sock.ev.on('message.upsert', async ({ messages }) => {
+ *   for (const msg of messages) {
+ *     console.log('Got message:', msg);
+ *   }
+ * });
+ * ```
+ */
+export function makeWASocket(config: WaliwaConfig): WASocket {
+  if (!config.authState) {
+    throw new Error('authState is required in config');
+  }
+  const socket = new WASocketImpl(config, config.authState);
+  // Auto-connect
+  socket.connect().catch(err => {
+    config.logger?.error?.(`Initial connect failed: ${err.message}`);
+  });
+  return socket as unknown as WASocket;
+}