@genuxofficial/baileys 1.0.0

package/lib/Utils/link-preview.js

@@ -0,0 +1,116 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 Promise.resolve().then(() => __importStar(require('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,11 @@
+export interface ILogger {
+    level: string;
+    child(obj: Record<string, unknown>): ILogger;
+    trace(obj: unknown, msg?: string): any;
+    debug(obj: unknown, msg?: string): any;
+    info(obj: unknown, msg?: string): any;
+    warn(obj: unknown, msg?: string): any;
+    error(obj: unknown, msg?: string): any;
+}
+declare const _default: import("pino").Logger<never, boolean>;
+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): Promise<ArrayBuffer>;
+    _subtractSingle(e: any, t: any): Promise<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);
+    }
+    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.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,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeKeyedMutex = exports.makeMutex = void 0;
+const makeMutex = () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    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/messages-media.d.ts

@@ -0,0 +1,108 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { Boom } from '@hapi/boom';
+import { AxiosRequestConfig } from 'axios';
+import { Readable, Transform } from 'stream';
+import { URL } from 'url';
+import { proto } from '../../WAProto';
+import { DownloadableMessage, MediaConnInfo, MediaDecryptionKeyInfo, MediaType, SocketConfig, WAMediaUpload, WAMediaUploadFunction, WAMessageContent } from '../Types';
+import { BinaryNode } from '../WABinary';
+import { ILogger } from './logger';
+export declare const hkdfInfoKey: (type: MediaType) => string;
+/** 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: 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?: ILogger;
+}): 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?: ILogger;
+    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) => Promise<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 {};