@violetix/baileys 0.5.5 → 0.6.0

package/lib/Utils/history.js

@@ -1,7 +1,6 @@
 import { pipeline } from 'stream/promises';
 import { promisify } from 'util';
 import { createInflate, inflate } from 'zlib';
-import $protobuf from 'protobufjs/minimal.js';
 import { proto } from '../../WAProto/index.js';
 import { WAMessageStubType } from '../Types/index.js';
 import { isHostedLidUser, isHostedPnUser, isLidUser, isPnUser } from '../WABinary/index.js';
@@ -24,31 +23,7 @@ const extractPnFromMessages = (messages) => {
     }
     return undefined;
 };
-const HISTORY_SYNC_CONVERSATIONS_FIELD = 2;
-const WIRE_TYPE_LENGTH_DELIMITED = 2;
-/**
- * Decodes a HistorySync one conversation at a time. `proto.HistorySync.decode` materializes
- * the whole tree, so for a large chunk every message of every chat is alive at once; walking
- * the top-level fields instead lets each conversation be reduced and dropped before the next
- * one is decoded. Non-conversation fields are copied raw and decoded together at the end.
- */
-export const decodeHistorySyncStreaming = (buffer, onConversation) => {
-    const reader = $protobuf.Reader.create(buffer);
-    const rest = [];
-    while (reader.pos < reader.len) {
-        const start = reader.pos;
-        const tag = reader.uint32();
-        if (tag >>> 3 === HISTORY_SYNC_CONVERSATIONS_FIELD && (tag & 7) === WIRE_TYPE_LENGTH_DELIMITED) {
-            onConversation(proto.Conversation.decode(reader, reader.uint32()));
-        }
-        else {
-            reader.skipType(tag & 7);
-            rest.push(buffer.subarray(start, reader.pos));
-        }
-    }
-    return proto.HistorySync.decode(rest.length === 1 ? rest[0] : Buffer.concat(rest));
-};
-const inflateHistoryStream = async (msg, options) => {
+export const downloadHistory = async (msg, options) => {
     const stream = await downloadContentFromMessage(msg, 'md-msg-hist', { options });
     // Pipe decrypted stream directly through zlib inflate
     // This avoids allocating an intermediate buffer for the compressed data
@@ -56,129 +31,100 @@ const inflateHistoryStream = async (msg, options) => {
     const chunks = [];
     inflater.on('data', (chunk) => chunks.push(chunk));
     await pipeline(stream, inflater);
-    return Buffer.concat(chunks);
-};
-export const downloadHistory = async (msg, options) => {
-    return proto.HistorySync.decode(await inflateHistoryStream(msg, options));
+    const buffer = Buffer.concat(chunks);
+    const syncData = proto.HistorySync.decode(buffer);
+    return syncData;
 };
-const createHistoryAccumulator = (logger) => {
+export const processHistoryMessage = (item, logger) => {
     const messages = [];
     const contacts = [];
     const chats = [];
-    const convLidPnMappings = [];
-    const addConversation = (chat) => {
-        contacts.push({
-            id: chat.id,
-            name: chat.displayName || chat.name || chat.username || undefined,
-            username: chat.username || undefined,
-            lid: chat.lidJid || chat.accountLid || undefined,
-            phoneNumber: chat.pnJid || undefined
-        });
-        const chatId = chat.id;
-        const isLid = isLidUser(chatId) || isHostedLidUser(chatId);
-        const isPn = isPnUser(chatId) || isHostedPnUser(chatId);
-        if (isLid && chat.pnJid) {
-            convLidPnMappings.push({ lid: chatId, pn: chat.pnJid });
-        }
-        else if (isPn && chat.lidJid) {
-            convLidPnMappings.push({ lid: chat.lidJid, pn: chatId });
+    const lidPnMappings = [];
+    logger?.trace({ progress: item.progress }, 'processing history of type ' + item.syncType?.toString());
+    // Extract LID-PN mappings for all sync types
+    for (const m of item.phoneNumberToLidMappings || []) {
+        if (m.lidJid && m.pnJid) {
+            lidPnMappings.push({ lid: m.lidJid, pn: m.pnJid });
         }
-        else if (isLid && !chat.pnJid) {
-            // Fallback: extract PN from userReceipt in messages when pnJid is missing
-            const pnFromReceipt = extractPnFromMessages(chat.messages || []);
-            if (pnFromReceipt) {
-                convLidPnMappings.push({ lid: chatId, pn: pnFromReceipt });
-            }
-        }
-        const msgs = chat.messages || [];
-        delete chat.messages;
-        for (const item of msgs) {
-            const message = item.message;
-            messages.push(message);
-            if (!chat.messages?.length) {
-                // keep only the most recent message in the chat array
-                chat.messages = [{ message }];
-            }
-            if (!message.key.fromMe && !chat.lastMessageRecvTimestamp) {
-                chat.lastMessageRecvTimestamp = toNumber(message.messageTimestamp);
-            }
-            if ((message.messageStubType === WAMessageStubType.BIZ_PRIVACY_MODE_TO_BSP ||
-                message.messageStubType === WAMessageStubType.BIZ_PRIVACY_MODE_TO_FB) &&
-                message.messageStubParameters?.[0]) {
+    }
+    switch (item.syncType) {
+        case proto.HistorySync.HistorySyncType.INITIAL_BOOTSTRAP:
+        case proto.HistorySync.HistorySyncType.RECENT:
+        case proto.HistorySync.HistorySyncType.FULL:
+        case proto.HistorySync.HistorySyncType.ON_DEMAND:
+            for (const chat of item.conversations) {
                 contacts.push({
-                    id: message.participant || message.key.participant || message.key.remoteJid,
-                    verifiedName: message.messageStubParameters?.[0]
+                    id: chat.id,
+                    name: chat.displayName || chat.name || chat.username || undefined,
+                    username: chat.username || undefined,
+                    lid: chat.lidJid || chat.accountLid || undefined,
+                    phoneNumber: chat.pnJid || undefined
                 });
-            }
-        }
-        chats.push(chat);
-    };
-    const finish = (item) => {
-        logger?.trace({ progress: item.progress }, 'processing history of type ' + item.syncType?.toString());
-        // Extract LID-PN mappings for all sync types
-        const lidPnMappings = [];
-        for (const m of item.phoneNumberToLidMappings || []) {
-            if (m.lidJid && m.pnJid) {
-                lidPnMappings.push({ lid: m.lidJid, pn: m.pnJid });
-            }
-        }
-        switch (item.syncType) {
-            case proto.HistorySync.HistorySyncType.INITIAL_BOOTSTRAP:
-            case proto.HistorySync.HistorySyncType.RECENT:
-            case proto.HistorySync.HistorySyncType.FULL:
-            case proto.HistorySync.HistorySyncType.ON_DEMAND:
-                for (const chat of item.conversations || []) {
-                    addConversation(chat);
+                const chatId = chat.id;
+                const isLid = isLidUser(chatId) || isHostedLidUser(chatId);
+                const isPn = isPnUser(chatId) || isHostedPnUser(chatId);
+                if (isLid && chat.pnJid) {
+                    lidPnMappings.push({ lid: chatId, pn: chat.pnJid });
                 }
-                break;
-            case proto.HistorySync.HistorySyncType.PUSH_NAME:
-                for (const c of item.pushnames || []) {
-                    contacts.push({ id: c.id, notify: c.pushname });
+                else if (isPn && chat.lidJid) {
+                    lidPnMappings.push({ lid: chat.lidJid, pn: chatId });
                 }
-                break;
-        }
-        return {
-            chats,
-            contacts,
-            messages,
-            lidPnMappings: [...lidPnMappings, ...convLidPnMappings],
-            pastParticipants: item.pastParticipants,
-            syncType: item.syncType,
-            progress: item.progress
-        };
-    };
-    return { addConversation, finish };
-};
-export const processHistoryMessage = (item, logger) => createHistoryAccumulator(logger).finish(item);
-const HISTORY_SYNC_TYPE_FIELD = 1;
-const CONVERSATION_SYNC_TYPES = new Set([
-    proto.HistorySync.HistorySyncType.INITIAL_BOOTSTRAP,
-    proto.HistorySync.HistorySyncType.RECENT,
-    proto.HistorySync.HistorySyncType.FULL,
-    proto.HistorySync.HistorySyncType.ON_DEMAND
-]);
-/** Reads only the `syncType` varint, skipping every other field without decoding it. */
-const peekHistorySyncType = (buffer) => {
-    const reader = $protobuf.Reader.create(buffer);
-    while (reader.pos < reader.len) {
-        const tag = reader.uint32();
-        if (tag >>> 3 === HISTORY_SYNC_TYPE_FIELD && (tag & 7) === 0) {
-            return reader.int32();
-        }
-        reader.skipType(tag & 7);
+                else if (isLid && !chat.pnJid) {
+                    // Fallback: extract PN from userReceipt in messages when pnJid is missing
+                    const pnFromReceipt = extractPnFromMessages(chat.messages || []);
+                    if (pnFromReceipt) {
+                        lidPnMappings.push({ lid: chatId, pn: pnFromReceipt });
+                    }
+                }
+                const msgs = chat.messages || [];
+                delete chat.messages;
+                for (const item of msgs) {
+                    const message = item.message;
+                    messages.push(message);
+                    if (!chat.messages?.length) {
+                        // keep only the most recent message in the chat array
+                        chat.messages = [{ message }];
+                    }
+                    if (!message.key.fromMe && !chat.lastMessageRecvTimestamp) {
+                        chat.lastMessageRecvTimestamp = toNumber(message.messageTimestamp);
+                    }
+                    if ((message.messageStubType === WAMessageStubType.BIZ_PRIVACY_MODE_TO_BSP ||
+                        message.messageStubType === WAMessageStubType.BIZ_PRIVACY_MODE_TO_FB) &&
+                        message.messageStubParameters?.[0]) {
+                        contacts.push({
+                            id: message.key.participant || message.key.remoteJid,
+                            verifiedName: message.messageStubParameters?.[0]
+                        });
+                    }
+                }
+                chats.push(chat);
+            }
+            break;
+        case proto.HistorySync.HistorySyncType.PUSH_NAME:
+            for (const c of item.pushnames) {
+                contacts.push({ id: c.id, notify: c.pushname });
+            }
+            break;
     }
-    return undefined;
+    return {
+        chats,
+        contacts,
+        messages,
+        lidPnMappings,
+        pastParticipants: item.pastParticipants,
+        syncType: item.syncType,
+        progress: item.progress
+    };
 };
 export const downloadAndProcessHistorySyncNotification = async (msg, options, logger) => {
-    const buffer = msg.initialHistBootstrapInlinePayload
-        ? await inflatePromise(msg.initialHistBootstrapInlinePayload)
-        : await inflateHistoryStream(msg, options);
-    const acc = createHistoryAccumulator(logger);
-    // conversations are reduced as they are decoded, only for the sync types that carry chats
-    // (same gate as processHistoryMessage); `rest` holds every other field
-    const wantsConversations = CONVERSATION_SYNC_TYPES.has(peekHistorySyncType(buffer));
-    const rest = decodeHistorySyncStreaming(buffer, wantsConversations ? acc.addConversation : () => { });
-    return acc.finish(rest);
+    let historyMsg;
+    if (msg.initialHistBootstrapInlinePayload) {
+        historyMsg = proto.HistorySync.decode(await inflatePromise(msg.initialHistBootstrapInlinePayload));
+    }
+    else {
+        historyMsg = await downloadHistory(msg, options);
+    }
+    return processHistoryMessage(historyMsg, logger);
 };
 export const getHistoryMsg = (message) => {
     const normalizedContent = !!message ? normalizeMessageContent(message) : undefined;

package/lib/Utils/index.d.ts

@@ -22,9 +22,5 @@ export * from "./browser-utils.js";
 export * from "./companion-reg-client-utils.js";
 export * from "./identity-change-handler.js";
 export * from "./stanza-ack.js";
-export * from "./ignore-key.js";
-export * from "./anchor-guard.js";
-export * from "./connection-manager.js";
-export * from "./a2ui.js";
 export * from "./meta-ai-msmsg.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/Utils/index.js

@@ -18,13 +18,9 @@ export * from './event-buffer.js';
 export * from './process-message.js';
 export * from './rich-message-utils.js';
 export * from './message-retry-manager.js';
-export * from './connection-manager.js';
 export * from './browser-utils.js';
 export * from './companion-reg-client-utils.js';
 export * from './identity-change-handler.js';
 export * from './stanza-ack.js';
-export * from './ignore-key.js';
-export * from './anchor-guard.js';
-export * from './a2ui.js';
 export * from './meta-ai-msmsg.js';
 //# sourceMappingURL=index.js.map

package/lib/Utils/listener-guard.js

@@ -34,8 +34,6 @@ export const makeListenerGuard = (onError) => {
             if (result && typeof result.catch === 'function') result.catch(onError)
             return result
          }
-         // Preserve the identity EventEmitter uses to remove once wrappers and list callbacks.
-         wrapper.listener = listener.listener || listener
          wrappers.set(listener, wrapper)
          return wrapper
       },

package/lib/Utils/message-retry-manager.js

@@ -1,24 +1,6 @@
 import { LRUCache } from 'lru-cache';
 /** Number of sent messages to cache in memory for handling retry receipts */
 const RECENT_MESSAGES_SIZE = 1024;
-/**
- * Entry caps for the two caches below that only had a `ttl`.
- *
- * lru-cache's own docs: "Even if ttl tracking is enabled, it is strongly recommended to set a `max` to
- * prevent unbounded growth of the cache." `recentMessagesMap` and `baseKeys` were capped at
- * RECENT_MESSAGES_SIZE; `sessionRecreateHistory` and `retryCounters` were not, so their only bound was
- * expiry — and one MessageRetryManager exists PER SOCKET (messages-send.js:87, on by default via
- * `enableRecentMessageCache`). A host running a bot fleet holds one per bot.
- *
- * `retryCounters` is the worse of the two: it is keyed per message and sets `updateAgeOnGet`, so
- * `hasExceededMaxRetries()` — which reads it — refreshes the TTL on every check. A message stuck in a
- * retry loop therefore kept its entry alive indefinitely, which is the opposite of what a TTL backstop
- * is for. The age semantics are left alone (dropping them would hand a long retry a fresh count and
- * extra attempts past maxMsgRetryCount); the cap is what makes the growth bounded either way, and LRU
- * eviction of the oldest counter has the same effect the TTL already intended.
- */
-const SESSION_HISTORY_SIZE = 1024;
-const RETRY_COUNTER_SIZE = 4096;
 const MESSAGE_KEY_SEPARATOR = '\u0000';
 /** Timeout for session recreation - 1 hour */
 const RECREATE_SESSION_TIMEOUT = 60 * 60 * 1000; // 1 hour in milliseconds
@@ -62,12 +44,10 @@ export class MessageRetryManager {
         });
         this.messageKeyIndex = new Map();
         this.sessionRecreateHistory = new LRUCache({
-            max: SESSION_HISTORY_SIZE,
             ttl: RECREATE_SESSION_TIMEOUT * 2,
             ttlAutopurge: true
         });
         this.retryCounters = new LRUCache({
-            max: RETRY_COUNTER_SIZE,
             ttl: 15 * 60 * 1000,
             ttlAutopurge: true,
             updateAgeOnGet: true

package/lib/Utils/messages-media.d.ts

@@ -44,31 +44,8 @@ export function getStream(item: any, opts: any): Promise<{
     stream: any;
     type: string;
 }>;
-export interface MediaFetchOptions {
-    headers?: HeadersInit;
-    signal?: AbortSignal;
-    dispatcher?: unknown;
-    maxContentLength?: number;
-}
-export interface MediaEncryptionOptions {
-    logger?: {
-        debug?: (...args: any[]) => void;
-        error?: (...args: any[]) => void;
-    };
-    saveOriginalFileIfRequired?: boolean;
-    opts?: MediaFetchOptions;
-    /** Reuse an existing 32-byte media key instead of generating one (e.g. sticker-pack thumbnails). */
-    mediaKey?: Uint8Array;
-}
-export interface MediaDownloadOptions {
-    startByte?: number;
-    /** Exclusive end offset. Ranges still download and authenticate the complete media. */
-    endByte?: number;
-    options?: MediaFetchOptions;
-    host?: string;
-}
-export function getHttpStream(url: any, options?: MediaFetchOptions): Promise<any>;
-export function encryptedStream(media: any, mediaType: any, { logger, saveOriginalFileIfRequired, opts }?: MediaEncryptionOptions): Promise<{
+export function getHttpStream(url: any, options?: {}): Promise<any>;
+export function encryptedStream(media: any, mediaType: any, { logger, saveOriginalFileIfRequired, opts }?: {}): Promise<{
     mediaKey: any;
     originalFilePath: any;
     encFilePath: any;
@@ -76,26 +53,18 @@ export function encryptedStream(media: any, mediaType: any, { logger, saveOrigin
     fileEncSha256: any;
     fileSha256: any;
     fileLength: number;
-    streamingSidecar: Buffer | undefined;
 }>;
-export function scanStreamable(head: Uint8Array): boolean | null;
 export const DEF_MEDIA_HOST: "mmg.whatsapp.net";
 export function getUrlFromDirectPath(directPath: any, host?: string): string;
 export function downloadContentFromMessage({ mediaKey, directPath, url }: {
     mediaKey: any;
-    directPath?: string;
-    url?: string;
-}, type: any, opts?: MediaDownloadOptions): Promise<any>;
-/**
- * Verifies the complete media HMAC before returning a temporary-file-backed stream.
- * Byte ranges are sliced after full download/authentication (endByte is exclusive).
- * Consume or destroy the stream to release its temporary file.
- */
-export function downloadEncryptedContent(downloadUrl: any, { cipherKey, iv, macKey }: {
+    directPath: any;
+    url: any;
+}, type: any, opts?: {}): Promise<any>;
+export function downloadEncryptedContent(downloadUrl: any, { cipherKey, iv }: {
     cipherKey: any;
     iv: any;
-    macKey: any;
-}, { startByte, endByte, options }?: MediaDownloadOptions): Promise<any>;
+}, { startByte, endByte, options }?: {}): Promise<any>;
 export function uploadWithNodeHttp({ url, filePath, headers, timeoutMs, agent }: {
     url: any;
     filePath: any;
@@ -165,4 +134,4 @@ export function decryptMediaRetryData({ ciphertext, iv }: {
 }, mediaKey: any, msgId: any): proto.MediaRetryNotification;
 export function getStatusCodeForMediaRetry(code: any): any;
 import { proto } from '../../WAProto/index.js';
-//# sourceMappingURL=messages-media.d.ts.map
+//# sourceMappingURL=messages-media.d.ts.map