@vanzxysenpai/baileys 0.0.0-stage → 0.0.2

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

@@ -0,0 +1,59 @@
+/**
+ * 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>;
+    list(type: any): AsyncGenerator<any, void, any>;
+    listIds(type: any): AsyncGenerator<any, void, any>;
+    clear(): Promise<void>;
+};
+export function addTransactionCapability(state: any, logger: any, opts1: { [key: string]: any; 
+    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: any[];
+    nextPreKeyId: number;
+    firstUnuploadedPreKeyId: number;
+    accountSyncCounter: number;
+    accountSettings: {
+        unarchiveChats: boolean;
+    };
+    registered: boolean;
+    pairingCode: any;
+    lastPropHash: any;
+    routingInfo: any;
+    additionalData: any;
+};

package/lib/Utils/auth-utils.js

@@ -0,0 +1,326 @@
+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 *list(type) {
+            if (typeof store.list !== 'function')
+                throw new Error('SignalKeyStore.list is not implemented by the wrapped store');
+            yield* store.list(type);
+        },
+        async *listIds(type) {
+            if (typeof store.listIds === 'function') {
+                yield* store.listIds(type);
+                return;
+            }
+            if (typeof store.list === 'function') {
+                for await (const [id] of store.list(type))
+                    yield id;
+                return;
+            }
+            throw new Error('SignalKeyStore.listIds is not implemented by the wrapped store');
+        },
+        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();
+    }
+    /**
+     * acquire every per-type queue in `types` — held
+     * simultaneously for the duration of `fn()` — via nested PQueue.add()
+     * calls in a fixed sorted order (prevents deadlock between overlapping
+     * commits sharing a type; a job never completes, and so never releases
+     * its queue slot, until every nested queue below it has too).
+     */
+    function withTypeQueues(types, fn) {
+        const sorted = [...types].sort();
+        const run = (idx) => (idx >= sorted.length ? fn() : getQueue(sorted[idx]).add(() => run(idx + 1)));
+        return run(0);
+    }
+    /**
+     * Commit transaction with retries
+     */
+    async function commitWithRetry(mutations) {
+        const types = Object.keys(mutations);
+        if (types.length === 0) {
+            logger.trace('no mutations in transaction');
+            return;
+        }
+        logger.trace('committing transaction');
+        for (let attempt = 0; attempt < maxCommitRetries; attempt++) {
+            try {
+                await withTypeQueues(types, () => 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);
+                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-reconnect.d.ts

@@ -0,0 +1,8 @@
+export function autoReconnect(socketFactory: any, options?: {}): {
+    start: () => Promise<any>;
+    stop: () => Promise<void>;
+    /** The live socket (replaced on every reconnect); null before start(). */
+    readonly socket: any;
+    /** Consecutive failed attempts since the last successful open. */
+    readonly attempts: number;
+};

package/lib/Utils/auto-reconnect.js

@@ -0,0 +1,204 @@
+// Vanz@Port (v2.0.3) --- ported from @japofc/baileys 2.4.1 (MIT, author JAPofc / J.AP), lib/Utils/auto-reconnect.js. See NOTICE.md.
+/**
+ * JAP@Add --- drop-in auto-reconnect for direct makeWASocket users.
+ *
+ * The Framework Bot has always had exponential-backoff reconnect built in;
+ * plain-socket users had to hand-roll the same connection.update dance every
+ * project (the #1 beginner Baileys question). This wraps it once, correctly:
+ *
+ *   const manager = autoReconnect(() => makeWASocketAuto({ auth: state }), {
+ *       onSocket: (sock) => sock.ev.on('messages.upsert', handler),
+ *   });
+ *   await manager.start();
+ *
+ * - exponential backoff with jitter (1s base -> 30s cap)
+ * - never reconnects on DisconnectReason.loggedOut (session is dead; caller
+ *   gets onLoggedOut to clean up creds)
+ * - restartRequired (post-pairing) reconnects immediately, not backed off
+ * - stop() cancels timers and closes the live socket
+ * - factory may be async (works with makeWASocketAuto) or sync
+ *
+ * @author J.AP
+ */
+import { DisconnectReason } from '../Types/index.js';
+import { isFatalDisconnect, mapDisconnectReason } from './disconnect-reason.js';
+import defaultLogger from './logger.js';
+
+export const autoReconnect = (socketFactory, options = {}) => {
+    const {
+        onSocket,
+        onOpen,
+        onLoggedOut,
+        onFatal,
+        maxAttempts = Infinity,
+        baseDelayMs = 1000,
+        maxDelayMs = 30000,
+        jitter = 0.25,
+        logger = defaultLogger.child({ module: 'auto-reconnect' }),
+    } = options;
+
+    let sock = null;
+    let attempts = 0;
+    let timer = null;
+    let stopped = false;
+    let started = false;
+
+    const delayFor = (attempt) => {
+        const exp = Math.min(maxDelayMs, baseDelayMs * Math.pow(2, attempt - 1));
+        const wiggle = exp * jitter * (Math.random() * 2 - 1);
+        return Math.max(0, Math.round(exp + wiggle));
+    };
+
+    const scheduleRestart = (delay) => {
+        if (stopped || timer) {
+            return; // never two pending reconnects at once
+        }
+        timer = setTimeout(() => {
+            timer = null;
+            connect().catch((err) => logger.error({ err }, 'reconnect attempt failed'));
+        }, delay);
+    };
+
+    const connect = async () => {
+        if (stopped) {
+            return null;
+        }
+        // JAP@Fix (lifecycle): best-effort cleanup of the previous socket so a
+        // half-open ws never lingers next to its replacement.
+        const previous = sock;
+        if (previous) {
+            try {
+                await previous.end?.();
+            }
+            catch { /* already dead */ }
+        }
+        let current;
+        try {
+            current = await socketFactory();
+        }
+        catch (err) {
+            // JAP@Fix (lifecycle): a throwing factory (e.g. makeWASocketAuto's
+            // version fetch while offline) used to kill the chain permanently.
+            // Treat it like a failed connection: back off and try again.
+            attempts += 1;
+            if (attempts > maxAttempts) {
+                logger.error({ err, attempts: attempts - 1 }, 'socket factory failed and max attempts reached — giving up');
+                return null;
+            }
+            const delay = delayFor(attempts);
+            logger.warn({ err, attempt: attempts, delay }, 'socket factory failed — retrying');
+            scheduleRestart(delay);
+            return null;
+        }
+        sock = current;
+        // JAP@Fix (race): a 'close' may be emitted more than once by the same
+        // socket, and a stale (already-replaced) socket can emit late events.
+        // Without these guards a double-close schedules two parallel reconnect
+        // chains, and every stale close spawns a ghost socket.
+        let closeHandled = false;
+        try {
+            onSocket?.(current);
+        }
+        catch (err) {
+            logger.warn({ err }, 'onSocket handler threw');
+        }
+        current.ev.on('connection.update', (update) => {
+            if (sock !== current) {
+                return; // stale socket — a newer one has replaced it
+            }
+            const { connection, lastDisconnect } = update;
+            if (connection === 'open') {
+                attempts = 0;
+                try {
+                    onOpen?.(current);
+                }
+                catch (err) {
+                    logger.warn({ err }, 'onOpen handler threw');
+                }
+                return;
+            }
+            if (connection !== 'close' || stopped || closeHandled) {
+                return;
+            }
+            closeHandled = true;
+            const statusCode = lastDisconnect?.error?.output?.statusCode;
+            if (statusCode === DisconnectReason.loggedOut) {
+                logger.info('session logged out — not reconnecting');
+                try {
+                    onLoggedOut?.(lastDisconnect?.error);
+                }
+                catch (err) {
+                    logger.warn({ err }, 'onLoggedOut handler threw');
+                }
+                return;
+            }
+            if (isFatalDisconnect(mapDisconnectReason(statusCode))) {
+                logger.warn({ statusCode }, 'fatal disconnect — not reconnecting');
+                try {
+                    onFatal?.(lastDisconnect?.error, statusCode);
+                }
+                catch (err) {
+                    logger.warn({ err }, 'onFatal handler threw');
+                }
+                return;
+            }
+            attempts += 1;
+            if (attempts > maxAttempts) {
+                logger.warn({ attempts: attempts - 1 }, 'max reconnect attempts reached — giving up');
+                return;
+            }
+            // JAP@Fix (lifecycle): restartRequired always reconnected with
+            // delay 0. Correct after pairing (single event), but when the
+            // server answers restartRequired on EVERY connect it becomes a
+            // tight spin loop (repro: 165 sockets in 200ms). Only the FIRST
+            // consecutive restartRequired is immediate; repeats back off.
+            const immediate = statusCode === DisconnectReason.restartRequired && attempts === 1;
+            const delay = immediate ? 0 : delayFor(attempts);
+            logger.info({ attempt: attempts, delay, statusCode }, 'scheduling reconnect');
+            scheduleRestart(delay);
+        });
+        return current;
+    };
+
+    // JAP@Fix (lifecycle): start() twice used to run two parallel reconnect
+    // chains forever (repro: 2 sockets immediately, 3 after one close storm).
+    // The public start() is now idempotent; connect() is the internal step.
+    const start = async () => {
+        if (started && !stopped) {
+            logger.warn('start() called while already running — returning the live socket');
+            return sock;
+        }
+        // JAP@Fix (lifecycle): start() after stop() used to return the dead
+        // socket silently (started stayed true, stopped stayed true, connect()
+        // no-oped). A stopped manager can now be restarted cleanly.
+        stopped = false;
+        started = true;
+        attempts = 0;
+        return connect();
+    };
+
+    const stop = async () => {
+        stopped = true;
+        if (timer) {
+            clearTimeout(timer);
+            timer = null;
+        }
+        try {
+            await sock?.end?.();
+        }
+        catch { /* socket may already be dead */ }
+    };
+
+    return {
+        start,
+        stop,
+        /** The live socket (replaced on every reconnect); null before start(). */
+        get socket() {
+            return sock;
+        },
+        /** Consecutive failed attempts since the last successful open. */
+        get attempts() {
+            return attempts;
+        },
+    };
+};

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

@@ -0,0 +1,35 @@
+export class AutoReplyHandler {
+    constructor(sendMessage: any, sendPresence: any, options?: {});
+    rules: Map<any, any>;
+    cooldowns: Map<any, any>;
+    globalCooldown: Map<any, any>;
+    sendMessage: any;
+    sendPresence: any;
+    options: {
+        globalCooldown: any;
+        simulateTyping: any;
+        typingDuration: any;
+        multiMatch: any;
+        onReply: any;
+        onError: any;
+    };
+    generateId(): string;
+    /** Add a rule keyed by keywords, a regex pattern, or an exact-match string. */
+    addRule(rule: any): any;
+    removeRule(id: any): boolean;
+    getRules(): any[];
+    getRule(id: any): any;
+    setRuleActive(id: any, active: any): boolean;
+    clearRules(): void;
+    checkCooldown(ruleId: any, jid: any): boolean;
+    checkGlobalCooldown(jid: any): boolean;
+    setCooldown(ruleId: any, jid: any, cooldown: any): void;
+    matchRule(text: any, rule: any): any;
+    isJidAllowed(jid: any, rule: any): boolean;
+    /**
+     * Feed each incoming message through here (e.g. from `messages.upsert`).
+     * Returns true if a rule matched and a reply was sent.
+     */
+    processMessage(message: any): Promise<boolean>;
+}
+export function createAutoReply(sendMessage: any, sendPresence: any, options: any): AutoReplyHandler;