@neelegirl/baileys 1.5.5 → 1.5.7

package/lib/Utils/history.js

@@ -0,0 +1,110 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const util_1 = require("util")
+const zlib_1 = require("zlib")
+const WAProto_1 = require("../../WAProto")
+const Types_1 = require("../Types")
+const WABinary_1 = require("../WABinary")
+const generics_1 = require("./generics")
+const messages_1 = require("./messages")
+const messages_media_1 = require("./messages-media")
+const inflatePromise = util_1.promisify(zlib_1.inflate)
+
+const downloadHistory = async (msg, options) => {
+    const stream = await messages_media_1.downloadContentFromMessage(msg, 'md-msg-hist', { options })
+    const bufferArray = []
+    for await (const chunk of stream) {
+        bufferArray.push(chunk)
+    }
+    let buffer = Buffer.concat(bufferArray)
+    // decompress buffer
+    buffer = await inflatePromise(buffer)
+    const syncData = WAProto_1.proto.HistorySync.decode(buffer)
+    return syncData
+}
+
+const processHistoryMessage = (item) => {
+    const messages = []
+    const contacts = []
+    const chats = []
+    switch (item.syncType) {
+        case WAProto_1.proto.HistorySync.HistorySyncType.INITIAL_BOOTSTRAP:
+        case WAProto_1.proto.HistorySync.HistorySyncType.RECENT:
+        case WAProto_1.proto.HistorySync.HistorySyncType.FULL:
+        case WAProto_1.proto.HistorySync.HistorySyncType.ON_DEMAND:
+            for (const chat of item.conversations) {
+                  contacts.push({
+                    id: chat.id,
+                    name: chat.name || undefined,
+                    lid: chat.lidJid || undefined,
+                    jid: (0, WABinary_1.isJidUser)(chat.id) ? chat.id : undefined
+                });
+                const msgs = chat.messages || []
+                delete chat.messages
+                delete chat.archived
+                delete chat.muteEndTime
+                delete chat.pinned
+                for (const item of msgs) {
+                    const message = item.message
+                    messages.push(message)
+                    if (!chat.messages?.length) {
+                        // keep only the most recent message in the chat array
+                        chat.messages = [{ message }]
+                    }
+                    if (!message.key.fromMe && !chat.lastMessageRecvTimestamp) {
+                        chat.lastMessageRecvTimestamp = generics_1.toNumber(message.messageTimestamp)
+                    }
+                    if (message.messageStubType === Types_1.WAMessageStubType.BIZ_PRIVACY_MODE_TO_BSP
+                        || message.messageStubType === Types_1.WAMessageStubType.BIZ_PRIVACY_MODE_TO_FB
+                        && message.messageStubParameters?.[0]) {
+                        contacts.push({
+                            id: message.key.participant || message.key.remoteJid,
+                            verifiedName: message.messageStubParameters?.[0]
+                        })
+                    }
+                }
+                if (WABinary_1.isJidUser(chat.id) && chat.readOnly && chat.archived) {
+                    delete chat.readOnly
+                }
+                chats.push({ ...chat })
+            }
+            break
+        case WAProto_1.proto.HistorySync.HistorySyncType.PUSH_NAME:
+            for (const c of item.pushnames) {
+                contacts.push({ 
+                	id: c.id, 
+                    name: c.name || undefined, 
+                    lid: c.lidJid || undefined, 
+                    jid: WABinary_1.isJidUser(c.id) ? c.id : undefined
+                }) 
+            }
+            break
+    }
+    return {
+        chats,
+        contacts,
+        messages,
+        syncType: item.syncType,
+        progress: item.progress
+    }
+}
+
+const downloadAndProcessHistorySyncNotification = async (msg, options) => {
+    const historyMsg = await downloadHistory(msg, options)
+    return processHistoryMessage(historyMsg)
+}
+
+const getHistoryMsg = (message) => {
+    const normalizedContent = !!message ? messages_1.normalizeMessageContent(message) : undefined
+    const anyHistoryMsg = normalizedContent?.protocolMessage?.historySyncNotification
+    return anyHistoryMsg
+}
+
+module.exports = {
+  downloadHistory, 
+  processHistoryMessage, 
+  downloadAndProcessHistorySyncNotification, 
+  getHistoryMsg
+}

package/lib/Utils/index.d.ts

@@ -0,0 +1,19 @@
+export * from './generics'
+export * from './decode-wa-message'
+export * from './messages'
+export * from './messages-media'
+export * from './validate-connection'
+export * from './crypto'
+export * from './signal'
+export * from './noise-handler'
+export * from './history'
+export * from './chat-utils'
+export * from './lt-hash'
+export * from './auth-utils'
+export * from './baileys-event-stream'
+export * from './use-mongo-file-auth-state'
+export * from './use-single-file-auth-state'
+export * from './use-multi-file-auth-state'
+export * from './link-preview'
+export * from './event-buffer'
+export * from './process-message'

package/lib/Utils/index.js

@@ -0,0 +1,41 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p)
+}
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+__exportStar(require("./generics"), exports)
+__exportStar(require("./decode-wa-message"), exports)
+__exportStar(require("./messages"), exports)
+__exportStar(require("./messages-media"), exports)
+__exportStar(require("./validate-connection"), exports)
+__exportStar(require("./crypto"), exports)
+__exportStar(require("./signal"), exports)
+__exportStar(require("./noise-handler"), exports)
+__exportStar(require("./history"), exports)
+__exportStar(require("./chat-utils"), exports)
+__exportStar(require("./lt-hash"), exports)
+__exportStar(require("./auth-utils"), exports)
+__exportStar(require("./baileys-event-stream"), exports)
+__exportStar(require("./use-mongo-file-auth-state"), exports)
+__exportStar(require("./use-single-file-auth-state"), exports)
+__exportStar(require("./use-multi-file-auth-state"), exports)
+__exportStar(require("./link-preview"), exports)
+__exportStar(require("./event-buffer"), exports)
+__exportStar(require("./process-message"), exports)
+__exportStar(require("./message-retry-manager"), exports)
+__exportStar(require("./check-npm-version"), exports)

package/lib/Utils/link-preview.d.ts

@@ -0,0 +1,23 @@
+import { AxiosRequestConfig } from 'axios'
+import { WAMediaUploadFunction, WAUrlInfo } from '../Types'
+import { ILogger } from './logger'
+
+export type URLGenerationOptions = {
+    thumbnailWidth: number
+    fetchOpts: {
+        /** Timeout in ms */
+        timeout: number
+        proxyUrl?: string
+        headers?: AxiosRequestConfig<{}>['headers']
+    }
+    uploadImage?: WAMediaUploadFunction
+    logger?: ILogger
+}
+
+/**
+ * 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
+ */
+export declare const getUrlInfo: (text: string, opts?: URLGenerationOptions) => Promise<WAUrlInfo | undefined>

package/lib/Utils/link-preview.js

@@ -0,0 +1,120 @@
+"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 })
+
+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 messages_media_1.getHttpStream(url, fetchOpts)
+    const result = await 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 }}) => {
+    try {
+        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 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 {
+                try {
+                    urlInfo.jpegThumbnail = image
+                        ? (await getCompressedJpegThumbnail(image, opts)).buffer
+                        : undefined
+                }
+                catch (error) {
+                    opts.logger?.debug({ err: error.stack, url: previewLink }, 'error in generating thumbnail')
+                }
+            }
+            return urlInfo
+        }
+    }
+    catch (error) {
+        if (!error.message.includes('receive a valid')) {
+            throw error
+        }
+    }
+}
+
+module.exports = {
+  getUrlInfo
+}

package/lib/Utils/logger.d.ts

@@ -0,0 +1,13 @@
+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 = pino_1.default({ timestamp: () => `,"time":"${new Date().toJSON()}"` })

package/lib/Utils/lt-hash.d.ts

@@ -0,0 +1,14 @@
+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,58 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+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 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 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
+    }
+}
+
+const LT_HASH_ANTI_TAMPERING = new d('WhatsApp Patch Integrity')
+
+module.exports = {
+  LT_HASH_ANTI_TAMPERING
+}

package/lib/Utils/make-mutex.d.ts

@@ -0,0 +1,9 @@
+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,49 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+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
+        },
+    }
+}
+
+const makeKeyedMutex = () => {
+    const map = {}
+    return {
+        mutex(key, task) {
+            if (!map[key]) {
+                map[key] = makeMutex()
+            }
+            return map[key].mutex(task)
+        }
+    }
+}
+
+module.exports = {
+  makeMutex, 
+  makeKeyedMutex
+}

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

@@ -0,0 +1,82 @@
+import type { proto } from '../../WAProto';
+import type { ILogger } from './logger';
+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 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 and history
+     */
+    shouldRecreateSession(jid: string, retryCount: number, hasSession: boolean): {
+        reason: string;
+        recreate: 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;
+}
+