@wenzyx1/bails 1.0.0

package/lib/Utils/link-preview.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUrlInfo = void 0;
+const messages_1 = require("./messages");
+const messages_media_1 = require("./messages-media");
+const THUMBNAIL_WIDTH_PX = 192;
+/** 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
+ * Return undefined if the fetch failed or no URL was found
+ * @param text first matched URL in text
+ * @returns the URL info required to generate link preview
+ */
+const getUrlInfo = async (text, opts = {
+    thumbnailWidth: THUMBNAIL_WIDTH_PX,
+    fetchOpts: { timeout: 3000 }
+}) => {
+    var _a;
+    try {
+        // retries
+        const retries = 0;
+        const maxRetry = 5;
+        const { getLinkPreview } = await import('link-preview-js');
+        let previewLink = text;
+        if (!text.startsWith('https://') && !text.startsWith('http://')) {
+            previewLink = 'https://' + previewLink;
+        }
+        const info = await getLinkPreview(previewLink, {
+            ...opts.fetchOpts,
+            followRedirects: 'follow',
+            handleRedirects: (baseURL, forwardedURL) => {
+                const urlObj = new URL(baseURL);
+                const forwardedURLObj = new URL(forwardedURL);
+                if (retries >= maxRetry) {
+                    return false;
+                }
+                if (forwardedURLObj.hostname === urlObj.hostname
+                    || forwardedURLObj.hostname === 'www.' + urlObj.hostname
+                    || 'www.' + forwardedURLObj.hostname === urlObj.hostname) {
+                    retries + 1;
+                    return true;
+                }
+                else {
+                    return false;
+                }
+            },
+            headers: opts.fetchOpts
+        });
+        if (info && 'title' in 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) {
+                const { imageMessage } = await (0, messages_1.prepareWAMessageMedia)({ image: { url: image } }, {
+                    upload: opts.uploadImage,
+                    mediaTypeOverride: 'thumbnail-link',
+                    options: opts.fetchOpts
+                });
+                urlInfo.jpegThumbnail = (imageMessage === null || imageMessage === void 0 ? void 0 : imageMessage.jpegThumbnail)
+                    ? Buffer.from(imageMessage.jpegThumbnail)
+                    : undefined;
+                urlInfo.highQualityThumbnail = imageMessage || undefined;
+            }
+            else {
+                try {
+                    urlInfo.jpegThumbnail = image
+                        ? (await getCompressedJpegThumbnail(image, opts)).buffer
+                        : undefined;
+                }
+                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')) {
+            throw error;
+        }
+    }
+};
+exports.getUrlInfo = getUrlInfo;

package/lib/Utils/logger.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("pino").Logger<{
+    timestamp: () => string;
+}>;
+export default _default;

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.d.ts

@@ -0,0 +1,12 @@
+declare class d {
+    salt: string;
+    constructor(e: string);
+    add(e: any, t: any): any;
+    subtract(e: any, t: any): any;
+    subtractThenAdd(e: any, t: any, r: any): any;
+    _addSingle(e: any, t: any): ArrayBuffer;
+    _subtractSingle(e: any, t: any): ArrayBuffer;
+    performPointwiseWithOverflow(e: any, t: any, r: any): ArrayBuffer;
+}
+export declare const LT_HASH_ANTI_TAMPERING: d;
+export {};

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);
+    }
+    _addSingle(e, t) {
+        var r = this;
+        const n = new Uint8Array((0, crypto_1.hkdf)(Buffer.from(t), o, { info: r.salt })).buffer;
+        return r.performPointwiseWithOverflow(e, n, ((e, t) => e + t));
+    }
+    _subtractSingle(e, t) {
+        var r = this;
+        const n = new Uint8Array((0, crypto_1.hkdf)(Buffer.from(t), o, { info: r.salt })).buffer;
+        return r.performPointwiseWithOverflow(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.d.ts

@@ -0,0 +1,7 @@
+export declare const makeMutex: () => {
+    mutex<T>(code: () => T | Promise<T>): Promise<T>;
+};
+export type Mutex = ReturnType<typeof makeMutex>;
+export declare const makeKeyedMutex: () => {
+    mutex<T>(key: string, task: () => T | Promise<T>): Promise<T>;
+};

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-composer.js

@@ -0,0 +1,293 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LANGUAGE_KEYWORDS = exports.PYTHON_KEYWORDS = exports.JS_KEYWORDS = exports.RichSubMessageType = exports.CodeHighlightType = void 0;
+exports.tokenizeCode = tokenizeCode;
+exports.buildRichContextInfo = buildRichContextInfo;
+exports.buildBotForwardedMessage = buildBotForwardedMessage;
+exports.generateTableContent = generateTableContent;
+exports.generateListContent = generateListContent;
+exports.generateCodeBlockContent = generateCodeBlockContent;
+exports.generateLatexContent = generateLatexContent;
+exports.generateLatexImageContent = generateLatexImageContent;
+exports.generateLatexInlineImageContent = generateLatexInlineImageContent;
+exports.captureUnifiedResponse = captureUnifiedResponse;
+exports.generateUnifiedResponseContent = generateUnifiedResponseContent;
+exports.generateRichMessageContent = generateRichMessageContent;
+const generics_1 = require("./generics");
+const JS_KEYWORDS = new Set([
+    'import', 'export', 'from', 'default', 'as', 'const', 'let', 'var',
+    'function', 'class', 'extends', 'new', 'return', 'if', 'else', 'for',
+    'while', 'do', 'switch', 'case', 'break', 'continue', 'try', 'catch',
+    'finally', 'throw', 'async', 'await', 'yield', 'typeof', 'instanceof',
+    'in', 'of', 'delete', 'void', 'true', 'false', 'null', 'undefined',
+    'NaN', 'Infinity', 'this', 'super', 'static', 'get', 'set', 'debugger', 'with'
+]);
+exports.JS_KEYWORDS = JS_KEYWORDS;
+const PYTHON_KEYWORDS = new Set([
+    'import', 'from', 'as', 'def', 'class', 'return', 'if', 'elif', 'else',
+    'for', 'while', 'break', 'continue', 'try', 'except', 'finally', 'raise',
+    'with', 'yield', 'lambda', 'pass', 'del', 'global', 'nonlocal', 'assert',
+    'True', 'False', 'None', 'and', 'or', 'not', 'in', 'is', 'async', 'await',
+    'self', 'print'
+]);
+exports.PYTHON_KEYWORDS = PYTHON_KEYWORDS;
+const LANGUAGE_KEYWORDS = {
+    javascript: JS_KEYWORDS,
+    typescript: JS_KEYWORDS,
+    js: JS_KEYWORDS,
+    ts: JS_KEYWORDS,
+    python: PYTHON_KEYWORDS,
+    py: PYTHON_KEYWORDS
+};
+exports.LANGUAGE_KEYWORDS = LANGUAGE_KEYWORDS;
+var CodeHighlightType;
+(function (CodeHighlightType) {
+    CodeHighlightType[CodeHighlightType['DEFAULT'] = 0] = 'DEFAULT';
+    CodeHighlightType[CodeHighlightType['KEYWORD'] = 1] = 'KEYWORD';
+    CodeHighlightType[CodeHighlightType['METHOD'] = 2] = 'METHOD';
+    CodeHighlightType[CodeHighlightType['STRING'] = 3] = 'STRING';
+    CodeHighlightType[CodeHighlightType['NUMBER'] = 4] = 'NUMBER';
+    CodeHighlightType[CodeHighlightType['COMMENT'] = 5] = 'COMMENT';
+})(CodeHighlightType || (exports.CodeHighlightType = CodeHighlightType = {}));
+var RichSubMessageType;
+(function (RichSubMessageType) {
+    RichSubMessageType[RichSubMessageType['UNKNOWN'] = 0] = 'UNKNOWN';
+    RichSubMessageType[RichSubMessageType['GRID_IMAGE'] = 1] = 'GRID_IMAGE';
+    RichSubMessageType[RichSubMessageType['TEXT'] = 2] = 'TEXT';
+    RichSubMessageType[RichSubMessageType['INLINE_IMAGE'] = 3] = 'INLINE_IMAGE';
+    RichSubMessageType[RichSubMessageType['TABLE'] = 4] = 'TABLE';
+    RichSubMessageType[RichSubMessageType['CODE'] = 5] = 'CODE';
+    RichSubMessageType[RichSubMessageType['DYNAMIC'] = 6] = 'DYNAMIC';
+    RichSubMessageType[RichSubMessageType['MAP'] = 7] = 'MAP';
+    RichSubMessageType[RichSubMessageType['LATEX'] = 8] = 'LATEX';
+    RichSubMessageType[RichSubMessageType['CONTENT_ITEMS'] = 9] = 'CONTENT_ITEMS';
+})(RichSubMessageType || (exports.RichSubMessageType = RichSubMessageType = {}));
+function tokenizeCode(codeStr, language = 'javascript') {
+    const keywords = LANGUAGE_KEYWORDS[language] || JS_KEYWORDS;
+    const blocks = [];
+    const lines = codeStr.split('\n');
+    for (let li = 0; li < lines.length; li++) {
+        const line = lines[li];
+        const isLast = li === lines.length - 1;
+        const nl = isLast ? '' : '\n';
+        if (!line.trim()) {
+            blocks.push({ highlightType: CodeHighlightType.DEFAULT, codeContent: line + nl });
+            continue;
+        }
+        if (line.trim().startsWith('//') || line.trim().startsWith('#')) {
+            blocks.push({ highlightType: CodeHighlightType.COMMENT, codeContent: line + nl });
+            continue;
+        }
+        const regex = /(\/\/.*$|#.*$)|(["'`](?:[^"'`\\]|\\.)*["'`])|(\b\d+(?:\.\d+)?\b)|(\b[a-zA-Z_$][\w$]*\b)|([^\s\w$"'`]+)|(\s+)/g;
+        let match;
+        const tokens = [];
+        while ((match = regex.exec(line)) !== null) {
+            const val = match[0];
+            if (match[1]) {
+                tokens.push({ highlightType: CodeHighlightType.COMMENT, codeContent: val });
+            }
+            else if (match[2]) {
+                tokens.push({ highlightType: CodeHighlightType.STRING, codeContent: val });
+            }
+            else if (match[3]) {
+                tokens.push({ highlightType: CodeHighlightType.NUMBER, codeContent: val });
+            }
+            else if (match[4]) {
+                if (keywords.has(val)) {
+                    tokens.push({ highlightType: CodeHighlightType.KEYWORD, codeContent: val });
+                }
+                else {
+                    const after = line.slice(regex.lastIndex).trimStart();
+                    if (after.startsWith('(')) {
+                        tokens.push({ highlightType: CodeHighlightType.METHOD, codeContent: val });
+                    }
+                    else {
+                        tokens.push({ highlightType: CodeHighlightType.DEFAULT, codeContent: val });
+                    }
+                }
+            }
+            else {
+                tokens.push({ highlightType: CodeHighlightType.DEFAULT, codeContent: val });
+            }
+        }
+        if (tokens.length === 0) {
+            blocks.push({ highlightType: CodeHighlightType.DEFAULT, codeContent: line + nl });
+            continue;
+        }
+        const merged = [];
+        for (const t of tokens) {
+            const prev = merged.length > 0 ? merged[merged.length - 1] : undefined;
+            if (prev && prev.highlightType === t.highlightType) {
+                prev.codeContent += t.codeContent;
+            }
+            else {
+                merged.push({ ...t });
+            }
+        }
+        if (merged.length > 0) {
+            merged[merged.length - 1].codeContent += nl;
+        }
+        blocks.push(...merged);
+    }
+    return blocks;
+}
+function buildRichContextInfo(quoted, options) {
+    const ctxInfo = {
+        forwardingScore: 1,
+        isForwarded: true,
+        forwardedAiBotMessageInfo: { botJid: (options === null || options === void 0 ? void 0 : options.botJid) ? options.botJid : '867051314767696@bot' },
+        forwardOrigin: 4,
+        ...((options === null || options === void 0 ? void 0 : options.mentions) ? { mentionedJid: options.mentions } : {})
+    };
+    if (quoted === null || quoted === void 0 ? void 0 : quoted.key) {
+        ctxInfo.stanzaId = quoted.key.id;
+        ctxInfo.participant = quoted.key.participant || quoted.sender || quoted.key.remoteJid;
+        ctxInfo.quotedMessage = quoted.message;
+    }
+    return ctxInfo;
+}
+function buildBotForwardedMessage(submessages, contextInfo, unifiedResponse) {
+    const richResponse = { messageType: 1, submessages, contextInfo };
+    if (unifiedResponse) {
+        richResponse.unifiedResponse = unifiedResponse;
+    }
+    return {
+        botForwardedMessage: {
+            message: { richResponseMessage: richResponse }
+        }
+    };
+}
+function generateTableContent(title, headers, rows, quoted, options = {}) {
+    const { footer, headerText } = options;
+    const tableRows = [{ items: headers, isHeading: true }, ...rows.map(row => ({ items: row.map(String) }))];
+    const submessages = [];
+    if (headerText)
+        submessages.push({ messageType: 2, messageText: headerText });
+    submessages.push({ messageType: 4, tableMetadata: { title, rows: tableRows } });
+    if (footer)
+        submessages.push({ messageType: 2, messageText: footer });
+    const ctxInfo = buildRichContextInfo(quoted);
+    return { message: buildBotForwardedMessage(submessages, ctxInfo), messageId: (0, generics_1.generateMessageIDV2)() };
+}
+function generateListContent(title, items, quoted, options = {}) {
+    const { footer, headerText } = options;
+    const tableRows = items.map(item => ({
+        items: Array.isArray(item) ? item.map(String) : [String(item)]
+    }));
+    const submessages = [];
+    if (headerText)
+        submessages.push({ messageType: 2, messageText: headerText });
+    submessages.push({ messageType: 4, tableMetadata: { title, rows: tableRows } });
+    if (footer)
+        submessages.push({ messageType: 2, messageText: footer });
+    const ctxInfo = buildRichContextInfo(quoted);
+    return { message: buildBotForwardedMessage(submessages, ctxInfo), messageId: (0, generics_1.generateMessageIDV2)() };
+}
+function generateCodeBlockContent(code, quoted, options = {}) {
+    const { title, footer, language = 'javascript' } = options;
+    const submessages = [];
+    if (title)
+        submessages.push({ messageType: 2, messageText: title });
+    submessages.push({
+        messageType: 5,
+        codeMetadata: { codeLanguage: language, codeBlocks: tokenizeCode(code, language) }
+    });
+    if (footer)
+        submessages.push({ messageType: 2, messageText: footer });
+    const ctxInfo = buildRichContextInfo(quoted);
+    return { message: buildBotForwardedMessage(submessages, ctxInfo), messageId: (0, generics_1.generateMessageIDV2)() };
+}
+function generateLatexContent(quoted, options) {
+    const { text, expressions, headerText, footer } = options;
+    const submessages = [];
+    if (headerText)
+        submessages.push({ messageType: 2, messageText: headerText });
+    const latexExpressions = expressions.map(expr => {
+        const entry = {
+            latexExpression: expr.latexExpression,
+            url: expr.url,
+            width: expr.width,
+            height: expr.height
+        };
+        if (expr.fontHeight !== undefined)
+            entry.fontHeight = expr.fontHeight;
+        if (expr.imageTopPadding !== undefined)
+            entry.imageTopPadding = expr.imageTopPadding;
+        if (expr.imageLeadingPadding !== undefined)
+            entry.imageLeadingPadding = expr.imageLeadingPadding;
+        if (expr.imageBottomPadding !== undefined)
+            entry.imageBottomPadding = expr.imageBottomPadding;
+        if (expr.imageTrailingPadding !== undefined)
+            entry.imageTrailingPadding = expr.imageTrailingPadding;
+        return entry;
+    });
+    submessages.push({ messageType: 8, latexMetadata: { text: text || '', expressions: latexExpressions } });
+    if (footer)
+        submessages.push({ messageType: 2, messageText: footer });
+    const ctxInfo = buildRichContextInfo(quoted);
+    return { message: buildBotForwardedMessage(submessages, ctxInfo), messageId: (0, generics_1.generateMessageIDV2)() };
+}
+async function generateLatexImageContent(quoted, options, uploadFn, renderLatexToPng) {
+    const { text, expressions, headerText, footer } = options;
+    const submessages = [];
+    if (headerText)
+        submessages.push({ messageType: 2, messageText: headerText });
+    const latexExpressions = await Promise.all(expressions.map(async (expr) => {
+        const { buffer, width, height } = await renderLatexToPng(expr.latexExpression);
+        const uploadResult = await uploadFn(buffer, 'image');
+        const imageUrl = uploadResult.url || uploadResult.directPath;
+        return { latexExpression: expr.latexExpression, url: imageUrl, width, height };
+    }));
+    submessages.push({ messageType: 8, latexMetadata: { text: text || '', expressions: latexExpressions } });
+    if (footer)
+        submessages.push({ messageType: 2, messageText: footer });
+    const ctxInfo = buildRichContextInfo(quoted);
+    return { message: buildBotForwardedMessage(submessages, ctxInfo), messageId: (0, generics_1.generateMessageIDV2)() };
+}
+async function generateLatexInlineImageContent(quoted, options, uploadFn, renderLatexToPng) {
+    const { text, expressions, headerText, footer } = options;
+    const submessages = [];
+    if (headerText)
+        submessages.push({ messageType: 2, messageText: headerText });
+    if (text)
+        submessages.push({ messageType: 2, messageText: text });
+    for (const expr of expressions) {
+        const { buffer, width, height } = await renderLatexToPng(expr.latexExpression);
+        const uploadResult = await uploadFn(buffer, 'image');
+        const imageUrl = uploadResult.url || uploadResult.directPath;
+        submessages.push({
+            messageType: 3,
+            imageMetadata: {
+                imageUrl: { imagePreviewUrl: imageUrl, imageHighResUrl: imageUrl },
+                imageText: expr.latexExpression,
+                alignment: 2
+            }
+        });
+    }
+    if (footer)
+        submessages.push({ messageType: 2, messageText: footer });
+    const ctxInfo = buildRichContextInfo(quoted);
+    return { message: buildBotForwardedMessage(submessages, ctxInfo), messageId: (0, generics_1.generateMessageIDV2)() };
+}
+function captureUnifiedResponse(msg) {
+    var _a, _b;
+    const botFwd = msg === null || msg === void 0 ? void 0 : (_a = msg.botForwardedMessage) === null || _a === void 0 ? void 0 : _a.message;
+    if (!botFwd)
+        return null;
+    const rich = botFwd.richResponseMessage;
+    if (!(rich === null || rich === void 0 ? void 0 : (_b = rich.unifiedResponse) === null || _b === void 0 ? void 0 : _b.data))
+        return null;
+    return {
+        unifiedResponse: { data: rich.unifiedResponse.data },
+        submessages: rich.submessages || [],
+        contextInfo: rich.contextInfo || {}
+    };
+}
+function generateUnifiedResponseContent(quoted, captured) {
+    const ctxInfo = buildRichContextInfo(quoted);
+    return { message: buildBotForwardedMessage(captured.submessages, ctxInfo, captured.unifiedResponse), messageId: (0, generics_1.generateMessageIDV2)() };
+}
+function generateRichMessageContent(submessages, quoted, options) {
+    const ctxInfo = buildRichContextInfo(quoted, options);
+    return { message: buildBotForwardedMessage(submessages, ctxInfo), messageId: (0, generics_1.generateMessageIDV2)() };
+}