@crysnovax/baileys 1.0.3

package/lib/Types/State.js

@@ -0,0 +1,12 @@
+import { Boom } from '@hapi/boom';
+export var SyncState;
+(function (SyncState) {
+    /** The socket is connecting, but we haven't received pending notifications yet. */
+    SyncState[SyncState["Connecting"] = 0] = "Connecting";
+    /** Pending notifications received. Buffering events until we decide whether to sync or not. */
+    SyncState[SyncState["AwaitingInitialSync"] = 1] = "AwaitingInitialSync";
+    /** The initial app state sync (history, etc.) is in progress. Buffering continues. */
+    SyncState[SyncState["Syncing"] = 2] = "Syncing";
+    /** Initial sync is complete, or was skipped. The socket is fully operational and events are processed in real-time. */
+    SyncState[SyncState["Online"] = 3] = "Online";
+})(SyncState || (SyncState = {}));

package/lib/Types/USync.js

@@ -0,0 +1 @@
+import { USyncUser } from '../WAUSync/index.js';

package/lib/Types/index.js

@@ -0,0 +1,25 @@
+export * from './Auth.js';
+export * from './GroupMetadata.js';
+export * from './Chat.js';
+export * from './Contact.js';
+export * from './State.js';
+export * from './Message.js';
+export * from './Socket.js';
+export * from './Events.js';
+export * from './Product.js';
+export * from './Call.js';
+export * from './Signal.js';
+export * from './Newsletter.js';
+export var DisconnectReason;
+(function (DisconnectReason) {
+    DisconnectReason[DisconnectReason["connectionClosed"] = 428] = "connectionClosed";
+    DisconnectReason[DisconnectReason["connectionLost"] = 408] = "connectionLost";
+    DisconnectReason[DisconnectReason["connectionReplaced"] = 440] = "connectionReplaced";
+    DisconnectReason[DisconnectReason["timedOut"] = 408] = "timedOut";
+    DisconnectReason[DisconnectReason["loggedOut"] = 401] = "loggedOut";
+    DisconnectReason[DisconnectReason["badSession"] = 500] = "badSession";
+    DisconnectReason[DisconnectReason["restartRequired"] = 515] = "restartRequired";
+    DisconnectReason[DisconnectReason["multideviceMismatch"] = 411] = "multideviceMismatch";
+    DisconnectReason[DisconnectReason["forbidden"] = 403] = "forbidden";
+    DisconnectReason[DisconnectReason["unavailableService"] = 503] = "unavailableService";
+})(DisconnectReason || (DisconnectReason = {}));

package/lib/Utils/auth-utils.js

@@ -0,0 +1,289 @@
+import NodeCache from '@cacheable/node-cache';
+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);
+                // Process pre-keys with validation
+                for (const type_ of types) {
+                    const type = type_;
+                    if (type === 'pre-key') {
+                        await preKeyManager.validateDeletions(data, type);
+                    }
+                }
+                // Write all data in parallel
+                await Promise.all(types.map(type => getQueue(type).add(async () => {
+                    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);
+            }
+        }
+    };
+};
+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/bot-planning-replay.js

@@ -0,0 +1,206 @@
+/**
+ * Lia@Changes [WIP]
+ * botPlanningReplay — Meta AI-style live reasoning feed.
+ *
+ * Sends a progress indicator with all steps IN_PROGRESS, then replays
+ * each step completing in real time via sequential edits — exactly how
+ * Meta AI's "Thinking…" bubble works. Final rich message lands clean
+ * with NO "edited" badge, using the same delete-resend flow from
+ * meta-compositing.
+ *
+ *   replayPlanning(sock, jid, steps, finalContent, options)
+ *
+ * Flow:
+ *   Send placeholder (all steps IN_PROGRESS)
+ *     → edit: step[0] → DONE  (stepDelayMs)
+ *     → edit: step[1] → DONE  (stepDelayMs)
+ *     → ...
+ *     → edit: step[n] → DONE  (finalPauseMs)
+ *     → delete placeholder
+ *     → send final rich message fresh
+ *
+ * If you use or copy this code, please credit @crysnovax/bailey.
+ */
+
+import { proto } from '../../WAProto/index.js';
+import {
+    buildCompositingPlaceholder,
+    buildProgressIndicator,
+    botMetadataSignature,
+    botMetadataCertificate,
+    PlanningStepStatus
+} from './meta-compositing.js';
+import { BOT_RENDERING_CONFIG_METADATA } from '../Defaults/index.js';
+import { delay } from './generics.js';
+
+// ─── Internal: rebuild the full botForwardedMessage with updated step statuses ───────────────
+const buildReplayFrame = (description, steps, placeholderText = '') => {
+    return buildCompositingPlaceholder({ description, steps, placeholderText });
+};
+
+// ─── Internal: send an in-place edit of the planning bubble with new step states ─────────────
+const editPlanningBubble = async (sock, jid, key, description, steps, placeholderText) => {
+    const updated = buildReplayFrame(description, steps, placeholderText);
+    // Use { edit: key, raw: true } — routes through protocolMessage.editedMessage
+    await sock.sendMessage(jid, {
+        raw: true,
+        edit: key,
+        ...updated
+    });
+};
+
+/**
+ * replayPlanning — full live planning animation.
+ *
+ * @param {object}   sock                        - Baileys socket
+ * @param {string}   jid                         - Destination JID
+ * @param {Array}    steps                        - Array of step definitions:
+ *                                                  { title, body?, isReasoning?, isEnhancedSearch? }
+ *                                                  Status is managed automatically — do NOT pass status here.
+ * @param {object}   finalContent                 - Rich content for the final message.
+ *                                                  Same as sendMessage: { code, table, text, richResponse… }
+ * @param {object}   [options]
+ * @param {string}   [options.description]        - Top label while thinking. Default: 'Thinking…'
+ * @param {string}   [options.placeholderText]    - Body text shown in bubble while loading.
+ * @param {number}   [options.stepDelayMs]        - Ms between each step completing. Default: 900
+ * @param {number}   [options.finalPauseMs]       - Ms to hold after all steps done before cleanup. Default: 600
+ * @param {boolean}  [options.abortOnDisconnect]  - Stop replay loop if socket closes. Default: true
+ * @param {object}   [options.sendOptions]        - Extra options for final sendMessage call.
+ * @returns {Promise<object>} - The final sent WAMessage
+ */
+export const replayPlanning = async (sock, jid, steps, finalContent, {
+    description = 'Thinking…',
+    placeholderText = '',
+    stepDelayMs = 900,
+    finalPauseMs = 600,
+    abortOnDisconnect = true,
+    sendOptions = {}
+} = {}) => {
+    if (!steps?.length) {
+        throw new Error('replayPlanning: steps array must have at least one entry');
+    }
+
+    // ── Track abort state if socket disconnects mid-replay ───────────────────
+    let aborted = false;
+    const onClose = () => { aborted = true; };
+    if (abortOnDisconnect) {
+        sock.ev?.once?.('connection.update', ({ connection }) => {
+            if (connection === 'close') onClose();
+        });
+    }
+
+    // ── 1. Build initial state — all steps IN_PROGRESS ───────────────────────
+    const initialSteps = steps.map(step => ({
+        ...step,
+        status: PlanningStepStatus.IN_PROGRESS
+    }));
+
+    const placeholder = await sock.sendMessage(jid, {
+        raw: true,
+        ...buildReplayFrame(description, initialSteps, placeholderText)
+    });
+
+    const key = placeholder?.key;
+
+    // ── 2. Replay loop — flip each step to DONE sequentially ─────────────────
+    try {
+        const currentSteps = [...initialSteps];
+
+        for (let i = 0; i < currentSteps.length; i++) {
+            if (aborted) break;
+
+            await delay(stepDelayMs);
+            if (aborted) break;
+
+            // Flip this step to DONE
+            currentSteps[i] = {
+                ...currentSteps[i],
+                status: PlanningStepStatus.DONE
+            };
+
+            if (key) {
+                await editPlanningBubble(
+                    sock, jid, key,
+                    description, currentSteps, placeholderText
+                );
+            }
+        }
+
+        // ── 3. Hold with all steps DONE so user sees completion ──────────────
+        if (!aborted && finalPauseMs > 0) {
+            await delay(finalPauseMs);
+        }
+
+        // ── 4. Delete placeholder silently ───────────────────────────────────
+        if (key && !aborted) {
+            await sock.sendMessage(jid, { delete: key });
+        }
+    } catch (err) {
+        // Non-fatal — always attempt final send even if replay failed mid-way
+        try {
+            if (key) await sock.sendMessage(jid, { delete: key });
+        } catch (_) {}
+    }
+
+    // ── 5. Send the final rich message as a brand-new message — no edited badge ──
+    return sock.sendMessage(jid, finalContent, sendOptions);
+};
+
+/**
+ * replayPlanningOnly — same animation but WITHOUT sending a final message.
+ * Use when you want to control the final send yourself.
+ *
+ * Returns { key } of the placeholder (already deleted on completion).
+ *
+ * @param {object} sock
+ * @param {string} jid
+ * @param {Array}  steps
+ * @param {object} [options]   - Same options as replayPlanning minus sendOptions
+ * @returns {Promise<void>}
+ */
+export const replayPlanningOnly = async (sock, jid, steps, options = {}) => {
+    return replayPlanning(sock, jid, steps, null, {
+        ...options,
+        _skipFinalSend: true
+    });
+};
+
+/**
+ * buildReasoningSteps — convenience builder for steps with isReasoning: true.
+ * Renders with the "reasoning" visual treatment in the Meta bubble.
+ *
+ * @example
+ * buildReasoningSteps(['Analyzing the problem…', 'Checking edge cases…'])
+ */
+export const buildReasoningSteps = (titles) =>
+    titles.map(title => ({ title, isReasoning: true }));
+
+/**
+ * buildSearchSteps — convenience builder for steps with isEnhancedSearch: true.
+ * Renders with the "enhanced search" visual treatment.
+ *
+ * @example
+ * buildSearchSteps(['Searching the web…', 'Reading top results…'])
+ */
+export const buildSearchSteps = (titles) =>
+    titles.map(title => ({ title, isEnhancedSearch: true }));
+
+/**
+ * mixedSteps — build a steps array mixing reasoning + search + plain steps.
+ * Pass an array of { title, type? } where type is 'reasoning' | 'search' | undefined.
+ *
+ * @example
+ * mixedSteps([
+ *   { title: 'Understanding your question…', type: 'reasoning' },
+ *   { title: 'Searching for data…',          type: 'search' },
+ *   { title: 'Writing the answer…' }
+ * ])
+ */
+export const mixedSteps = (defs) =>
+    defs.map(({ title, body, type }) => ({
+        title,
+        ...(body ? { body } : {}),
+        ...(type === 'reasoning' ? { isReasoning: true } : {}),
+        ...(type === 'search' ? { isEnhancedSearch: true } : {})
+    }));
+

package/lib/Utils/browser-utils.js

@@ -0,0 +1,28 @@
+import { platform, release } from 'node: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'],
+    android: browser => [browser, 'Android', ''],
+    /** 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
+};