@vanzxysenpai/baileys 0.0.0-stage → 0.0.2

package/lib/Utils/auto-reply.js

@@ -0,0 +1,152 @@
+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);
+                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);

package/lib/Utils/bad-mac-handler.d.ts

@@ -0,0 +1,59 @@
+export function isBadMacError(error: any): any;
+export function isSessionError(error: any): any;
+export class BadMacHandler {
+    /**
+     * @param {object} [options]
+     * @param {number} [options.maxRetries=5] Errors within one window before `hasReachedLimit()` turns true.
+     * @param {number} [options.resetInterval=300000] Window length (ms); the counter resets once it has passed.
+     * @param {string} [options.authFolder] Folder used by `useMultiFileAuthState()` — required for cleanup.
+     * @param {{ warn?: Function, error?: Function }} [options.logger] pino-style logger (defaults to silent).
+     * @param {(stats: object) => void} [options.onLimit] Called each time an error is handled while at/over the limit.
+     */
+    constructor(options?: {
+        maxRetries?: number;
+        resetInterval?: number;
+        authFolder?: string;
+        logger?: {
+            warn?: Function;
+            error?: Function;
+        };
+        onLimit?: (stats: object) => void;
+    });
+    errorCount: number;
+    maxRetries: number;
+    resetInterval: number;
+    lastReset: number;
+    authFolder: string;
+    logger: {
+        warn?: Function;
+        error?: Function;
+    };
+    onLimit: (stats: object) => void;
+    isBadMacError(error: any): any;
+    isSessionError(error: any): any;
+    /**
+     * Delete per-peer Signal session files (`session-*`, `sender-key-*`) from `authFolder`. creds.json and
+     * app-state-sync-* are always kept; peers renegotiate sessions on the next message. Call it when the bot is
+     * idle or right before a restart — the running socket may still hold those sessions in memory.
+     * @returns {Promise<string[]>} names of the removed files
+     */
+    clearProblematicSessionFiles(opts1?: { [key: string]: any; 
+        dryRun?: boolean;
+    }): Promise<string[]>;
+    incrementErrorCount(): void;
+    resetErrorCount(): void;
+    hasReachedLimit(): boolean;
+    /**
+     * @returns {boolean} true when it was a Bad MAC error (handled/counted — caller may ignore it);
+     *                    false when it was anything else (caller must rethrow).
+     */
+    handleError(error: any, context?: string): boolean;
+    /** Wrap an async fn: Bad MAC is swallowed (returns null), every other error is rethrown. */
+    createSafeWrapper(fn: any, context: any): (...args: any[]) => Promise<any>;
+    getStats(): {
+        errorCount: number;
+        maxRetries: number;
+        lastReset: string;
+        timeUntilReset: number;
+    };
+}

package/lib/Utils/bad-mac-handler.js

@@ -0,0 +1,119 @@
+// Vanz@Port (v2.1.14) --- adapted from @lpzeravk/baileys 1.0.0 (lib/Utils/bad-mac-handler.js, MIT), rewritten:
+//  - comments/log text translated to English; logger is injectable (this fork's Utils/logger.js is a bare pino
+//    instance, not the errorLog/warningLog helpers the source imported);
+//  - `authFolder` has NO hardcoded default path (the source assumed ./assets/auth/baileys) — cleanup is a no-op
+//    with a warning until you pass it;
+//  - `decryption failed` no longer counts as Bad MAC (it also matches unrelated media-decrypt errors);
+//  - cleanup is async, supports `dryRun`, and returns the removed file names.
+//
+// "Bad MAC" happens when a peer's Signal session goes out of sync (they reinstalled WhatsApp, changed device, or a
+// key exchange was lost). It is expected now and then and is not a bot bug — this helper detects/counts it so your own
+// try/catch can ignore it, and can drop the per-peer session files (creds are never touched).
+import fs from 'node:fs/promises';
+import path from 'node:path';
+const noop = () => { };
+const PRESERVE = ['creds.json', 'app-state-sync-key', 'app-state-sync-version'];
+export const isBadMacError = (error) => {
+    const msg = error?.message || String(error ?? '');
+    return msg.includes('Bad MAC') || msg.includes('MAC verification failed');
+};
+export const isSessionError = (error) => {
+    const msg = error?.message || String(error ?? '');
+    return msg.includes('Session') || msg.includes('signal protocol') || msg.includes('decrypt') || isBadMacError(error);
+};
+export class BadMacHandler {
+    /**
+     * @param {object} [options]
+     * @param {number} [options.maxRetries=5] Errors within one window before `hasReachedLimit()` turns true.
+     * @param {number} [options.resetInterval=300000] Window length (ms); the counter resets once it has passed.
+     * @param {string} [options.authFolder] Folder used by `useMultiFileAuthState()` — required for cleanup.
+     * @param {{ warn?: Function, error?: Function }} [options.logger] pino-style logger (defaults to silent).
+     * @param {(stats: object) => void} [options.onLimit] Called each time an error is handled while at/over the limit.
+     */
+    constructor(options = {}) {
+        this.errorCount = 0;
+        this.maxRetries = options.maxRetries ?? 5;
+        this.resetInterval = options.resetInterval ?? 300000;
+        this.lastReset = Date.now();
+        this.authFolder = options.authFolder;
+        this.logger = options.logger ?? {};
+        this.onLimit = options.onLimit;
+    }
+    isBadMacError(error) {
+        return isBadMacError(error);
+    }
+    isSessionError(error) {
+        return isSessionError(error);
+    }
+    /**
+     * Delete per-peer Signal session files (`session-*`, `sender-key-*`) from `authFolder`. creds.json and
+     * app-state-sync-* are always kept; peers renegotiate sessions on the next message. Call it when the bot is
+     * idle or right before a restart — the running socket may still hold those sessions in memory.
+     * @returns {Promise<string[]>} names of the removed files
+     */
+    async clearProblematicSessionFiles({ dryRun = false } = {}) {
+        if (!this.authFolder) {
+            (this.logger.warn ?? noop).call(this.logger, '[bad-mac] authFolder not configured — nothing cleared');
+            return [];
+        }
+        const removed = [];
+        try {
+            for (const file of await fs.readdir(this.authFolder)) {
+                if (PRESERVE.some((p) => file.includes(p))) continue;
+                if (!(file.startsWith('session-') || file.includes('sender-key'))) continue;
+                const full = path.join(this.authFolder, file);
+                if (!(await fs.stat(full)).isFile()) continue;
+                if (!dryRun) await fs.unlink(full);
+                removed.push(file);
+            }
+        } catch (err) {
+            (this.logger.error ?? noop).call(this.logger, { err }, '[bad-mac] failed to clear session files');
+            return removed;
+        }
+        if (removed.length) (this.logger.warn ?? noop).call(this.logger, `[bad-mac] ${dryRun ? 'would remove' : 'removed'} ${removed.length} session file(s); creds preserved`);
+        return removed;
+    }
+    incrementErrorCount() {
+        if (Date.now() - this.lastReset > this.resetInterval) {
+            this.resetErrorCount();
+        }
+        this.errorCount++;
+    }
+    resetErrorCount() {
+        this.errorCount = 0;
+        this.lastReset = Date.now();
+    }
+    hasReachedLimit() {
+        return this.errorCount >= this.maxRetries;
+    }
+    /**
+     * @returns {boolean} true when it was a Bad MAC error (handled/counted — caller may ignore it);
+     *                    false when it was anything else (caller must rethrow).
+     */
+    handleError(error, context = 'unknown') {
+        if (!isBadMacError(error)) return false;
+        this.incrementErrorCount();
+        (this.logger.warn ?? noop).call(this.logger, `[bad-mac] ${context}: ${error.message} (${this.errorCount}/${this.maxRetries})`);
+        if (this.hasReachedLimit()) this.onLimit?.(this.getStats());
+        return true;
+    }
+    /** Wrap an async fn: Bad MAC is swallowed (returns null), every other error is rethrown. */
+    createSafeWrapper(fn, context) {
+        return async (...args) => {
+            try {
+                return await fn(...args);
+            } catch (error) {
+                if (this.handleError(error, context)) return null;
+                throw error;
+            }
+        };
+    }
+    getStats() {
+        return {
+            errorCount: this.errorCount,
+            maxRetries: this.maxRetries,
+            lastReset: new Date(this.lastReset).toISOString(),
+            timeUntilReset: Math.max(0, this.resetInterval - (Date.now() - this.lastReset))
+        };
+    }
+}

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

@@ -0,0 +1,5 @@
+export function captureEventStream(ev: any, filename: any): void;
+export function readAndEmitEventStream(filename: any, delayIntervalMs?: number): {
+    ev: any;
+    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 @vanzxysenpai/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,9 @@
+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): string;
+export function isAndroidBrowser(browser: any): boolean;

package/lib/Utils/browser-utils.js

@@ -0,0 +1,29 @@
+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
+};
+/** Vanz@Port (2.0.3) --- from Bail-master browser-utils: true when the browser tuple is an Android companion. */
+export const isAndroidBrowser = (browser) => typeof browser?.[1] === 'string' && browser[1].toUpperCase() === 'ANDROID';

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[]>;