@neelegirl/baileys 1.5.2 → 1.5.3

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

@@ -0,0 +1,160 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const LRUCache_1 = require("lru-cache")
+
+/** Number of sent messages to cache in memory for handling retry receipts */
+const RECENT_MESSAGES_SIZE = 512
+
+/** Timeout for session recreation - 1 hour */
+const RECREATE_SESSION_TIMEOUT = 60 * 60 * 1000 // 1 hour in milliseconds
+
+const PHONE_REQUEST_DELAY = 3000
+
+class MessageRetryManager {
+    constructor(logger, maxMsgRetryCount) {
+        this.logger = logger
+        this.recentMessagesMap = new LRUCache_1.LRUCache({
+            max: RECENT_MESSAGES_SIZE
+        })
+        this.sessionRecreateHistory = new LRUCache_1.LRUCache({
+            ttl: RECREATE_SESSION_TIMEOUT * 2,
+            ttlAutopurge: true
+        })
+        this.retryCounters = new LRUCache_1.LRUCache({
+            ttl: 15 * 60 * 1000,
+            ttlAutopurge: true,
+            updateAgeOnGet: true
+        }) // 15 minutes TTL
+        this.pendingPhoneRequests = {}
+        this.maxMsgRetryCount = 5
+        this.statistics = {
+            totalRetries: 0,
+            successfulRetries: 0,
+            failedRetries: 0,
+            mediaRetries: 0,
+            sessionRecreations: 0,
+            phoneRequests: 0
+        }
+        this.maxMsgRetryCount = maxMsgRetryCount
+    }
+    /**
+     * Add a recent message to the cache for retry handling
+     */
+    addRecentMessage(to, id, message) {
+        const key = { to, id }
+        const keyStr = this.keyToString(key)
+        // Add new message
+        this.recentMessagesMap.set(keyStr, {
+            message,
+            timestamp: Date.now()
+        })
+        this.logger.debug(`Added message to retry cache: ${to}/${id}`)
+    }
+    /**
+     * Get a recent message from the cache
+     */
+    getRecentMessage(to, id) {
+        const key = { to, id }
+        const keyStr = this.keyToString(key)
+        return this.recentMessagesMap.get(keyStr)
+    }
+    /**
+     * Check if a session should be recreated based on retry count and history
+     */
+    shouldRecreateSession(jid, retryCount, hasSession) {
+        // If we don't have a session, always recreate
+        if (!hasSession) {
+            this.sessionRecreateHistory.set(jid, Date.now())
+            this.statistics.sessionRecreations++
+            return {
+                reason: "we don't have a Signal session with them",
+                recreate: true
+            }
+        }
+        // Only consider recreation if retry count > 1
+        if (retryCount < 2) {
+            return { reason: '', recreate: false }
+        }
+        const now = Date.now()
+        const prevTime = this.sessionRecreateHistory.get(jid)
+        // If no previous recreation or it's been more than an hour
+        if (!prevTime || now - prevTime > RECREATE_SESSION_TIMEOUT) {
+            this.sessionRecreateHistory.set(jid, now)
+            this.statistics.sessionRecreations++
+            return {
+                reason: 'retry count > 1 and over an hour since last recreation',
+                recreate: true
+            }
+        }
+        return { reason: '', recreate: false }
+    }
+    /**
+     * Increment retry counter for a message
+     */
+    incrementRetryCount(messageId) {
+        this.retryCounters.set(messageId, (this.retryCounters.get(messageId) || 0) + 1)
+        this.statistics.totalRetries++
+        return this.retryCounters.get(messageId)
+    }
+    /**
+     * Get retry count for a message
+     */
+    getRetryCount(messageId) {
+        return this.retryCounters.get(messageId) || 0
+    }
+    /**
+     * Check if message has exceeded maximum retry attempts
+     */
+    hasExceededMaxRetries(messageId) {
+        return this.getRetryCount(messageId) >= this.maxMsgRetryCount
+    }
+    /**
+     * Mark retry as successful
+     */
+    markRetrySuccess(messageId) {
+        this.statistics.successfulRetries++
+        // Clean up retry counter for successful message
+        this.retryCounters.delete(messageId)
+        this.cancelPendingPhoneRequest(messageId)
+    }
+    /**
+     * Mark retry as failed
+     */
+    markRetryFailed(messageId) {
+        this.statistics.failedRetries++
+        this.retryCounters.delete(messageId)
+    }
+    /**
+     * Schedule a phone request with delay
+     */
+    schedulePhoneRequest(messageId, callback, delay = PHONE_REQUEST_DELAY) {
+        // Cancel any existing request for this message
+        this.cancelPendingPhoneRequest(messageId)
+        this.pendingPhoneRequests[messageId] = setTimeout(() => {
+            delete this.pendingPhoneRequests[messageId]
+            this.statistics.phoneRequests++
+            callback()
+        }, delay)
+        this.logger.debug(`Scheduled phone request for message ${messageId} with ${delay}ms delay`)
+    }
+    /**
+     * Cancel pending phone request
+     */
+    cancelPendingPhoneRequest(messageId) {
+        const timeout = this.pendingPhoneRequests[messageId]
+        if (timeout) {
+            clearTimeout(timeout)
+            delete this.pendingPhoneRequests[messageId]
+            this.logger.debug(`Cancelled pending phone request for message ${messageId}`)
+        }
+    }
+    keyToString(key) {
+        return `${key.to}:${key.id}`
+    }
+}
+
+module.exports = {
+  MessageRetryManager
+}

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

@@ -1,129 +1,135 @@
-import { Boom } from '@hapi/boom'
-import { AxiosRequestConfig } from 'axios'
-import { Readable, Transform } from 'stream'
-import { URL } from 'url'
-import { proto } from '../../WAProto'
-import { DownloadableMessage, MediaConnInfo, MediaDecryptionKeyInfo, MediaType, SocketConfig, WAMediaUpload, WAMediaUploadFunction, WAMessageContent } from '../Types'
-import { BinaryNode } from '../WABinary'
-import { ILogger } from './logger'
-
-export declare const hkdfInfoKey: (type: MediaType) => string
-
-/** generates all the keys required to encrypt/decrypt & sign a media message */
-export declare function getMediaKeys(buffer: Uint8Array | string | null | undefined, mediaType: MediaType): MediaDecryptionKeyInfo
-
-export declare const extractImageThumb: (bufferOrFilePath: Readable | Buffer | string, width?: number) => Promise<{
-    buffer: Buffer
-    original: {
-        width: number | undefined
-        height: number | undefined
-    }
-}>
-
-export declare const encodeBase64EncodedStringForUpload: (b64: string) => string
-
-export declare const generateProfilePicture: (mediaUpload: WAMediaUpload) => Promise<{
-    img: Buffer
-}>
-
-/** gets the SHA256 of the given media message */
-export declare const mediaMessageSHA256B64: (message: WAMessageContent) => string | null | undefined
-
-export declare function getAudioDuration(buffer: Buffer | string | Readable): Promise<number | undefined>
-
-/**
-  referenced from and modifying https://github.com/wppconnect-team/wa-js/blob/main/src/chat/functions/prepareAudioWaveform.ts
- */
-export declare function getAudioWaveform(buffer: Buffer | string | Readable, logger?: ILogger): Promise<Uint8Array | undefined>
-
-export declare const toReadable: (buffer: Buffer) => Readable
-
-export declare const toBuffer: (stream: Readable) => Promise<Buffer>
-
-export declare const getStream: (item: WAMediaUpload, opts?: AxiosRequestConfig) => Promise<{
-    readonly stream: Readable
-    readonly type: "buffer"
-} | {
-    readonly stream: Readable
-    readonly type: "readable"
-} | {
-    readonly stream: Readable
-    readonly type: "remote"
-} | {
-    readonly stream: import("fs").ReadStream
-    readonly type: "file"
-}>
-
-/** generates a thumbnail for a given media, if required */
-export declare function generateThumbnail(file: string, mediaType: 'video' | 'image', options: {
-    logger?: Logger
-}): Promise<{
-    thumbnail: string | undefined
-    originalImageDimensions: {
-        width: number
-        height: number
-    } | undefined
-}>
-
-export declare const getHttpStream: (url: string | URL, options?: AxiosRequestConfig & {
-    isStream?: true
-}) => Promise<Readable>
-
-type EncryptedStreamOptions = {
-    saveOriginalFileIfRequired?: boolean
-    logger?: Logger
-    opts?: AxiosRequestConfig
-}
-
-export declare const encryptedStream: (media: WAMediaUpload, mediaType: MediaType, { logger, saveOriginalFileIfRequired, opts }?: EncryptedStreamOptions) => Promise<{
-    mediaKey: Buffer
-    encWriteStream: Readable
-    bodyPath: string | undefined
-    mac: Buffer
-    fileEncSha256: Buffer
-    fileSha256: Buffer
-    fileLength: number
-    didSaveToTmpPath: boolean
-}>
-
-export type MediaDownloadOptions = {
-    startByte?: number
-    endByte?: number
-    options?: AxiosRequestConfig<{}>
-}
-
-export declare const getUrlFromDirectPath: (directPath: string) => string
-
-export declare const downloadContentFromMessage: ({ mediaKey, directPath, url }: DownloadableMessage, type: MediaType, opts?: MediaDownloadOptions) => Promise<Transform>
-
-/**
- * Decrypts and downloads an AES256-CBC encrypted file given the keys.
- * Assumes the SHA256 of the plaintext is appended to the end of the ciphertext
- * */
-export declare const downloadEncryptedContent: (downloadUrl: string, { cipherKey, iv }: MediaDecryptionKeyInfo, { startByte, endByte, options }?: MediaDownloadOptions) => Promise<Transform>
-
-export declare function extensionForMediaMessage(message: WAMessageContent): string
-
-export declare const getWAUploadToServer: ({ customUploadHosts, fetchAgent, logger, options }: SocketConfig, refreshMediaConn: (force: boolean) => Promise<MediaConnInfo>) => WAMediaUploadFunction
-/**
- * Generate a binary node that will request the phone to re-upload the media & return the newly uploaded URL
- */
-export declare const encryptMediaRetryRequest: (key: proto.IMessageKey, mediaKey: Buffer | Uint8Array, meId: string) => BinaryNode
-
-export declare const decodeMediaRetryNode: (node: BinaryNode) => {
-    key: proto.IMessageKey
-    media?: {
-        ciphertext: Uint8Array
-        iv: Uint8Array
-    } | undefined
-    error?: Boom<any> | undefined
-}
-
-export declare const decryptMediaRetryData: ({ ciphertext, iv }: {
-    ciphertext: Uint8Array
-    iv: Uint8Array
-}, mediaKey: Uint8Array, msgId: string) => Promise<proto.MediaRetryNotification>
-
-export declare const getStatusCodeForMediaRetry: (code: number) => any
-
+import { Boom } from '@hapi/boom'
+import { AxiosRequestConfig } from 'axios'
+import { Readable, Transform } from 'stream'
+import { URL } from 'url'
+import { proto } from '@neelegirl/baileys/WAProto'
+import { DownloadableMessage, MediaConnInfo, MediaDecryptionKeyInfo, MediaType, SocketConfig, WAMediaUpload, WAMediaUploadFunction, WAMessageContent } from '@neelegirl/baileys/lib/Types'
+import { BinaryNode } from '@neelegirl/baileys/lib/WABinary'
+import { ILogger } from '@neelegirl/baileys/lib/Utils/logger'
+
+export declare const hkdfInfoKey: (type: MediaType) => string
+
+export declare const getRawMediaUploadData: (media: WAMediaUpload, mediaType: MediaType, logger?: ILogger) => Promise<{
+    filePath: string
+    fileSha256: Buffer<ArrayBufferLike>
+    fileLength: number
+}>
+
+/** generates all the keys required to encrypt/decrypt & sign a media message */
+export declare function getMediaKeys(buffer: Uint8Array | string | null | undefined, mediaType: MediaType): MediaDecryptionKeyInfo
+
+export declare const extractImageThumb: (bufferOrFilePath: Readable | Buffer | string, width?: number) => Promise<{
+    buffer: Buffer
+    original: {
+        width: number | undefined
+        height: number | undefined
+    }
+}>
+
+export declare const encodeBase64EncodedStringForUpload: (b64: string) => string
+
+export declare const generateProfilePicture: (mediaUpload: WAMediaUpload) => Promise<{
+    img: Buffer
+}>
+
+/** gets the SHA256 of the given media message */
+export declare const mediaMessageSHA256B64: (message: WAMessageContent) => string | null | undefined
+
+export declare function getAudioDuration(buffer: Buffer | string | Readable): Promise<number | undefined>
+
+/**
+  referenced from and modifying https://github.com/wppconnect-team/wa-js/blob/main/src/chat/functions/prepareAudioWaveform.ts
+ */
+export declare function getAudioWaveform(buffer: Buffer | string | Readable, logger?: ILogger): Promise<Uint8Array | undefined>
+
+export declare const toReadable: (buffer: Buffer) => Readable
+
+export declare const toBuffer: (stream: Readable) => Promise<Buffer>
+
+export declare const getStream: (item: WAMediaUpload, opts?: AxiosRequestConfig) => Promise<{
+    readonly stream: Readable
+    readonly type: "buffer"
+} | {
+    readonly stream: Readable
+    readonly type: "readable"
+} | {
+    readonly stream: Readable
+    readonly type: "remote"
+} | {
+    readonly stream: import("fs").ReadStream
+    readonly type: "file"
+}>
+
+/** generates a thumbnail for a given media, if required */
+export declare function generateThumbnail(file: string, mediaType: 'video' | 'image', options: {
+    logger?: Logger
+}): Promise<{
+    thumbnail: string | undefined
+    originalImageDimensions: {
+        width: number
+        height: number
+    } | undefined
+}>
+
+export declare const getHttpStream: (url: string | URL, options?: AxiosRequestConfig & {
+    isStream?: true
+}) => Promise<Readable>
+
+type EncryptedStreamOptions = {
+    saveOriginalFileIfRequired?: boolean
+    logger?: Logger
+    opts?: AxiosRequestConfig
+}
+
+export declare const encryptedStream: (media: WAMediaUpload, mediaType: MediaType, { logger, saveOriginalFileIfRequired, opts }?: EncryptedStreamOptions) => Promise<{
+    mediaKey: Buffer
+    encWriteStream: Readable
+    bodyPath: string | undefined
+    mac: Buffer
+    fileEncSha256: Buffer
+    fileSha256: Buffer
+    fileLength: number
+    didSaveToTmpPath: boolean
+}>
+
+export type MediaDownloadOptions = {
+    startByte?: number
+    endByte?: number
+    options?: AxiosRequestConfig<{}>
+}
+
+export declare const getUrlFromDirectPath: (directPath: string) => string
+
+export declare const downloadContentFromMessage: ({ mediaKey, directPath, url }: DownloadableMessage, type: MediaType, opts?: MediaDownloadOptions) => Promise<Transform>
+
+/**
+ * Decrypts and downloads an AES256-CBC encrypted file given the keys.
+ * Assumes the SHA256 of the plaintext is appended to the end of the ciphertext
+ * */
+export declare const downloadEncryptedContent: (downloadUrl: string, { cipherKey, iv }: MediaDecryptionKeyInfo, { startByte, endByte, options }?: MediaDownloadOptions) => Promise<Transform>
+
+export declare function extensionForMediaMessage(message: WAMessageContent): string
+
+export declare const getWAUploadToServer: ({ customUploadHosts, fetchAgent, logger, options }: SocketConfig, refreshMediaConn: (force: boolean) => Promise<MediaConnInfo>) => WAMediaUploadFunction
+/**
+ * Generate a binary node that will request the phone to re-upload the media & return the newly uploaded URL
+ */
+export declare const encryptMediaRetryRequest: (key: proto.IMessageKey, mediaKey: Buffer | Uint8Array, meId: string) => BinaryNode
+
+export declare const decodeMediaRetryNode: (node: BinaryNode) => {
+    key: proto.IMessageKey
+    media?: {
+        ciphertext: Uint8Array
+        iv: Uint8Array
+    } | undefined
+    error?: Boom<any> | undefined
+}
+
+export declare const decryptMediaRetryData: ({ ciphertext, iv }: {
+    ciphertext: Uint8Array
+    iv: Uint8Array
+}, mediaKey: Uint8Array, msgId: string) => Promise<proto.MediaRetryNotification>
+
+export declare const getStatusCodeForMediaRetry: (code: number) => any
+
 export {}