jagproject 26.3.22 → 26.3.25

package/lib/Utils/message-retry-manager.d.ts

@@ -0,0 +1,110 @@
+import type { proto } from '../../WAProto/index.js';
+import type { ILogger } from './logger.js';
+export interface RecentMessageKey {
+    to: string;
+    id: string;
+}
+export interface RecentMessage {
+    message: proto.IMessage;
+    timestamp: number;
+}
+export interface SessionRecreateHistory {
+    [jid: string]: number;
+}
+export interface RetryCounter {
+    [messageId: string]: number;
+}
+export type PendingPhoneRequest = Record<string, ReturnType<typeof setTimeout>>;
+export interface RetryStatistics {
+    totalRetries: number;
+    successfulRetries: number;
+    failedRetries: number;
+    mediaRetries: number;
+    sessionRecreations: number;
+    phoneRequests: number;
+}
+export declare enum RetryReason {
+    UnknownError = 0,
+    SignalErrorNoSession = 1,
+    SignalErrorInvalidKey = 2,
+    SignalErrorInvalidKeyId = 3,
+    /** MAC verification failed - most common cause of decryption failures */
+    SignalErrorInvalidMessage = 4,
+    SignalErrorInvalidSignature = 5,
+    SignalErrorFutureMessage = 6,
+    /** Explicit MAC failure - session is definitely out of sync */
+    SignalErrorBadMac = 7,
+    SignalErrorInvalidSession = 8,
+    SignalErrorInvalidMsgKey = 9,
+    BadBroadcastEphemeralSetting = 10,
+    UnknownCompanionNoPrekey = 11,
+    AdvFailure = 12,
+    StatusRevokeDelay = 13
+}
+export declare class MessageRetryManager {
+    private logger;
+    private recentMessagesMap;
+    private messageKeyIndex;
+    private sessionRecreateHistory;
+    private retryCounters;
+    private pendingPhoneRequests;
+    private readonly maxMsgRetryCount;
+    private statistics;
+    constructor(logger: ILogger, maxMsgRetryCount: number);
+    /**
+     * Add a recent message to the cache for retry handling
+     */
+    addRecentMessage(to: string, id: string, message: proto.IMessage): void;
+    /**
+     * Get a recent message from the cache
+     */
+    getRecentMessage(to: string, id: string): RecentMessage | undefined;
+    /**
+     * Check if a session should be recreated based on retry count, history, and error code.
+     * MAC errors (codes 4 and 7) trigger immediate session recreation regardless of timeout.
+     */
+    shouldRecreateSession(jid: string, hasSession: boolean, errorCode?: RetryReason): {
+        reason: string;
+        recreate: boolean;
+    };
+    /**
+     * Parse error code from retry receipt's retry node.
+     * Returns undefined if no error code is present.
+     */
+    parseRetryErrorCode(errorAttr: string | undefined): RetryReason | undefined;
+    /**
+     * Check if an error code indicates a MAC failure
+     */
+    isMacError(errorCode: RetryReason | undefined): boolean;
+    /**
+     * Increment retry counter for a message
+     */
+    incrementRetryCount(messageId: string): number;
+    /**
+     * Get retry count for a message
+     */
+    getRetryCount(messageId: string): number;
+    /**
+     * Check if message has exceeded maximum retry attempts
+     */
+    hasExceededMaxRetries(messageId: string): boolean;
+    /**
+     * Mark retry as successful
+     */
+    markRetrySuccess(messageId: string): void;
+    /**
+     * Mark retry as failed
+     */
+    markRetryFailed(messageId: string): void;
+    /**
+     * Schedule a phone request with delay
+     */
+    schedulePhoneRequest(messageId: string, callback: () => void, delay?: number): void;
+    /**
+     * Cancel pending phone request
+     */
+    cancelPendingPhoneRequest(messageId: string): void;
+    private keyToString;
+    private removeRecentMessage;
+}
+//# sourceMappingURL=message-retry-manager.d.ts.map

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

@@ -1,32 +1,60 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessageRetryManager = void 0;
-
+exports.MessageRetryManager = exports.RetryReason = void 0;
 const lru_cache_1 = require("lru-cache");
-
+/** Number of sent messages to cache in memory for handling retry receipts */
 const RECENT_MESSAGES_SIZE = 512;
-
-const RECREATE_SESSION_TIMEOUT = 60 * 60 * 1000;
-
+const MESSAGE_KEY_SEPARATOR = '\u0000';
+/** Timeout for session recreation - 1 hour */
+const RECREATE_SESSION_TIMEOUT = 60 * 60 * 1000; // 1 hour in milliseconds
 const PHONE_REQUEST_DELAY = 3000;
-
+(function (RetryReason) {
+    RetryReason[RetryReason["UnknownError"] = 0] = "UnknownError";
+    RetryReason[RetryReason["SignalErrorNoSession"] = 1] = "SignalErrorNoSession";
+    RetryReason[RetryReason["SignalErrorInvalidKey"] = 2] = "SignalErrorInvalidKey";
+    RetryReason[RetryReason["SignalErrorInvalidKeyId"] = 3] = "SignalErrorInvalidKeyId";
+    /** MAC verification failed - most common cause of decryption failures */
+    RetryReason[RetryReason["SignalErrorInvalidMessage"] = 4] = "SignalErrorInvalidMessage";
+    RetryReason[RetryReason["SignalErrorInvalidSignature"] = 5] = "SignalErrorInvalidSignature";
+    RetryReason[RetryReason["SignalErrorFutureMessage"] = 6] = "SignalErrorFutureMessage";
+    /** Explicit MAC failure - session is definitely out of sync */
+    RetryReason[RetryReason["SignalErrorBadMac"] = 7] = "SignalErrorBadMac";
+    RetryReason[RetryReason["SignalErrorInvalidSession"] = 8] = "SignalErrorInvalidSession";
+    RetryReason[RetryReason["SignalErrorInvalidMsgKey"] = 9] = "SignalErrorInvalidMsgKey";
+    RetryReason[RetryReason["BadBroadcastEphemeralSetting"] = 10] = "BadBroadcastEphemeralSetting";
+    RetryReason[RetryReason["UnknownCompanionNoPrekey"] = 11] = "UnknownCompanionNoPrekey";
+    RetryReason[RetryReason["AdvFailure"] = 12] = "AdvFailure";
+    RetryReason[RetryReason["StatusRevokeDelay"] = 13] = "StatusRevokeDelay";
+})(exports.RetryReason || (exports.RetryReason = {}));
+/** Error codes that indicate a MAC failure and require immediate session recreation */
+const MAC_ERROR_CODES = new Set([exports.RetryReason.SignalErrorInvalidMessage, exports.RetryReason.SignalErrorBadMac]);
 class MessageRetryManager {
     constructor(logger, maxMsgRetryCount) {
         this.logger = logger;
-        this.maxMsgRetryCount = maxMsgRetryCount;
-        this._recentMessagesMap = new lru_cache_1.LRUCache({
-            max: RECENT_MESSAGES_SIZE
+        this.recentMessagesMap = new lru_cache_1.LRUCache({
+            max: RECENT_MESSAGES_SIZE,
+            ttl: 5 * 60 * 1000,
+            ttlAutopurge: true,
+            dispose: (_value, key) => {
+                const separatorIndex = key.lastIndexOf(MESSAGE_KEY_SEPARATOR);
+                if (separatorIndex > -1) {
+                    const messageId = key.slice(separatorIndex + MESSAGE_KEY_SEPARATOR.length);
+                    this.messageKeyIndex.delete(messageId);
+                }
+            }
         });
-        this._sessionRecreateHistory = new lru_cache_1.LRUCache({
+        this.messageKeyIndex = new Map();
+        this.sessionRecreateHistory = new lru_cache_1.LRUCache({
             ttl: RECREATE_SESSION_TIMEOUT * 2,
             ttlAutopurge: true
         });
-        this._retryCounters = new lru_cache_1.LRUCache({
+        this.retryCounters = new lru_cache_1.LRUCache({
             ttl: 15 * 60 * 1000,
             ttlAutopurge: true,
             updateAgeOnGet: true
-        });
-        this._pendingPhoneRequests = {};
+        }); // 15 minutes TTL
+        this.pendingPhoneRequests = {};
+        this.maxMsgRetryCount = 5;
         this.statistics = {
             totalRetries: 0,
             successfulRetries: 0,
@@ -37,36 +65,57 @@ class MessageRetryManager {
         };
         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);
-        this._recentMessagesMap.set(keyStr, {
+        const keyStr = this.keyToString(key);
+        // Add new message
+        this.recentMessagesMap.set(keyStr, {
             message,
             timestamp: Date.now()
         });
+        this.messageKeyIndex.set(id, keyStr);
         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);
+        const keyStr = this.keyToString(key);
+        return this.recentMessagesMap.get(keyStr);
     }
-    shouldRecreateSession(jid, retryCount, hasSession) {
+    /**
+     * Check if a session should be recreated based on retry count, history, and error code.
+     * MAC errors (codes 4 and 7) trigger immediate session recreation regardless of timeout.
+     */
+    shouldRecreateSession(jid, hasSession, errorCode) {
+        // If we don't have a session, always recreate
         if (!hasSession) {
-            this._sessionRecreateHistory.set(jid, Date.now());
+            this.sessionRecreateHistory.set(jid, Date.now());
             this.statistics.sessionRecreations++;
             return {
                 reason: "we don't have a Signal session with them",
                 recreate: true
             };
         }
-        if (retryCount < 2) {
-            return { reason: '', recreate: false };
+        // IMMEDIATE recreation for MAC errors - session is definitely out of sync
+        if (errorCode !== undefined && MAC_ERROR_CODES.has(errorCode)) {
+            this.sessionRecreateHistory.set(jid, Date.now());
+            this.statistics.sessionRecreations++;
+            this.logger.warn({ jid, errorCode: exports.RetryReason[errorCode] }, 'MAC error detected, forcing immediate session recreation');
+            return {
+                reason: `MAC error (code ${errorCode}: ${exports.RetryReason[errorCode]}), immediate session recreation`,
+                recreate: true
+            };
         }
         const now = Date.now();
-        const prevTime = this._sessionRecreateHistory.get(jid);
+        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.sessionRecreateHistory.set(jid, now);
             this.statistics.sessionRecreations++;
             return {
                 reason: 'retry count > 1 and over an hour since last recreation',
@@ -75,54 +124,103 @@ class MessageRetryManager {
         }
         return { reason: '', recreate: false };
     }
+    /**
+     * Parse error code from retry receipt's retry node.
+     * Returns undefined if no error code is present.
+     */
+    parseRetryErrorCode(errorAttr) {
+        if (errorAttr === undefined || errorAttr === '') {
+            return undefined;
+        }
+        const code = parseInt(errorAttr, 10);
+        if (Number.isNaN(code)) {
+            return undefined;
+        }
+        // Validate it's a known RetryReason
+        if (code >= exports.RetryReason.UnknownError && code <= exports.RetryReason.StatusRevokeDelay) {
+            return code;
+        }
+        return exports.RetryReason.UnknownError;
+    }
+    /**
+     * Check if an error code indicates a MAC failure
+     */
+    isMacError(errorCode) {
+        return errorCode !== undefined && MAC_ERROR_CODES.has(errorCode);
+    }
+    /**
+     * Increment retry counter for a message
+     */
     incrementRetryCount(messageId) {
-        this._retryCounters.set(messageId, (this._retryCounters.get(messageId) || 0) + 1);
+        this.retryCounters.set(messageId, (this.retryCounters.get(messageId) || 0) + 1);
         this.statistics.totalRetries++;
-        return this._retryCounters.get(messageId);
+        return this.retryCounters.get(messageId);
     }
+    /**
+     * Get retry count for a message
+     */
     getRetryCount(messageId) {
-        return this._retryCounters.get(messageId) || 0;
+        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++;
-        this._retryCounters.delete(messageId);
-        this._cancelPendingPhoneRequest(messageId);
+        // Clean up retry counter for successful message
+        this.retryCounters.delete(messageId);
+        this.cancelPendingPhoneRequest(messageId);
+        this.removeRecentMessage(messageId);
     }
+    /**
+     * Mark retry as failed
+     */
     markRetryFailed(messageId) {
         this.statistics.failedRetries++;
-        this._retryCounters.delete(messageId);
+        this.retryCounters.delete(messageId);
+        this.cancelPendingPhoneRequest(messageId);
+        this.removeRecentMessage(messageId);
     }
+    /**
+     * Schedule a phone request with delay
+     */
     schedulePhoneRequest(messageId, callback, delay = PHONE_REQUEST_DELAY) {
-        this._cancelPendingPhoneRequest(messageId);
-        this._pendingPhoneRequests[messageId] = setTimeout(() => {
-            delete this._pendingPhoneRequests[messageId];
+        // 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];
+        const timeout = this.pendingPhoneRequests[messageId];
         if (timeout) {
             clearTimeout(timeout);
-            delete this._pendingPhoneRequests[messageId];
+            delete this.pendingPhoneRequests[messageId];
             this.logger.debug(`Cancelled pending phone request for message ${messageId}`);
         }
     }
-    _keyToString(key) {
-        return `${key.to}:${key.id}`;
+    keyToString(key) {
+        return `${key.to}${MESSAGE_KEY_SEPARATOR}${key.id}`;
     }
-    _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}`);
+    removeRecentMessage(messageId) {
+        const keyStr = this.messageKeyIndex.get(messageId);
+        if (!keyStr) {
+            return;
         }
+        this.recentMessagesMap.delete(keyStr);
+        this.messageKeyIndex.delete(messageId);
     }
 }
-
-exports.MessageRetryManager = MessageRetryManager;
+exports.MessageRetryManager = MessageRetryManager;

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

@@ -0,0 +1,130 @@
+import { Boom } from '@hapi/boom';
+import type { Agent } from 'https';
+import { Readable, Transform } from 'stream';
+import { URL } from 'url';
+import { proto } from '../../WAProto/index.js';
+import { type MediaType } from '../Defaults/index.js';
+import type { DownloadableMessage, MediaConnInfo, MediaDecryptionKeyInfo, SocketConfig, WAMediaUpload, WAMediaUploadFunction, WAMessageContent, WAMessageKey } from '../Types/index.js';
+import { type BinaryNode } from '../WABinary/index.js';
+import type { ILogger } from './logger.js';
+export declare const hkdfInfoKey: (type: MediaType) => string;
+export declare const getRawMediaUploadData: (media: WAMediaUpload, mediaType: MediaType, logger?: ILogger) => Promise<{
+    filePath: string;
+    fileSha256: NonSharedBuffer;
+    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): Promise<MediaDecryptionKeyInfo>;
+export declare const extractImageThumb: (bufferOrFilePath: Readable | Buffer | string, width?: number) => Promise<{
+    buffer: any;
+    original: {
+        width: any;
+        height: any;
+    };
+}>;
+export declare const encodeBase64EncodedStringForUpload: (b64: string) => string;
+export declare const generateProfilePicture: (mediaUpload: WAMediaUpload, dimensions?: {
+    width: number;
+    height: number;
+}) => Promise<{
+    img: Buffer<ArrayBufferLike>;
+}>;
+/** 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<ArrayBuffer> | undefined>;
+export declare const toReadable: (buffer: Buffer) => Readable;
+export declare const toBuffer: (stream: Readable) => Promise<Buffer<ArrayBuffer>>;
+export declare const getStream: (item: WAMediaUpload, opts?: RequestInit & {
+    maxContentLength?: number;
+}) => 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?: ILogger;
+}): Promise<{
+    thumbnail: string | undefined;
+    originalImageDimensions: {
+        width: number;
+        height: number;
+    } | undefined;
+}>;
+export declare const getHttpStream: (url: string | URL, options?: RequestInit & {
+    isStream?: true;
+}) => Promise<Readable>;
+type EncryptedStreamOptions = {
+    saveOriginalFileIfRequired?: boolean;
+    logger?: ILogger;
+    opts?: RequestInit;
+};
+export declare const encryptedStream: (media: WAMediaUpload, mediaType: MediaType, { logger, saveOriginalFileIfRequired, opts }?: EncryptedStreamOptions) => Promise<{
+    mediaKey: NonSharedBuffer;
+    originalFilePath: string | undefined;
+    encFilePath: string;
+    mac: Buffer<ArrayBuffer>;
+    fileEncSha256: NonSharedBuffer;
+    fileSha256: NonSharedBuffer;
+    fileLength: number;
+}>;
+export type MediaDownloadOptions = {
+    startByte?: number;
+    endByte?: number;
+    options?: RequestInit;
+};
+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;
+type MediaUploadResult = {
+    url?: string;
+    direct_path?: string;
+    meta_hmac?: string;
+    ts?: number;
+    fbid?: number;
+};
+export type UploadParams = {
+    url: string;
+    filePath: string;
+    headers: Record<string, string>;
+    timeoutMs?: number;
+    agent?: Agent;
+};
+export declare const uploadWithNodeHttp: ({ url, filePath, headers, timeoutMs, agent }: UploadParams, redirectCount?: number) => Promise<MediaUploadResult | undefined>;
+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: WAMessageKey, mediaKey: Buffer | Uint8Array, meId: string) => BinaryNode;
+export declare const decodeMediaRetryNode: (node: BinaryNode) => {
+    key: WAMessageKey;
+    media?: {
+        ciphertext: Uint8Array;
+        iv: Uint8Array;
+    };
+    error?: Boom;
+};
+export declare const decryptMediaRetryData: ({ ciphertext, iv }: {
+    ciphertext: Uint8Array;
+    iv: Uint8Array;
+}, mediaKey: Uint8Array, msgId: string) => proto.MediaRetryNotification;
+export declare const getStatusCodeForMediaRetry: (code: number) => 200 | 412 | 404 | 418;
+export {};
+//# sourceMappingURL=messages-media.d.ts.map