@nerxa/socketon 0.0.0-stage → 1.21.0

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

@@ -0,0 +1,79 @@
+export const RetryReason: any;
+export class MessageRetryManager {
+    constructor(logger: any, maxMsgRetryCount?: number);
+    logger: any;
+    recentMessagesMap: any;
+    messageKeyIndex: Map<string, Set<string>>;
+    sessionRecreateHistory: any;
+    retryCounters: any;
+    baseKeys: any;
+    pendingPhoneRequests: {};
+    maxMsgRetryCount: any;
+    statistics: {
+        totalRetries: number;
+        successfulRetries: number;
+        failedRetries: number;
+        mediaRetries: number;
+        sessionRecreations: number;
+        phoneRequests: number;
+    };
+    /**
+     * Add a recent message to the cache for retry handling
+     */
+    addRecentMessage(to: any, id: any, message: any): void;
+    /**
+     * Get a recent message from the cache
+     */
+    getRecentMessage(to: any, id: any): any;
+    /**
+     * 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: any, hasSession: any, errorCode: any): {
+        reason: string;
+        recreate: boolean;
+    };
+    /**
+     * Parse error code from retry receipt's retry node.
+     * Returns undefined if no error code is present.
+     */
+    parseRetryErrorCode(errorAttr: any): any;
+    /**
+     * Check if an error code indicates a MAC failure
+     */
+    isMacError(errorCode: any): boolean;
+    /**
+     * Increment retry counter for a message
+     */
+    incrementRetryCount(messageId: any): any;
+    /**
+     * Get retry count for a message
+     */
+    getRetryCount(messageId: any): any;
+    /**
+     * Check if message has exceeded maximum retry attempts
+     */
+    hasExceededMaxRetries(messageId: any): boolean;
+    /**
+     * Mark retry as successful
+     */
+    markRetrySuccess(messageId: any): void;
+    /**
+     * Mark retry as failed
+     */
+    markRetryFailed(messageId: any): void;
+    /**
+     * Schedule a phone request with delay
+     */
+    schedulePhoneRequest(messageId: any, callback: any, delay?: number): void;
+    /**
+     * Cancel pending phone request
+     */
+    cancelPendingPhoneRequest(messageId: any): void;
+    clear(): void;
+    saveBaseKey(addr: any, msgId: any, baseKey: any): void;
+    hasSameBaseKey(addr: any, msgId: any, baseKey: any): boolean;
+    deleteBaseKey(addr: any, msgId: any): void;
+    keyToString(key: any): string;
+    removeRecentMessage(messageId: any): void;
+}

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

@@ -0,0 +1,255 @@
+import { LRUCache } from 'lru-cache';
+
+const RECENT_MESSAGES_SIZE = 1024;
+const MESSAGE_KEY_SEPARATOR = '\u0000';
+
+const DEFAULT_MAX_MSG_RETRY_COUNT = 5;
+
+const RECREATE_SESSION_TIMEOUT = 60 * 60 * 1000;
+const PHONE_REQUEST_DELAY = 3000;
+
+export var RetryReason;
+(function (RetryReason) {
+    RetryReason[RetryReason["UnknownError"] = 0] = "UnknownError";
+    RetryReason[RetryReason["SignalErrorNoSession"] = 1] = "SignalErrorNoSession";
+    RetryReason[RetryReason["SignalErrorInvalidKey"] = 2] = "SignalErrorInvalidKey";
+    RetryReason[RetryReason["SignalErrorInvalidKeyId"] = 3] = "SignalErrorInvalidKeyId";
+
+    RetryReason[RetryReason["SignalErrorInvalidMessage"] = 4] = "SignalErrorInvalidMessage";
+    RetryReason[RetryReason["SignalErrorInvalidSignature"] = 5] = "SignalErrorInvalidSignature";
+    RetryReason[RetryReason["SignalErrorFutureMessage"] = 6] = "SignalErrorFutureMessage";
+
+    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";
+})(RetryReason || (RetryReason = {}));
+
+const MAC_ERROR_CODES = new Set([RetryReason.SignalErrorInvalidMessage, RetryReason.SignalErrorBadMac]);
+export class MessageRetryManager {
+    constructor(logger, maxMsgRetryCount) {
+        this.logger = logger;
+        this.recentMessagesMap = new LRUCache({
+            max: RECENT_MESSAGES_SIZE,
+            ttl: 5 * 60 * 1000,
+            ttlAutopurge: true,
+            dispose: (_value, key) => {
+                const separatorIndex = key.lastIndexOf(MESSAGE_KEY_SEPARATOR);
+                if (separatorIndex === -1) {
+                    return;
+                }
+                const messageId = key.slice(separatorIndex + MESSAGE_KEY_SEPARATOR.length);
+                const keys = this.messageKeyIndex.get(messageId);
+                if (!keys) {
+                    return;
+                }
+                keys.delete(key);
+                if (!keys.size) {
+                    this.messageKeyIndex.delete(messageId);
+                }
+            }
+        });
+        this.messageKeyIndex = new Map();
+        this.sessionRecreateHistory = new LRUCache({
+            ttl: RECREATE_SESSION_TIMEOUT * 2,
+            ttlAutopurge: true
+        });
+        this.retryCounters = new LRUCache({
+            ttl: 15 * 60 * 1000,
+            ttlAutopurge: true,
+            updateAgeOnGet: true
+        });
+        this.baseKeys = new LRUCache({
+            max: 1024,
+            ttl: 15 * 60 * 1000,
+            ttlAutopurge: true
+        });
+        this.pendingPhoneRequests = {};
+        this.statistics = {
+            totalRetries: 0,
+            successfulRetries: 0,
+            failedRetries: 0,
+            mediaRetries: 0,
+            sessionRecreations: 0,
+            phoneRequests: 0
+        };
+        this.maxMsgRetryCount = Number.isInteger(maxMsgRetryCount) ? maxMsgRetryCount : DEFAULT_MAX_MSG_RETRY_COUNT;
+    }
+
+    addRecentMessage(to, id, message) {
+        const key = { to, id };
+        const keyStr = this.keyToString(key);
+
+        this.recentMessagesMap.set(keyStr, {
+            message,
+            timestamp: Date.now()
+        });
+        const keys = this.messageKeyIndex.get(id);
+        if (keys) {
+            keys.add(keyStr);
+        }
+        else {
+            this.messageKeyIndex.set(id, new Set([keyStr]));
+        }
+        this.logger.debug(`Added message to retry cache: ${to}/${id}`);
+    }
+
+    getRecentMessage(to, id) {
+        const key = { to, id };
+        const keyStr = this.keyToString(key);
+        return this.recentMessagesMap.get(keyStr);
+    }
+
+    shouldRecreateSession(jid, hasSession, errorCode) {
+
+        if (!hasSession) {
+            this.sessionRecreateHistory.set(jid, Date.now());
+            this.statistics.sessionRecreations++;
+            return {
+                reason: "we don't have a Signal session with them",
+                recreate: true
+            };
+        }
+
+        if (errorCode !== undefined && MAC_ERROR_CODES.has(errorCode)) {
+            this.sessionRecreateHistory.set(jid, Date.now());
+            this.statistics.sessionRecreations++;
+            this.logger.warn({ jid, errorCode: RetryReason[errorCode] }, 'MAC error detected, forcing immediate session recreation');
+            return {
+                reason: `MAC error (code ${errorCode}: ${RetryReason[errorCode]}), immediate session recreation`,
+                recreate: true
+            };
+        }
+        const now = Date.now();
+        const prevTime = this.sessionRecreateHistory.get(jid);
+
+        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 };
+    }
+
+    parseRetryErrorCode(errorAttr) {
+        if (errorAttr === undefined || errorAttr === '') {
+            return undefined;
+        }
+        const code = parseInt(errorAttr, 10);
+        if (Number.isNaN(code)) {
+            return undefined;
+        }
+
+        if (code >= RetryReason.UnknownError && code <= RetryReason.StatusRevokeDelay) {
+            return code;
+        }
+        return RetryReason.UnknownError;
+    }
+
+    isMacError(errorCode) {
+        return errorCode !== undefined && MAC_ERROR_CODES.has(errorCode);
+    }
+
+    incrementRetryCount(messageId) {
+        this.retryCounters.set(messageId, (this.retryCounters.get(messageId) || 0) + 1);
+        this.statistics.totalRetries++;
+        return this.retryCounters.get(messageId);
+    }
+
+    getRetryCount(messageId) {
+        return this.retryCounters.get(messageId) || 0;
+    }
+
+    hasExceededMaxRetries(messageId) {
+        return this.getRetryCount(messageId) >= this.maxMsgRetryCount;
+    }
+
+    markRetrySuccess(messageId) {
+        this.statistics.successfulRetries++;
+
+        this.retryCounters.delete(messageId);
+        this.cancelPendingPhoneRequest(messageId);
+        this.removeRecentMessage(messageId);
+    }
+
+    markRetryFailed(messageId) {
+        this.statistics.failedRetries++;
+        this.retryCounters.delete(messageId);
+        this.cancelPendingPhoneRequest(messageId);
+        this.removeRecentMessage(messageId);
+    }
+
+    schedulePhoneRequest(messageId, callback, delay = PHONE_REQUEST_DELAY) {
+
+        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`);
+    }
+
+    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}`);
+        }
+    }
+    clear() {
+        this.recentMessagesMap.clear();
+        this.messageKeyIndex.clear();
+        this.sessionRecreateHistory.clear();
+        this.retryCounters.clear();
+        this.baseKeys.clear();
+        for (const messageId of Object.keys(this.pendingPhoneRequests)) {
+            this.cancelPendingPhoneRequest(messageId);
+        }
+        this.statistics = {
+            totalRetries: 0,
+            successfulRetries: 0,
+            failedRetries: 0,
+            mediaRetries: 0,
+            sessionRecreations: 0,
+            phoneRequests: 0
+        };
+    }
+    saveBaseKey(addr, msgId, baseKey) {
+        this.baseKeys.set(`${addr}:${msgId}`, baseKey);
+    }
+    hasSameBaseKey(addr, msgId, baseKey) {
+        const stored = this.baseKeys.get(`${addr}:${msgId}`);
+        if (!stored || stored.length !== baseKey.length) {
+            return false;
+        }
+        for (let i = 0; i < stored.length; i++) {
+            if (stored[i] !== baseKey[i])
+                return false;
+        }
+        return true;
+    }
+    deleteBaseKey(addr, msgId) {
+        this.baseKeys.delete(`${addr}:${msgId}`);
+    }
+    keyToString(key) {
+        return `${key.to}${MESSAGE_KEY_SEPARATOR}${key.id}`;
+    }
+    removeRecentMessage(messageId) {
+        const keys = this.messageKeyIndex.get(messageId);
+        if (!keys) {
+            return;
+        }
+        for (const keyStr of [...keys]) {
+            this.recentMessagesMap.delete(keyStr);
+        }
+        this.messageKeyIndex.delete(messageId);
+    }
+}

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

@@ -0,0 +1,136 @@
+/** generates all the keys required to encrypt/decrypt & sign a media message */
+export function getMediaKeys(buffer: any, mediaType: any): Promise<{
+    iv: any;
+    cipherKey: any;
+    macKey: any;
+}>;
+export function getAudioDuration(buffer: any): Promise<any>;
+/**
+  referenced from and modifying https://github.com/wppconnect-team/wa-js/blob/main/src/chat/functions/prepareAudioWaveform.ts
+ */
+export function getAudioWaveform(buffer: any, logger: any): Promise<Uint8Array<ArrayBuffer> | undefined>;
+/** generates a thumbnail for a given media, if required */
+export function generateThumbnail(file: any, mediaType: any, options: any): Promise<{
+    thumbnail: any;
+    originalImageDimensions: {
+        width: any;
+        height: any;
+    } | undefined;
+}>;
+export function extensionForMediaMessage(message: any): any;
+export function getImageProcessingLibrary(): Promise<any>;
+export function hkdfInfoKey(type: any): string;
+export function getRawMediaUploadData(media: any, mediaType: any, logger: any): Promise<{
+    filePath: any;
+    fileSha256: any;
+    fileLength: number;
+}>;
+export function extractVideoThumb(path: any, time: any, size: any): Promise<any>;
+export function extractImageThumb(bufferOrFilePath: any, width?: number): Promise<{
+    buffer: any;
+    original: {
+        width: any;
+        height: any;
+    };
+}>;
+export function encodeBase64EncodedStringForUpload(b64: any): string;
+export function generateProfilePicture(mediaUpload: any, dimensions: any): Promise<{
+    img: any;
+}>;
+export function mediaMessageSHA256B64(message: any): any;
+export function toReadable(buffer: any): any;
+export function toBuffer(stream: any): Promise<any>;
+export function getStream(item: any, opts: any): Promise<{
+    stream: any;
+    type: string;
+}>;
+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;
+    mac: any;
+    fileEncSha256: any;
+    fileSha256: any;
+    fileLength: number;
+}>;
+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: any;
+    url: any;
+}, type: any, opts?: {}): Promise<any>;
+export function downloadEncryptedContent(downloadUrl: any, { cipherKey, iv }: {
+    cipherKey: any;
+    iv: any;
+}, { startByte, endByte, options }?: {}): Promise<any>;
+export function uploadWithNodeHttp({ url, filePath, headers, timeoutMs, agent }: {
+    url: any;
+    filePath: any;
+    headers: any;
+    timeoutMs: any;
+    agent: any;
+}, redirectCount?: number): Promise<any>;
+export function getWAUploadToServer({ customUploadHosts, fetchAgent, logger, options }: {
+    customUploadHosts: any;
+    fetchAgent: any;
+    logger: any;
+    options: any;
+}, refreshMediaConn: any): (filePath: any, { mediaType, fileEncSha256B64, timeoutMs, newsletter }: {
+    mediaType: any;
+    fileEncSha256B64: any;
+    timeoutMs: any;
+    newsletter: any;
+}) => Promise<{
+    mediaUrl: any;
+    directPath: any;
+    meta_hmac: any;
+    fbid: any;
+    ts: any;
+    thumbnailDirectPath: any;
+    thumbnailSha256: any;
+}>;
+export function encryptMediaRetryRequest(key: any, mediaKey: any, meId: any): {
+    tag: string;
+    attrs: {
+        id: any;
+        to: string;
+        type: string;
+    };
+    content: ({
+        tag: string;
+        attrs: {
+            jid?: undefined;
+            from_me?: undefined;
+            participant?: undefined;
+        };
+        content: {
+            tag: string;
+            attrs: {};
+            content: any;
+        }[];
+    } | {
+        tag: string;
+        attrs: {
+            jid: any;
+            from_me: string;
+            participant: any;
+        };
+        content?: undefined;
+    })[];
+};
+export function decodeMediaRetryNode(node: any): {
+    key: {
+        id: any;
+        remoteJid: any;
+        fromMe: boolean;
+        participant: any;
+    };
+};
+export function decryptMediaRetryData({ ciphertext, iv }: {
+    ciphertext: any;
+    iv: any;
+}, mediaKey: any, msgId: any): proto.MediaRetryNotification;
+export function getStatusCodeForMediaRetry(code: any): any;
+import { proto } from '../../WAProto/index.js';