rixleys 1.0.0

package/lib/Utils/link-preview.js

@@ -0,0 +1,151 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUrlInfo = exports.getLinkPreview = void 0;
+
+const cheerio = require("cheerio");
+const axios = require("axios");
+const messages_1 = require("./messages");
+const messages_media_1 = require("./messages-media");
+
+const THUMBNAIL_WIDTH_PX = 192;
+
+/**
+ * Built-in Lightweight Link Preview Extractor (Zero External Peer Dependency)
+ */
+async function getLinkPreview(targetUrl, options = {}) {
+    const timeout = options.timeout || 5000;
+    const headers = {
+        "User-Agent":
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+        ...(options.headers || {})
+    };
+
+    try {
+        const response = await axios.get(targetUrl, {
+            headers,
+            timeout,
+            maxRedirects: 5,
+            validateStatus: (status) => status >= 200 && status < 400
+        });
+
+        const html = response.data;
+        if (typeof html !== "string") return null;
+
+        const $ = cheerio.load(html);
+
+        // Extract Title
+        const title =
+            $('meta[property="og:title"]').attr("content") ||
+            $('meta[name="twitter:title"]').attr("content") ||
+            $("title").text() ||
+            "";
+
+        // Extract Description
+        const description =
+            $('meta[property="og:description"]').attr("content") ||
+            $('meta[name="twitter:description"]').attr("content") ||
+            $('meta[name="description"]').attr("content") ||
+            "";
+
+        // Extract Images
+        let images = [];
+        const ogImage = $('meta[property="og:image"]').attr("content");
+        const twImage = $('meta[name="twitter:image"]').attr("content");
+        const linkIcon = $('link[rel="image_src"]').attr("href") || $('link[rel="icon"]').attr("href");
+
+        const rawImg = ogImage || twImage || linkIcon;
+        if (rawImg) {
+            try {
+                const absoluteImgUrl = new URL(rawImg, targetUrl).href;
+                images.push(absoluteImgUrl);
+            } catch {
+                images.push(rawImg);
+            }
+        }
+
+        const canonicalUrl =
+            $('link[rel="canonical"]').attr("href") ||
+            $('meta[property="og:url"]').attr("content") ||
+            targetUrl;
+
+        return {
+            url: canonicalUrl,
+            title: title.trim(),
+            description: description.trim(),
+            images,
+            mediaType: "website"
+        };
+    } catch (err) {
+        return null;
+    }
+}
+
+exports.getLinkPreview = getLinkPreview;
+
+/** Fetches an image and generates a thumbnail for it */
+const getCompressedJpegThumbnail = async (url, { thumbnailWidth, fetchOpts }) => {
+    const stream = await (0, messages_media_1.getHttpStream)(url, fetchOpts);
+    const result = await (0, messages_media_1.extractImageThumb)(stream, thumbnailWidth);
+    return result;
+};
+
+/**
+ * Given a piece of text, checks for any URL present, generates link preview for the same and returns it
+ */
+const getUrlInfo = async (text, opts = {
+    thumbnailWidth: THUMBNAIL_WIDTH_PX,
+    fetchOpts: { timeout: 3000 }
+}) => {
+    var _a;
+    try {
+        let previewLink = text;
+        if (!text.startsWith("https://") && !text.startsWith("http://")) {
+            previewLink = "https://" + previewLink;
+        }
+
+        const info = await getLinkPreview(previewLink, opts.fetchOpts);
+
+        if (info && info.title) {
+            const [image] = info.images || [];
+            const urlInfo = {
+                "canonical-url": info.url,
+                "matched-text": text,
+                title: info.title,
+                description: info.description,
+                originalThumbnailUrl: image
+            };
+
+            if (opts.uploadImage && image) {
+                const { imageMessage } = await (0, messages_1.prepareWAMessageMedia)(
+                    { image: { url: image } },
+                    {
+                        upload: opts.uploadImage,
+                        mediaTypeOverride: "thumbnail-link",
+                        options: opts.fetchOpts
+                    }
+                );
+                urlInfo.jpegThumbnail = imageMessage?.jpegThumbnail
+                    ? Buffer.from(imageMessage.jpegThumbnail)
+                    : undefined;
+                urlInfo.highQualityThumbnail = imageMessage || undefined;
+            } else if (image) {
+                try {
+                    urlInfo.jpegThumbnail = (await getCompressedJpegThumbnail(image, opts)).buffer;
+                } catch (error) {
+                    (_a = opts.logger) === null || _a === void 0
+                        ? void 0
+                        : _a.debug({ err: error.stack, url: previewLink }, "error in generating thumbnail");
+                }
+            }
+            return urlInfo;
+        }
+    } catch (error) {
+        if (!error.message?.includes("receive a valid")) {
+            // ignore preview fail
+        }
+    }
+};
+
+exports.getUrlInfo = getUrlInfo;

package/lib/Utils/logger.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pino_1 = __importDefault(require("pino"));
+exports.default = (0, pino_1.default)({ timestamp: () => `,"time":"${new Date().toJSON()}"` });

package/lib/Utils/lt-hash.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LT_HASH_ANTI_TAMPERING = void 0;
+const crypto_1 = require("./crypto");
+/**
+ * LT Hash is a summation based hash algorithm that maintains the integrity of a piece of data
+ * over a series of mutations. You can add/remove mutations and it'll return a hash equal to
+ * if the same series of mutations was made sequentially.
+ */
+const o = 128;
+class d {
+    constructor(e) {
+        this.salt = e;
+    }
+    add(e, t) {
+        var r = this;
+        for (const item of t) {
+            e = r._addSingle(e, item);
+        }
+        return e;
+    }
+    subtract(e, t) {
+        var r = this;
+        for (const item of t) {
+            e = r._subtractSingle(e, item);
+        }
+        return e;
+    }
+    subtractThenAdd(e, t, r) {
+        var n = this;
+        return n.add(n.subtract(e, r), t);
+    }
+    async _addSingle(e, t) {
+        var r = this;
+        const n = new Uint8Array(await (0, crypto_1.hkdf)(Buffer.from(t), o, { info: r.salt })).buffer;
+        return r.performPointwiseWithOverflow(await e, n, ((e, t) => e + t));
+    }
+    async _subtractSingle(e, t) {
+        var r = this;
+        const n = new Uint8Array(await (0, crypto_1.hkdf)(Buffer.from(t), o, { info: r.salt })).buffer;
+        return r.performPointwiseWithOverflow(await e, n, ((e, t) => e - t));
+    }
+    performPointwiseWithOverflow(e, t, r) {
+        const n = new DataView(e), i = new DataView(t), a = new ArrayBuffer(n.byteLength), s = new DataView(a);
+        for (let e = 0; e < n.byteLength; e += 2) {
+            s.setUint16(e, r(n.getUint16(e, !0), i.getUint16(e, !0)), !0);
+        }
+        return a;
+    }
+}
+exports.LT_HASH_ANTI_TAMPERING = new d('WhatsApp Patch Integrity');

package/lib/Utils/make-mutex.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeKeyedMutex = exports.makeMutex = void 0;
+const makeMutex = () => {
+    let task = Promise.resolve();
+    let taskTimeout;
+    return {
+        mutex(code) {
+            task = (async () => {
+                // wait for the previous task to complete
+                // if there is an error, we swallow so as to not block the queue
+                try {
+                    await task;
+                }
+                catch (_a) { }
+                try {
+                    // execute the current task
+                    const result = await code();
+                    return result;
+                }
+                finally {
+                    clearTimeout(taskTimeout);
+                }
+            })();
+            // we replace the existing task, appending the new piece of execution to it
+            // so the next task will have to wait for this one to finish
+            return task;
+        },
+    };
+};
+exports.makeMutex = makeMutex;
+const makeKeyedMutex = () => {
+    const map = {};
+    return {
+        mutex(key, task) {
+            if (!map[key]) {
+                map[key] = (0, exports.makeMutex)();
+            }
+            return map[key].mutex(task);
+        }
+    };
+};
+exports.makeKeyedMutex = makeKeyedMutex;

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

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageRetryManager = exports.RetryReason = void 0;
+
+const lru_cache_1 = require("lru-cache");
+
+const RECENT_MESSAGES_SIZE = 1000;
+const MESSAGE_KEY_SEPARATOR = '\u0000';
+const RECREATE_SESSION_TIMEOUT = 60 * 60 * 1000;
+
+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 = exports.RetryReason || (exports.RetryReason = {}));
+
+const MAC_ERROR_CODES = new Set([RetryReason.SignalErrorInvalidMessage, RetryReason.SignalErrorBadMac]);
+
+class MessageRetryManager {
+    constructor(logger, maxMsgRetryCount = 5) {
+        this.logger = logger;
+        this.maxMsgRetryCount = maxMsgRetryCount;
+        this.messageKeyIndex = new Map();
+        this.pendingPhoneRequests = {};
+        this.statistics = {
+            totalRetries: 0,
+            successfulRetries: 0,
+            failedRetries: 0,
+            mediaRetries: 0,
+            sessionRecreations: 0,
+            phoneRequests: 0
+        };
+        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({
+            max: 10000,
+            ttl: RECREATE_SESSION_TIMEOUT,
+            ttlAutopurge: true
+        });
+        this.retryCounters = new lru_cache_1.LRUCache({
+            max: 5000,
+            ttl: 15 * 60 * 1000,
+            ttlAutopurge: true
+        });
+        this.baseKeys = new lru_cache_1.LRUCache({
+            max: 1024,
+            ttl: 15 * 60 * 1000,
+            ttlAutopurge: true
+        });
+    }
+
+    addRecentMessage(key, message) {
+        const id = key.id;
+        if (!id) return;
+        const keyStr = this.keyToString(key);
+        this.recentMessagesMap.set(keyStr, { message, timestamp: Date.now() });
+        this.messageKeyIndex.set(id, keyStr);
+    }
+
+    getRecentMessage(key) {
+        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: 'no existing session', 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: 'session recreation timeout window expired', recreate: true };
+        }
+        return {
+            reason: `session recreated recently at ${new Date(prevTime).toISOString()}, skipping`,
+            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, delayMs = 3000) {
+        this.cancelPendingPhoneRequest(messageId);
+        this.pendingPhoneRequests[messageId] = setTimeout(() => {
+            delete this.pendingPhoneRequests[messageId];
+            this.statistics.phoneRequests++;
+            callback();
+        }, delayMs);
+    }
+
+    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}${MESSAGE_KEY_SEPARATOR}${key.id}`;
+    }
+
+    removeRecentMessage(messageId) {
+        const keyStr = this.messageKeyIndex.get(messageId);
+        if (!keyStr) return;
+        this.recentMessagesMap.delete(keyStr);
+        this.messageKeyIndex.delete(messageId);
+    }
+}
+
+exports.MessageRetryManager = MessageRetryManager;