@neelegirl/baileys 1.5.3 → 1.5.5

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

@@ -1,160 +0,0 @@
-"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,135 +0,0 @@
-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 {}