@vanzxy/baileys 2.0.0

package/lib/Utils/auto-reply.d.ts

@@ -0,0 +1,47 @@
+import type { WAMessage, AnyMessageContent } from '../Types/index.js';
+export interface AutoReplyRule {
+    id?: string;
+    keywords?: string[];
+    pattern?: RegExp;
+    exactMatch?: string;
+    response: AnyMessageContent | ((message: WAMessage, match: RegExpMatchArray | string[]) => Promise<AnyMessageContent> | AnyMessageContent);
+    cooldown?: number;
+    priority?: number;
+    active?: boolean;
+    groupsOnly?: boolean;
+    privateOnly?: boolean;
+    allowedJids?: string[];
+    blockedJids?: string[];
+    quoted?: boolean;
+}
+export interface AutoReplyOptions {
+    globalCooldown?: number;
+    simulateTyping?: boolean;
+    typingDuration?: number;
+    multiMatch?: boolean;
+    onReply?: (rule: AutoReplyRule, message: WAMessage, response: AnyMessageContent) => void;
+    onError?: (error: Error, rule: AutoReplyRule, message: WAMessage) => void;
+}
+export declare class AutoReplyHandler {
+    private rules;
+    private cooldowns;
+    private globalCooldown;
+    private sendMessage;
+    private sendPresence?;
+    private options;
+    constructor(sendMessage: (jid: string, content: AnyMessageContent, options?: any) => Promise<any>, sendPresence?: (jid: string, presence: string) => Promise<void>, options?: AutoReplyOptions);
+    addRule(rule: AutoReplyRule): AutoReplyRule & {
+        id: string;
+    };
+    removeRule(id: string): boolean;
+    getRules(): (AutoReplyRule & {
+        id: string;
+    })[];
+    getRule(id: string): (AutoReplyRule & {
+        id: string;
+    }) | undefined;
+    setRuleActive(id: string, active: boolean): boolean;
+    clearRules(): void;
+    processMessage(message: WAMessage): Promise<boolean>;
+}
+export declare const createAutoReply: (sendMessage: (jid: string, content: AnyMessageContent, options?: any) => Promise<any>, sendPresence?: (jid: string, presence: string) => Promise<void>, options?: AutoReplyOptions) => AutoReplyHandler;

package/lib/Utils/auto-reply.js

@@ -0,0 +1,158 @@
+// Vanz@Add --- ported from Bail-master addons/auto-reply.ts (type-only
+// annotations dropped; behavior unchanged).
+export class AutoReplyHandler {
+    rules = new Map();
+    cooldowns = new Map();
+    globalCooldown = new Map();
+    sendMessage;
+    sendPresence;
+    options;
+    constructor(sendMessage, sendPresence, options = {}) {
+        this.sendMessage = sendMessage;
+        this.sendPresence = sendPresence;
+        this.options = {
+            globalCooldown: options.globalCooldown ?? 1000,
+            simulateTyping: options.simulateTyping ?? false,
+            typingDuration: options.typingDuration ?? 1000,
+            multiMatch: options.multiMatch ?? false,
+            onReply: options.onReply ?? (() => { }),
+            onError: options.onError ?? (() => { })
+        };
+    }
+    generateId() {
+        return `ar_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    }
+    /** Add a rule keyed by keywords, a regex pattern, or an exact-match string. */
+    addRule(rule) {
+        const fullRule = {
+            ...rule,
+            id: rule.id ?? this.generateId(),
+            active: rule.active ?? true,
+            priority: rule.priority ?? 0
+        };
+        if (!fullRule.keywords && !fullRule.pattern && !fullRule.exactMatch)
+            throw new Error('Rule must have keywords, pattern, or exactMatch');
+        this.rules.set(fullRule.id, fullRule);
+        return fullRule;
+    }
+    removeRule(id) {
+        return this.rules.delete(id);
+    }
+    getRules() {
+        return Array.from(this.rules.values());
+    }
+    getRule(id) {
+        return this.rules.get(id);
+    }
+    setRuleActive(id, active) {
+        const r = this.rules.get(id);
+        if (r) {
+            r.active = active;
+            return true;
+        }
+        return false;
+    }
+    clearRules() {
+        this.rules.clear();
+    }
+    checkCooldown(ruleId, jid) {
+        return Date.now() - (this.cooldowns.get(`${ruleId}:${jid}`) ?? 0) > 0;
+    }
+    checkGlobalCooldown(jid) {
+        return Date.now() - (this.globalCooldown.get(jid) ?? 0) > this.options.globalCooldown;
+    }
+    setCooldown(ruleId, jid, cooldown) {
+        this.cooldowns.set(`${ruleId}:${jid}`, Date.now() + cooldown);
+    }
+    matchRule(text, rule) {
+        if (!rule.active)
+            return null;
+        if (text.toLowerCase() === rule.exactMatch?.toLowerCase())
+            return [text];
+        if (rule.keywords?.length) {
+            const lower = text.toLowerCase();
+            for (const kw of rule.keywords)
+                if (lower.includes(kw.toLowerCase()))
+                    return [kw];
+        }
+        if (rule.pattern)
+            return text.match(rule.pattern);
+        return null;
+    }
+    isJidAllowed(jid, rule) {
+        const isGroup = jid.endsWith('@g.us');
+        if (jid.endsWith('@newsletter'))
+            return false;
+        if (rule.groupsOnly && !isGroup)
+            return false;
+        if (rule.privateOnly && isGroup)
+            return false;
+        if (rule.allowedJids?.length && !rule.allowedJids.includes(jid))
+            return false;
+        if (rule.blockedJids?.includes(jid))
+            return false;
+        return true;
+    }
+    /**
+     * Feed each incoming message through here (e.g. from `messages.upsert`).
+     * Returns true if a rule matched and a reply was sent.
+     */
+    async processMessage(message) {
+        const content = message.message;
+        if (!content)
+            return false;
+        const text = content.conversation ||
+            content.extendedTextMessage?.text ||
+            content.imageMessage?.caption ||
+            content.videoMessage?.caption ||
+            content.documentMessage?.caption ||
+            '';
+        if (!text)
+            return false;
+        const jid = message.key.remoteJid;
+        if (!jid || !this.checkGlobalCooldown(jid))
+            return false;
+        const sortedRules = Array.from(this.rules.values())
+            .filter((r) => r.active)
+            .sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+        let matched = false;
+        for (const rule of sortedRules) {
+            if (!this.isJidAllowed(jid, rule))
+                continue;
+            if (rule.cooldown && !this.checkCooldown(rule.id, jid))
+                continue;
+            const match = this.matchRule(text, rule);
+            if (!match)
+                continue;
+            try {
+                let response;
+                if (typeof rule.response === 'function')
+                    response = await rule.response(message, match);
+                else
+                    response = rule.response;
+                if (this.options.simulateTyping && this.sendPresence) {
+                    await this.sendPresence(jid, 'composing');
+                    await new Promise((r) => setTimeout(r, this.options.typingDuration));
+                    await this.sendPresence(jid, 'paused');
+                }
+                await this.sendMessage(jid, response, rule.quoted ? { quoted: message } : undefined);
+                // Vanz@Fix (bug 60): global cooldown used to only get stamped inside
+                // setCooldown(), which only ran when the matched rule had its own
+                // cooldown — so rules without one never fed the global anti-spam gate.
+                this.globalCooldown.set(jid, Date.now());
+                if (rule.cooldown)
+                    this.setCooldown(rule.id, jid, rule.cooldown);
+                this.options.onReply(rule, message, response);
+                matched = true;
+                if (!this.options.multiMatch)
+                    break;
+            }
+            catch (error) {
+                this.options.onError(error, rule, message);
+            }
+        }
+        return matched;
+    }
+}
+export const createAutoReply = (sendMessage, sendPresence, options) => new AutoReplyHandler(sendMessage, sendPresence, options);
+//# sourceMappingURL=auto-reply.js.map

package/lib/Utils/baileys-event-stream.d.ts

@@ -0,0 +1,8 @@
+import type { BaileysEventEmitter } from '../Types/index.js';
+/** Monkey-patches ev.emit to append every event as an NDJSON line to `filename`. */
+export declare const captureEventStream: (ev: BaileysEventEmitter, filename: string) => void;
+/** Reads an NDJSON file written by captureEventStream and replays each event on a new EventEmitter. */
+export declare const readAndEmitEventStream: (filename: string, delayIntervalMs?: number) => {
+    ev: BaileysEventEmitter;
+    task: Promise<void>;
+};

package/lib/Utils/baileys-event-stream.js

@@ -0,0 +1,62 @@
+// Ported from @queenanya/baileys `addons/baileys-event-stream.ts`.
+// Adjustments for @vanzxy/baileys: import paths rewired to this fork's own
+// `generics.js` (delay) and `make-mutex.js` (makeMutex) — both already
+// present, no logic changes otherwise.
+import EventEmitter from 'events';
+import { createReadStream } from 'fs';
+import { writeFile } from 'fs/promises';
+import { createInterface } from 'readline';
+import { delay } from './generics.js';
+import { makeMutex } from './make-mutex.js';
+
+/**
+ * Monkey-patches `ev.emit` to append every Baileys event as a JSON line
+ * (NDJSON) to `filename`. Useful for debugging or replaying sessions.
+ *
+ * @example
+ * captureEventStream(sock.ev, './events.ndjson')
+ */
+export const captureEventStream = (ev, filename) => {
+    const originalEmit = ev.emit.bind(ev);
+    const writeMutex = makeMutex();
+    const patchedEmit = (event, ...rest) => {
+        const line = JSON.stringify({ timestamp: Date.now(), event, data: rest[0] }) + '\n';
+        const result = originalEmit(event, ...rest);
+        void writeMutex.mutex(async () => {
+            await writeFile(filename, line, { flag: 'a' });
+        });
+        return result;
+    };
+    ev.emit = patchedEmit;
+};
+
+/**
+ * Reads an NDJSON file written by {@link captureEventStream} and replays
+ * each event on a new EventEmitter.
+ *
+ * @param filename        Path to the NDJSON file.
+ * @param delayIntervalMs Milliseconds to wait between events (default 0).
+ * @returns `{ ev, task }` — ev is the emitter, task resolves when done.
+ */
+export const readAndEmitEventStream = (filename, delayIntervalMs = 0) => {
+    const ev = new EventEmitter();
+    const fireEvents = async () => {
+        const fileStream = createReadStream(filename);
+        const rl = createInterface({ input: fileStream, crlfDelay: Infinity });
+        for await (const line of rl) {
+            if (!line.trim())
+                continue;
+            try {
+                const { event, data } = JSON.parse(line);
+                ev.emit(event, data);
+                if (delayIntervalMs)
+                    await delay(delayIntervalMs);
+            }
+            catch {
+                // skip malformed lines
+            }
+        }
+        fileStream.destroy();
+    };
+    return { ev, task: fireEvents() };
+};

package/lib/Utils/browser-utils.d.ts

@@ -0,0 +1,8 @@
+export namespace Browsers {
+    function ubuntu(browser: any): any[];
+    function macOS(browser: any): any[];
+    function baileys(browser: any): any[];
+    function windows(browser: any): any[];
+    function appropriate(browser: any): any[];
+}
+export function getPlatformId(browser: any): any;

package/lib/Utils/browser-utils.js

@@ -0,0 +1,28 @@
+import { platform, release } from 'os';
+import { proto } from '../../WAProto/index.js';
+const PLATFORM_MAP = {
+    aix: 'AIX',
+    darwin: 'Mac OS',
+    win32: 'Windows',
+    android: 'Android',
+    freebsd: 'FreeBSD',
+    openbsd: 'OpenBSD',
+    sunos: 'Solaris',
+    linux: undefined,
+    haiku: undefined,
+    cygwin: undefined,
+    netbsd: undefined
+};
+export const Browsers = {
+    ubuntu: browser => ['Ubuntu', browser, '22.04.4'],
+    macOS: browser => ['Mac OS', browser, '14.4.1'],
+    baileys: browser => ['Baileys', browser, '6.5.0'],
+    windows: browser => ['Windows', browser, '10.0.22631'],
+    /** The appropriate browser based on your OS & release */
+    appropriate: browser => [PLATFORM_MAP[platform()] || 'Ubuntu', browser, release()]
+};
+export const getPlatformId = (browser) => {
+    const platformType = proto.DeviceProps.PlatformType[browser.toUpperCase()];
+    return platformType ? platformType.toString() : '1'; //chrome
+};
+//# sourceMappingURL=browser-utils.js.map

package/lib/Utils/business.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Uploads images not already uploaded to WA's servers
+ */
+export function uploadingNecessaryImagesOfProduct(product: any, waUploadToServer: any, timeoutMs?: number): Promise<any>;
+export function parseCatalogNode(node: any): {
+    products: any;
+    nextPageCursor: any;
+};
+export function parseCollectionsNode(node: any): {
+    collections: any;
+};
+export function parseOrderDetailsNode(node: any): {
+    price: {
+        total: number;
+        currency: any;
+    };
+    products: any;
+};
+export function toProductNode(productId: any, product: any): {
+    tag: string;
+    attrs: {
+        compliance_category: string;
+        is_hidden: any;
+    };
+    content: {
+        tag: string;
+        attrs: {};
+        content: any;
+    }[];
+};
+export function parseProductNode(productNode: any): {
+    id: any;
+    imageUrls: {
+        requested: any;
+        original: any;
+    };
+    reviewStatus: {
+        whatsapp: any;
+    };
+    availability: string;
+    name: any;
+    retailerId: any;
+    url: any;
+    description: any;
+    price: number;
+    currency: any;
+    isHidden: boolean;
+};
+export function uploadingNecessaryImages(images: any, waUploadToServer: any, timeoutMs?: number): Promise<any[]>;

package/lib/Utils/business.js

@@ -0,0 +1,240 @@
+import { Boom } from '@hapi/boom';
+import { createHash } from 'crypto';
+import { createWriteStream, promises as fs } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { getBinaryNodeChild, getBinaryNodeChildren, getBinaryNodeChildString } from '../WABinary/index.js';
+import { generateMessageIDV2 } from './generics.js';
+import logger from './logger.js';
+import { getStream, getUrlFromDirectPath } from './messages-media.js';
+export const parseCatalogNode = (node) => {
+    const catalogNode = getBinaryNodeChild(node, 'product_catalog');
+    const products = getBinaryNodeChildren(catalogNode, 'product').map(parseProductNode);
+    const paging = getBinaryNodeChild(catalogNode, 'paging');
+    return {
+        products,
+        nextPageCursor: paging ? getBinaryNodeChildString(paging, 'after') : undefined
+    };
+};
+export const parseCollectionsNode = (node) => {
+    const collectionsNode = getBinaryNodeChild(node, 'collections');
+    const collections = getBinaryNodeChildren(collectionsNode, 'collection').map(collectionNode => {
+        const id = getBinaryNodeChildString(collectionNode, 'id');
+        const name = getBinaryNodeChildString(collectionNode, 'name');
+        const products = getBinaryNodeChildren(collectionNode, 'product').map(parseProductNode);
+        return {
+            id,
+            name,
+            products,
+            status: parseStatusInfo(collectionNode)
+        };
+    });
+    return {
+        collections
+    };
+};
+export const parseOrderDetailsNode = (node) => {
+    const orderNode = getBinaryNodeChild(node, 'order');
+    const products = getBinaryNodeChildren(orderNode, 'product').map(productNode => {
+        const imageNode = getBinaryNodeChild(productNode, 'image');
+        return {
+            id: getBinaryNodeChildString(productNode, 'id'),
+            name: getBinaryNodeChildString(productNode, 'name'),
+            imageUrl: getBinaryNodeChildString(imageNode, 'url'),
+            price: +getBinaryNodeChildString(productNode, 'price'),
+            currency: getBinaryNodeChildString(productNode, 'currency'),
+            quantity: +getBinaryNodeChildString(productNode, 'quantity')
+        };
+    });
+    const priceNode = getBinaryNodeChild(orderNode, 'price');
+    const orderDetails = {
+        price: {
+            total: +getBinaryNodeChildString(priceNode, 'total'),
+            currency: getBinaryNodeChildString(priceNode, 'currency')
+        },
+        products
+    };
+    return orderDetails;
+};
+export const toProductNode = (productId, product) => {
+    const attrs = {};
+    const content = [];
+    if (typeof productId !== 'undefined') {
+        content.push({
+            tag: 'id',
+            attrs: {},
+            content: Buffer.from(productId)
+        });
+    }
+    if (typeof product.name !== 'undefined') {
+        content.push({
+            tag: 'name',
+            attrs: {},
+            content: Buffer.from(product.name)
+        });
+    }
+    if (typeof product.description !== 'undefined') {
+        content.push({
+            tag: 'description',
+            attrs: {},
+            content: Buffer.from(product.description)
+        });
+    }
+    if (typeof product.retailerId !== 'undefined') {
+        content.push({
+            tag: 'retailer_id',
+            attrs: {},
+            content: Buffer.from(product.retailerId)
+        });
+    }
+    if (product.images.length) {
+        content.push({
+            tag: 'media',
+            attrs: {},
+            content: product.images.map(img => {
+                if (!('url' in img)) {
+                    throw new Boom('Expected img for product to already be uploaded', { statusCode: 400 });
+                }
+                return {
+                    tag: 'image',
+                    attrs: {},
+                    content: [
+                        {
+                            tag: 'url',
+                            attrs: {},
+                            content: Buffer.from(img.url.toString())
+                        }
+                    ]
+                };
+            })
+        });
+    }
+    if (typeof product.price !== 'undefined') {
+        content.push({
+            tag: 'price',
+            attrs: {},
+            content: Buffer.from(product.price.toString())
+        });
+    }
+    if (typeof product.currency !== 'undefined') {
+        content.push({
+            tag: 'currency',
+            attrs: {},
+            content: Buffer.from(product.currency)
+        });
+    }
+    if ('originCountryCode' in product) {
+        if (typeof product.originCountryCode === 'undefined') {
+            attrs['compliance_category'] = 'COUNTRY_ORIGIN_EXEMPT';
+        }
+        else {
+            content.push({
+                tag: 'compliance_info',
+                attrs: {},
+                content: [
+                    {
+                        tag: 'country_code_origin',
+                        attrs: {},
+                        content: Buffer.from(product.originCountryCode)
+                    }
+                ]
+            });
+        }
+    }
+    if (typeof product.isHidden !== 'undefined') {
+        attrs['is_hidden'] = product.isHidden.toString();
+    }
+    const node = {
+        tag: 'product',
+        attrs,
+        content
+    };
+    return node;
+};
+export const parseProductNode = (productNode) => {
+    const isHidden = productNode.attrs.is_hidden === 'true';
+    const id = getBinaryNodeChildString(productNode, 'id');
+    const mediaNode = getBinaryNodeChild(productNode, 'media');
+    const statusInfoNode = getBinaryNodeChild(productNode, 'status_info');
+    const product = {
+        id,
+        imageUrls: parseImageUrls(mediaNode),
+        reviewStatus: {
+            whatsapp: getBinaryNodeChildString(statusInfoNode, 'status')
+        },
+        availability: 'in stock',
+        name: getBinaryNodeChildString(productNode, 'name'),
+        retailerId: getBinaryNodeChildString(productNode, 'retailer_id'),
+        url: getBinaryNodeChildString(productNode, 'url'),
+        description: getBinaryNodeChildString(productNode, 'description'),
+        price: +getBinaryNodeChildString(productNode, 'price'),
+        currency: getBinaryNodeChildString(productNode, 'currency'),
+        isHidden
+    };
+    return product;
+};
+/**
+ * Uploads images not already uploaded to WA's servers
+ */
+export async function uploadingNecessaryImagesOfProduct(product, waUploadToServer, timeoutMs = 30000) {
+    product = {
+        ...product,
+        images: product.images
+            ? await uploadingNecessaryImages(product.images, waUploadToServer, timeoutMs)
+            : product.images
+    };
+    return product;
+}
+/**
+ * Uploads images not already uploaded to WA's servers
+ */
+export const uploadingNecessaryImages = async (images, waUploadToServer, timeoutMs = 30000) => {
+    const results = await Promise.all(images.map(async (img) => {
+        if ('url' in img) {
+            const url = img.url.toString();
+            if (url.includes('.whatsapp.net')) {
+                return { url };
+            }
+        }
+        const { stream } = await getStream(img);
+        const hasher = createHash('sha256');
+        const filePath = join(tmpdir(), 'img' + generateMessageIDV2());
+        const encFileWriteStream = createWriteStream(filePath);
+        // Vanz@Fix (bug 61): no 'error' listener meant a write failure (e.g. disk
+        // full) would surface as an unhandled 'error' event instead of rejecting
+        // this promise; and the stream was never closed before unlink() below.
+        const writeStreamError = new Promise((_, reject) => encFileWriteStream.on('error', reject));
+        for await (const block of stream) {
+            hasher.update(block);
+            encFileWriteStream.write(block);
+        }
+        await Promise.race([
+            new Promise((resolve) => encFileWriteStream.end(resolve)),
+            writeStreamError
+        ]);
+        const sha = hasher.digest('base64');
+        const { directPath } = await waUploadToServer(filePath, {
+            mediaType: 'product-catalog-image',
+            fileEncSha256B64: sha,
+            timeoutMs
+        });
+        await fs.unlink(filePath).catch(err => logger.warn({ err, filePath }, 'Vanz@Fix (bug 57): error deleting temp file')); // was console.log
+        return { url: getUrlFromDirectPath(directPath) };
+    }));
+    return results;
+};
+const parseImageUrls = (mediaNode) => {
+    const imgNode = getBinaryNodeChild(mediaNode, 'image');
+    return {
+        requested: getBinaryNodeChildString(imgNode, 'request_image_url'),
+        original: getBinaryNodeChildString(imgNode, 'original_image_url')
+    };
+};
+const parseStatusInfo = (mediaNode) => {
+    const node = getBinaryNodeChild(mediaNode, 'status_info');
+    return {
+        status: getBinaryNodeChildString(node, 'status'),
+        canAppeal: getBinaryNodeChildString(node, 'can_appeal') === 'true'
+    };
+};
+//# sourceMappingURL=business.js.map