@kangwifi-pro/waliwa 1.0.0

package/src/messages/send.ts

@@ -0,0 +1,521 @@
+/**
+ * Waliwa - Message send/receive operations
+ * High-level API untuk kirim dan terima pesan
+ */
+
+import type {
+  MessageContent,
+  WAMessage,
+  WAMessageKey,
+  JIDLike,
+  SendMessageResult,
+  WALogger,
+  MessageStatus
+} from '../types/index.js';
+import {
+  encodeMessageNode,
+  decodeMessageNode,
+  generateMessageId,
+  generateStanzaId
+} from './message-encoder.js';
+import { encodeBinaryNode, BinaryNode } from '../core/binary.js';
+import { jidToString, isGroupJid } from '../utils/jid.js';
+import { SilentLogger } from '../utils/logger.js';
+
+// ============== Send Message Result Tracking ==============
+
+interface PendingMessage {
+  jid: string;
+  messageId: string;
+  resolve: (result: SendMessageResult) => void;
+  reject: (err: Error) => void;
+  timeout: NodeJS.Timeout;
+}
+
+/**
+ * Track pending message sends untuk kaitin response dengan server ACK
+ */
+export class PendingMessageTracker {
+  private pending: Map<string, PendingMessage> = new Map();
+
+  add(jid: string, messageId: string, resolve: (r: SendMessageResult) => void, reject: (e: Error) => void, timeoutMs: number = 30000): void {
+    const timeout = setTimeout(() => {
+      this.pending.delete(messageId);
+      reject(new Error(`Message send timeout for ${messageId}`));
+    }, timeoutMs);
+
+    this.pending.set(messageId, { jid, messageId, resolve, reject, timeout });
+  }
+
+  resolve(messageId: string, result: SendMessageResult): void {
+    const p = this.pending.get(messageId);
+    if (p) {
+      clearTimeout(p.timeout);
+      this.pending.delete(messageId);
+      p.resolve(result);
+    }
+  }
+
+  reject(messageId: string, err: Error): void {
+    const p = this.pending.get(messageId);
+    if (p) {
+      clearTimeout(p.timeout);
+      this.pending.delete(messageId);
+      p.reject(err);
+    }
+  }
+
+  /** Clear all pending (untuk disconnect) */
+  rejectAll(err: Error): void {
+    for (const [, p] of this.pending) {
+      clearTimeout(p.timeout);
+      p.reject(err);
+    }
+    this.pending.clear();
+  }
+
+  size(): number {
+    return this.pending.size;
+  }
+}
+
+// ============== Message Sender ==============
+
+export interface MessageSenderOptions {
+  /** Function untuk kirim raw bytes via WebSocket */
+  send: (data: Uint8Array) => void;
+  /** Logger */
+  logger?: WALogger;
+  /** Track pending sends */
+  tracker?: PendingMessageTracker;
+}
+
+export class MessageSender {
+  private send: (data: Uint8Array) => void;
+  private logger: WALogger;
+  private tracker: PendingMessageTracker;
+
+  constructor(opts: MessageSenderOptions) {
+    this.send = opts.send;
+    this.logger = opts.logger ?? new SilentLogger();
+    this.tracker = opts.tracker ?? new PendingMessageTracker();
+  }
+
+  /**
+   * Send message ke recipient
+   */
+  async sendMessage(
+    jid: JIDLike,
+    content: MessageContent,
+    options: {
+      messageId?: string;
+      participant?: string;
+      timeoutMs?: number;
+    } = {}
+  ): Promise<SendMessageResult> {
+    const messageId = options.messageId ?? generateMessageId();
+    const jidStr = jidToString(jid);
+
+    this.logger.debug(`Sending message ${messageId} to ${jidStr}`);
+
+    // Build message node
+    const messageNode = encodeMessageNode(jid, content, {
+      messageId,
+      participant: options.participant
+    });
+
+    // Wrap dalam <message> envelope
+    const envelope: BinaryNode = {
+      tag: 'message',
+      attrs: {
+        to: jidStr,
+        type: 'text',
+        id: messageId
+      },
+      content: [messageNode]
+    };
+
+    const binaryData = encodeBinaryNode(envelope);
+
+    // Promise yang resolve ketika server ACK
+    return new Promise<SendMessageResult>((resolve, reject) => {
+      this.tracker.add(jidStr, messageId, resolve, reject, options.timeoutMs);
+
+      try {
+        this.send(binaryData);
+      } catch (err: any) {
+        this.tracker.reject(messageId, err);
+      }
+    });
+  }
+
+  /**
+   * Forward message ke recipient lain
+   */
+  async forwardMessage(
+    to: JIDLike,
+    message: WAMessage,
+    options: { timeoutMs?: number } = {}
+  ): Promise<SendMessageResult> {
+    const messageId = generateMessageId();
+    const jidStr = jidToString(to);
+
+    this.logger.debug(`Forwarding message ${message.key.id} -> ${jidStr}`);
+
+    // Build forward node: <message to=... type=... id=...>
+    // dengan contextInfo.forwardingScore dan original message
+    const forwardNode: BinaryNode = {
+      tag: 'message',
+      attrs: {
+        to: jidStr,
+        type: 'text',
+        id: messageId
+      },
+      content: [
+        message.message?.text ? {
+          tag: 'conversation',
+          attrs: {},
+          content: message.message.text
+        } : null,
+        {
+          tag: 'contextInfo',
+          attrs: {},
+          content: [
+            {
+              tag: 'stanzaId',
+              attrs: {},
+              content: message.key.id
+            },
+            {
+              tag: 'participant',
+              attrs: {},
+              content: jidToString(message.key.participant ?? message.key.remoteJid)
+            },
+            {
+              tag: 'forwardingScore',
+              attrs: {},
+              content: '1'
+            }
+          ]
+        }
+      ].filter(Boolean) as any[]
+    };
+
+    const binaryData = encodeBinaryNode(forwardNode);
+
+    return new Promise<SendMessageResult>((resolve, reject) => {
+      this.tracker.add(jidStr, messageId, resolve, reject, options.timeoutMs);
+      try {
+        this.send(binaryData);
+      } catch (err: any) {
+        this.tracker.reject(messageId, err);
+      }
+    });
+  }
+
+  /**
+   * Delete message (revoke)
+   */
+  async deleteMessage(
+    jid: JIDLike,
+    key: WAMessageKey,
+    options: { revokeEveryone?: boolean; timeoutMs?: number } = {}
+  ): Promise<SendMessageResult> {
+    const messageId = generateMessageId();
+    const jidStr = jidToString(jid);
+
+    const revokeNode: BinaryNode = {
+      tag: 'message',
+      attrs: {
+        to: jidStr,
+        type: 'revoke',
+        id: messageId
+      },
+      content: [
+        {
+          tag: 'revokeMessage',
+          attrs: {
+            id: key.id,
+            fromMe: key.fromMe ? 'true' : 'false',
+            participant: jidToString(key.participant ?? key.remoteJid),
+            type: options.revokeEveryone ? 'everyone' : 'me'
+          }
+        }
+      ]
+    };
+
+    const binaryData = encodeBinaryNode(revokeNode);
+
+    return new Promise<SendMessageResult>((resolve, reject) => {
+      this.tracker.add(jidStr, messageId, resolve, reject, options.timeoutMs);
+      try {
+        this.send(binaryData);
+      } catch (err: any) {
+        this.tracker.reject(messageId, err);
+      }
+    });
+  }
+
+  /**
+   * React ke message dengan emoji
+   */
+  async reactToMessage(
+    jid: JIDLike,
+    key: WAMessageKey,
+    emoji: string,
+    options: { timeoutMs?: number } = {}
+  ): Promise<SendMessageResult> {
+    const messageId = generateMessageId();
+    const jidStr = jidToString(jid);
+
+    const reactionNode: BinaryNode = {
+      tag: 'message',
+      attrs: {
+        to: jidStr,
+        type: 'reaction',
+        id: messageId
+      },
+      content: [
+        {
+          tag: 'reactionMessage',
+          attrs: {
+            key: JSON.stringify({
+              id: key.id,
+              fromMe: key.fromMe,
+              remoteJid: jidToString(key.remoteJid),
+              participant: key.participant ? jidToString(key.participant) : undefined
+            }),
+            text: emoji,
+            timestamp: Math.floor(Date.now() / 1000).toString()
+          }
+        }
+      ]
+    };
+
+    const binaryData = encodeBinaryNode(reactionNode);
+
+    return new Promise<SendMessageResult>((resolve, reject) => {
+      this.tracker.add(jidStr, messageId, resolve, reject, options.timeoutMs);
+      try {
+        this.send(binaryData);
+      } catch (err: any) {
+        this.tracker.reject(messageId, err);
+      }
+    });
+  }
+
+  /**
+   * Update tracker ketika ACK diterima
+   */
+  handleAck(messageId: string, status: MessageStatus, timestamp?: number): void {
+    this.tracker.resolve(messageId, {
+      key: {
+        remoteJid: '',
+        fromMe: true,
+        id: messageId
+      },
+      status,
+      messageTimestamp: timestamp
+    });
+  }
+
+  /**
+   * Reject all pending (untuk disconnect)
+   */
+  destroy(): void {
+    this.tracker.rejectAll(new Error('Connection closed'));
+  }
+}
+
+// ============== Message Receiver ==============
+
+export interface MessageReceiverOptions {
+  logger?: WALogger;
+  /** Handler untuk incoming messages */
+  onMessage?: (messages: WAMessage[], type: 'append' | 'notify') => void;
+  /** Handler untuk status updates */
+  onStatusUpdate?: (key: WAMessageKey, status: MessageStatus) => void;
+}
+
+export class MessageReceiver {
+  private logger: WALogger;
+  private onMessage?: (messages: WAMessage[], type: 'append' | 'notify') => void;
+  private onStatusUpdate?: (key: WAMessageKey, status: MessageStatus) => void;
+
+  constructor(opts: MessageReceiverOptions) {
+    this.logger = opts.logger ?? new SilentLogger();
+    this.onMessage = opts.onMessage;
+    this.onStatusUpdate = opts.onStatusUpdate;
+  }
+
+  /**
+   * Handle incoming binary node (dari WebSocket)
+   */
+  handleNode(node: BinaryNode): void {
+    if (!node) return;
+
+    switch (node.tag) {
+      case 'message':
+        this.handleMessageNode(node);
+        break;
+      case 'receipt':
+        this.handleReceiptNode(node);
+        break;
+      case 'status':
+        this.handleStatusNode(node);
+        break;
+      case 'ack':
+        this.handleAckNode(node);
+        break;
+      default:
+        // Unknown node type
+        this.logger.trace(`Unhandled node: ${node.tag}`);
+    }
+  }
+
+  private handleMessageNode(node: BinaryNode): void {
+    if (!this.onMessage) return;
+
+    const attrs = node.attrs || {};
+    const from = attrs.from ?? '';
+    const fromMe = attrs.fromMe === 'true' || attrs.type === 'send';
+    const id = attrs.id;
+    const type = attrs.type;
+
+    // Convert ke WAMessage
+    const message = decodeMessageNode(node, fromMe);
+    if (!message) return;
+
+    this.logger.debug(`Received message ${id} from ${from} (type: ${type})`);
+
+    this.onMessage([message], type === 'append' ? 'append' : 'notify');
+  }
+
+  private handleReceiptNode(node: BinaryNode): void {
+    const attrs = node.attrs || {};
+    const id = attrs.id;
+    const type = attrs.type;
+    const from = attrs.from;
+
+    if (!this.onStatusUpdate || !id) return;
+
+    const statusMap: Record<string, MessageStatus> = {
+      'read': 'read',
+      'delivered': 'delivered',
+      'played': 'played'
+    };
+
+    const status = statusMap[type];
+    if (status) {
+      this.onStatusUpdate({
+        remoteJid: from,
+        fromMe: true,
+        id
+      }, status);
+    }
+  }
+
+  private handleStatusNode(node: BinaryNode): void {
+    const attrs = node.attrs || {};
+    const id = attrs.id;
+    const type = attrs.type;
+    const from = attrs.from;
+
+    if (!this.onStatusUpdate || !id) return;
+
+    const statusMap: Record<string, MessageStatus> = {
+      'read': 'read',
+      'delivered': 'delivered',
+      'played': 'played'
+    };
+
+    const status = statusMap[type];
+    if (status) {
+      this.onStatusUpdate({
+        remoteJid: from,
+        fromMe: true,
+        id
+      }, status);
+    }
+  }
+
+  private handleAckNode(node: BinaryNode): void {
+    // ACK dari server untuk confirm message received
+    const attrs = node.attrs || {};
+    const id = attrs.id;
+    const type = attrs.type;
+
+    if (!id) return;
+
+    const statusMap: Record<string, MessageStatus> = {
+      'received': 'sent',
+      'read': 'read',
+      'played': 'played'
+    };
+
+    const status = statusMap[type] ?? 'sent';
+    if (this.onStatusUpdate) {
+      this.onStatusUpdate({
+        remoteJid: '',
+        fromMe: true,
+        id
+      }, status);
+    }
+  }
+
+  /**
+   * Set handlers (untuk runtime binding)
+   */
+  setHandlers(opts: MessageReceiverOptions): void {
+    this.onMessage = opts.onMessage;
+    this.onStatusUpdate = opts.onStatusUpdate;
+  }
+}
+
+// ============== Read Receipt Sender ==============
+
+/**
+ * Send read receipts untuk incoming messages
+ */
+export function buildReadReceiptNode(
+  jid: JIDLike,
+  messageIds: string[],
+  participant?: JIDLike
+): BinaryNode {
+  const attrs: any = {
+    to: jidToString(jid),
+    type: 'read',
+    id: messageIds[0]
+  };
+  if (participant) attrs.participant = jidToString(participant);
+
+  return {
+    tag: 'receipt',
+    attrs,
+    content: messageIds.map(id => ({
+      tag: 'receipt',
+      attrs: { id, t: Math.floor(Date.now() / 1000).toString() }
+    }))
+  };
+}
+
+/**
+ * Send typing indicator
+ */
+export function buildChatPresenceNode(
+  jid: JIDLike,
+  type: 'composing' | 'paused' | 'recording',
+  media?: 'audio' | 'video'
+): BinaryNode {
+  return {
+    tag: 'chat',
+    attrs: {
+      to: jidToString(jid),
+      type
+    },
+    content: media ? [{
+      tag: media,
+      attrs: {}
+    }] : undefined
+  };
+}