@japofc/baileys 2.1.0

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

@@ -0,0 +1,57 @@
+/**
+ * Adds caching capability to a SignalKeyStore
+ * @param store the store to add caching to
+ * @param logger to log trace events
+ * @param _cache cache store to use
+ */
+export function makeCacheableSignalKeyStore(store: any, logger: any, _cache: any): {
+    get(type: any, ids: any): Promise<any>;
+    set(data: any): Promise<any>;
+    clear(): Promise<void>;
+};
+export function addTransactionCapability(state: any, logger: any, { maxCommitRetries, delayBetweenTriesMs }: {
+    maxCommitRetries: any;
+    delayBetweenTriesMs: any;
+}): {
+    get: (type: any, ids: any) => Promise<any>;
+    set: (data: any) => Promise<void>;
+    isInTransaction: () => boolean;
+    transaction: (work: any, key: any) => Promise<any>;
+};
+export function assertMeId(creds: any): any;
+export function initAuthCreds(): {
+    noiseKey: {
+        private: any;
+        public: any;
+    };
+    pairingEphemeralKeyPair: {
+        private: any;
+        public: any;
+    };
+    signedIdentityKey: {
+        private: any;
+        public: any;
+    };
+    signedPreKey: {
+        keyPair: {
+            private: any;
+            public: any;
+        };
+        signature: any;
+        keyId: any;
+    };
+    registrationId: number;
+    advSecretKey: any;
+    processedHistoryMessages: never[];
+    nextPreKeyId: number;
+    firstUnuploadedPreKeyId: number;
+    accountSyncCounter: number;
+    accountSettings: {
+        unarchiveChats: boolean;
+    };
+    registered: boolean;
+    pairingCode: undefined;
+    lastPropHash: undefined;
+    routingInfo: undefined;
+    additionalData: undefined;
+};

package/lib/Utils/auth-utils.js

@@ -0,0 +1,306 @@
+import NodeCache from '@cacheable/node-cache';
+import { Boom } from '@hapi/boom';
+import { AsyncLocalStorage } from 'async_hooks';
+import { Mutex } from 'async-mutex';
+import { randomBytes } from 'crypto';
+import PQueue from 'p-queue';
+import { DEFAULT_CACHE_TTLS } from '../Defaults/index.js';
+import { Curve, signedKeyPair } from './crypto.js';
+import { delay, generateRegistrationId } from './generics.js';
+import { PreKeyManager } from './pre-key-manager.js';
+/**
+ * Adds caching capability to a SignalKeyStore
+ * @param store the store to add caching to
+ * @param logger to log trace events
+ * @param _cache cache store to use
+ */
+export function makeCacheableSignalKeyStore(store, logger, _cache) {
+    const cache = _cache ||
+        new NodeCache({
+            stdTTL: DEFAULT_CACHE_TTLS.SIGNAL_STORE, // 5 minutes
+            useClones: false,
+            deleteOnExpire: true
+        });
+    // Mutex for protecting cache operations
+    const cacheMutex = new Mutex();
+    function getUniqueId(type, id) {
+        return `${type}.${id}`;
+    }
+    return {
+        async get(type, ids) {
+            return cacheMutex.runExclusive(async () => {
+                const data = {};
+                const idsToFetch = [];
+                for (const id of ids) {
+                    const item = (await cache.get(getUniqueId(type, id)));
+                    if (typeof item !== 'undefined') {
+                        data[id] = item;
+                    }
+                    else {
+                        idsToFetch.push(id);
+                    }
+                }
+                if (idsToFetch.length) {
+                    logger?.trace({ items: idsToFetch.length }, 'loading from store');
+                    const fetched = await store.get(type, idsToFetch);
+                    for (const id of idsToFetch) {
+                        const item = fetched[id];
+                        if (item) {
+                            data[id] = item;
+                            // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+                            await cache.set(getUniqueId(type, id), item);
+                        }
+                    }
+                }
+                return data;
+            });
+        },
+        async set(data) {
+            return cacheMutex.runExclusive(async () => {
+                let keys = 0;
+                for (const type in data) {
+                    for (const id in data[type]) {
+                        await cache.set(getUniqueId(type, id), data[type][id]);
+                        keys += 1;
+                    }
+                }
+                logger?.trace({ keys }, 'updated cache');
+                await store.set(data);
+            });
+        },
+        async clear() {
+            await cache.flushAll();
+            await store.clear?.();
+        }
+    };
+}
+/**
+ * Adds DB-like transaction capability to the SignalKeyStore
+ * Uses AsyncLocalStorage for automatic context management
+ * @param state the key store to apply this capability to
+ * @param logger logger to log events
+ * @returns SignalKeyStore with transaction capability
+ */
+export const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetweenTriesMs }) => {
+    const txStorage = new AsyncLocalStorage();
+    // Queues for concurrency control (keyed by signal data type - bounded set)
+    const keyQueues = new Map();
+    // Transaction mutexes with reference counting for cleanup
+    const txMutexes = new Map();
+    const txMutexRefCounts = new Map();
+    // Pre-key manager for specialized operations
+    const preKeyManager = new PreKeyManager(state, logger);
+    /**
+     * Get or create a queue for a specific key type
+     */
+    function getQueue(key) {
+        if (!keyQueues.has(key)) {
+            keyQueues.set(key, new PQueue({ concurrency: 1 }));
+        }
+        return keyQueues.get(key);
+    }
+    /**
+     * Get or create a transaction mutex
+     */
+    function getTxMutex(key) {
+        if (!txMutexes.has(key)) {
+            txMutexes.set(key, new Mutex());
+            txMutexRefCounts.set(key, 0);
+        }
+        return txMutexes.get(key);
+    }
+    /**
+     * Acquire a reference to a transaction mutex
+     */
+    function acquireTxMutexRef(key) {
+        const count = txMutexRefCounts.get(key) ?? 0;
+        txMutexRefCounts.set(key, count + 1);
+    }
+    /**
+     * Release a reference to a transaction mutex and cleanup if no longer needed
+     */
+    function releaseTxMutexRef(key) {
+        const count = (txMutexRefCounts.get(key) ?? 1) - 1;
+        txMutexRefCounts.set(key, count);
+        // Cleanup if no more references and mutex is not locked
+        if (count <= 0) {
+            const mutex = txMutexes.get(key);
+            if (mutex && !mutex.isLocked()) {
+                txMutexes.delete(key);
+                txMutexRefCounts.delete(key);
+            }
+        }
+    }
+    /**
+     * Check if currently in a transaction
+     */
+    function isInTransaction() {
+        return !!txStorage.getStore();
+    }
+    /**
+     * Commit transaction with retries
+     */
+    async function commitWithRetry(mutations) {
+        if (Object.keys(mutations).length === 0) {
+            logger.trace('no mutations in transaction');
+            return;
+        }
+        logger.trace('committing transaction');
+        for (let attempt = 0; attempt < maxCommitRetries; attempt++) {
+            try {
+                await state.set(mutations);
+                logger.trace({ mutationCount: Object.keys(mutations).length }, 'committed transaction');
+                return;
+            }
+            catch (error) {
+                const retriesLeft = maxCommitRetries - attempt - 1;
+                logger.warn(`failed to commit mutations, retries left=${retriesLeft}`);
+                if (retriesLeft === 0) {
+                    throw error;
+                }
+                await delay(delayBetweenTriesMs);
+            }
+        }
+    }
+    return {
+        get: async (type, ids) => {
+            const ctx = txStorage.getStore();
+            if (!ctx) {
+                // No transaction - direct read without exclusive lock for concurrency
+                return state.get(type, ids);
+            }
+            // In transaction - check cache first
+            const cached = ctx.cache[type] || {};
+            const missing = ids.filter(id => !(id in cached));
+            if (missing.length > 0) {
+                ctx.dbQueries++;
+                logger.trace({ type, count: missing.length }, 'fetching missing keys in transaction');
+                const fetched = await getTxMutex(type).runExclusive(() => state.get(type, missing));
+                // Update cache
+                ctx.cache[type] = ctx.cache[type] || {};
+                Object.assign(ctx.cache[type], fetched);
+            }
+            // Return requested ids from cache
+            const result = {};
+            for (const id of ids) {
+                const value = ctx.cache[type]?.[id];
+                if (value !== undefined && value !== null) {
+                    result[id] = value;
+                }
+            }
+            return result;
+        },
+        set: async (data) => {
+            const ctx = txStorage.getStore();
+            if (!ctx) {
+                // No transaction - direct write with queue protection
+                const types = Object.keys(data);
+                // JAP@Fix (bug 66): validateDeletions() used to run *before* this,
+                // serialized only against PreKeyManager's own internal queue —
+                // a separate PQueue instance from getQueue(type) below, both keyed
+                // 'pre-key' but never synchronized with each other. Two concurrent
+                // set() calls for pre-key data could validate against a store state
+                // that a still-pending write from the other call hadn't applied yet,
+                // letting a stale deletion go through or a just-deleted key get
+                // resurrected by data racing back in. Validation now happens inside
+                // the same per-type queue job as the write, so it's ordered against
+                // any other set() for that type instead of racing it.
+                await Promise.all(types.map(type => getQueue(type).add(async () => {
+                    if (type === 'pre-key') {
+                        await preKeyManager.validateDeletions(data, type);
+                    }
+                    const typeData = { [type]: data[type] };
+                    await state.set(typeData);
+                })));
+                return;
+            }
+            // In transaction - update cache and mutations
+            logger.trace({ types: Object.keys(data) }, 'caching in transaction');
+            for (const key_ in data) {
+                const key = key_;
+                // Ensure structures exist
+                ctx.cache[key] = ctx.cache[key] || {};
+                ctx.mutations[key] = ctx.mutations[key] || {};
+                // Special handling for pre-keys
+                if (key === 'pre-key') {
+                    await preKeyManager.processOperations(data, key, ctx.cache, ctx.mutations, true);
+                }
+                else {
+                    // Normal key types
+                    Object.assign(ctx.cache[key], data[key]);
+                    Object.assign(ctx.mutations[key], data[key]);
+                }
+            }
+        },
+        isInTransaction,
+        transaction: async (work, key) => {
+            const existing = txStorage.getStore();
+            // Nested transaction - reuse existing context
+            if (existing) {
+                logger.trace('reusing existing transaction context');
+                return work();
+            }
+            // New transaction - acquire mutex and create context
+            const mutex = getTxMutex(key);
+            acquireTxMutexRef(key);
+            try {
+                return await mutex.runExclusive(async () => {
+                    const ctx = {
+                        cache: {},
+                        mutations: {},
+                        dbQueries: 0
+                    };
+                    logger.trace('entering transaction');
+                    try {
+                        const result = await txStorage.run(ctx, work);
+                        // Commit mutations
+                        await commitWithRetry(ctx.mutations);
+                        logger.trace({ dbQueries: ctx.dbQueries }, 'transaction completed');
+                        return result;
+                    }
+                    catch (error) {
+                        logger.error({ error }, 'transaction failed, rolling back');
+                        throw error;
+                    }
+                });
+            }
+            finally {
+                releaseTxMutexRef(key);
+            }
+        }
+    };
+};
+/**
+ * Returns the authenticated user's JID, or throws a Boom-401 if creds are not yet authenticated.
+ * Use this anywhere we'd otherwise reach for `creds.me!.id` to fail fast with a descriptive error.
+ */
+export const assertMeId = (creds) => {
+    const id = creds.me?.id;
+    if (!id) {
+        throw new Boom('Cannot proceed: socket is not authenticated yet (creds.me.id is missing)', { statusCode: 401 });
+    }
+    return id;
+};
+export const initAuthCreds = () => {
+    const identityKey = Curve.generateKeyPair();
+    return {
+        noiseKey: Curve.generateKeyPair(),
+        pairingEphemeralKeyPair: Curve.generateKeyPair(),
+        signedIdentityKey: identityKey,
+        signedPreKey: signedKeyPair(identityKey, 1),
+        registrationId: generateRegistrationId(),
+        advSecretKey: randomBytes(32).toString('base64'),
+        processedHistoryMessages: [],
+        nextPreKeyId: 1,
+        firstUnuploadedPreKeyId: 1,
+        accountSyncCounter: 0,
+        accountSettings: {
+            unarchiveChats: false
+        },
+        registered: false,
+        pairingCode: undefined,
+        lastPropHash: undefined,
+        routingInfo: undefined,
+        additionalData: undefined
+    };
+};

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,157 @@
+// JAP@Add --- part of the @japofc/baileys utils (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);
+                // JAP@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);

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 @@
+// JAP@Utils --- durable event stream (append-only JSONL log + replay).
+// Uses this package'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,27 @@
+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
+};