kage-baileys 3.0.6 → 3.2.3

package/lib/Utils/auth-utils.js

@@ -197,3 +197,706 @@ const initAuthCreds = () => {
     };
 };
 exports.initAuthCreds = initAuthCreds;
+
+// Kage: compatibilidad de API.
+const __kageModule57 = (() => {
+const module = { exports: {} }; const exports = module.exports;
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const { randomBytes } = require("crypto")
+const { default: PQueue } = require("p-queue") 
+const { default: NodeCache } = require("@cacheable/node-cache")
+const { DEFAULT_CACHE_TTLS } = require("../Defaults/constants")
+const { AsyncLocalStorage } = require("async_hooks")
+const { LRUCache } = require("lru-cache") 
+const { Mutex }= require("async-mutex") 
+const {
+  Curve, 
+  signedKeyPair
+} = require("./crypto")
+const {
+  delay, 
+  generateRegistrationId
+} = require("./generics")
+const { PreKeyManager } = require("./pre-key-manager") 
+
+/**
+ * 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
+ */
+function makeCacheableSignalKeyStore(store, logger, _cache) {
+    const cache = _cache || new NodeCache({
+        stdTTL: DEFAULT_CACHE_TTLS.SIGNAL_STORE,
+        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 = 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
+                            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?.call(store)
+        }
+    }
+}
+
+/**
+ * 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
+ */
+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)
+            }
+        }
+    }
+}
+
+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
+    }
+}
+
+module.exports = {
+  makeCacheableSignalKeyStore, 
+  addTransactionCapability, 
+  initAuthCreds
+}
+return module.exports;
+})();
+for (const key of Object.keys(__kageModule57)) {
+ if (key !== '__esModule' && !Object.prototype.hasOwnProperty.call(exports,key)) Object.defineProperty(exports,key,{enumerable:true,configurable:true,get:()=>__kageModule57[key]});
+}
+
+// Kage: funciones avanzadas.
+const __kageModule161 = (() => {
+const module = { exports: {} }; const exports = module.exports;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initAuthCreds = exports.assertMeId = exports.addTransactionCapability = void 0;
+exports.makeCacheableSignalKeyStore = makeCacheableSignalKeyStore;
+const node_async_hooks_1 = require("node:async_hooks");
+const node_crypto_1 = require("node:crypto");
+const index_js_1 = require("../Addon/index.js");
+const index_js_2 = require("../Defaults/index.js");
+const crypto_js_1 = require("./crypto.js");
+const generics_js_1 = require("./generics.js");
+const pre_key_manager_js_1 = require("./pre-key-manager.js");
+// One instance per process: a per-socket AsyncLocalStorage leaks the heap under Node's legacy
+// async-context propagation, where every live instance tags every pending async resource. The
+// value is keyed by store token so a store only ever sees its own context, even when another
+// wrapped store runs inside its transaction.
+const txStorage = new node_async_hooks_1.AsyncLocalStorage();
+/**
+ * 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
+ */
+function makeCacheableSignalKeyStore(store, logger, _cache) {
+    const cache = _cache ||
+        (0, index_js_1.createCache)({
+            ttl: index_js_2.DEFAULT_CACHE_TTLS.SIGNAL_STORE // 5 minutes
+        });
+    // Mutex for protecting cache operations
+    const cacheMutex = (0, index_js_1.createMutex)();
+    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
+ */
+const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetweenTriesMs }) => {
+    // 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 pre_key_manager_js_1.PreKeyManager(state, logger);
+    /**
+     * Get or create a queue for a specific key type
+     */
+    function getQueue(key) {
+        if (!keyQueues.has(key)) {
+            keyQueues.set(key, (0, index_js_1.createQueue)(1));
+        }
+        return keyQueues.get(key);
+    }
+    /**
+     * Get or create a transaction mutex
+     */
+    function getTxMutex(key) {
+        if (!txMutexes.has(key)) {
+            txMutexes.set(key, (0, index_js_1.createMutex)());
+            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 (0, generics_js_1.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);
+            }
+        },
+        disposeTransactionStorage: () => {
+            // The first txStorage.run() enables the storage, which registers it in a
+            // module-global list inside node:async_hooks holding a STRONG reference.
+            // On Node < 24 every enabled storage also stamps one symbol-keyed property
+            // onto every async resource created anywhere in the process, so the cost of
+            // never disabling grows with sockets-ever-created x live async resources
+            // (observed: 1.9GB of a 2.1GB heap after 25h at ~250 concurrent sockets).
+            // Only .disable() releases it - GC alone never collects an enabled storage,
+            // on any Node version.
+            try {
+                txStorage.disable();
+            }
+            catch (err) {
+                logger.warn({ err }, 'failed to disable transaction storage');
+            }
+        }
+    };
+};
+exports.addTransactionCapability = addTransactionCapability;
+/**
+ * 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.
+ */
+const assertMeId = (creds) => {
+    const id = creds.me?.id;
+    if (!id) {
+        throw new index_js_1.HttpError('Cannot proceed: socket is not authenticated yet (creds.me.id is missing)', { statusCode: 401 });
+    }
+    return id;
+};
+exports.assertMeId = assertMeId;
+const initAuthCreds = () => {
+    const identityKey = crypto_js_1.Curve.generateKeyPair();
+    return {
+        noiseKey: crypto_js_1.Curve.generateKeyPair(),
+        pairingEphemeralKeyPair: crypto_js_1.Curve.generateKeyPair(),
+        signedIdentityKey: identityKey,
+        signedPreKey: (0, crypto_js_1.signedKeyPair)(identityKey, 1),
+        registrationId: (0, generics_js_1.generateRegistrationId)(),
+        advSecretKey: (0, node_crypto_1.randomBytes)(32).toString('base64'),
+        processedHistoryMessages: [],
+        nextPreKeyId: 1,
+        firstUnuploadedPreKeyId: 1,
+        accountSyncCounter: 0,
+        accountSettings: {
+            unarchiveChats: false
+        },
+        registered: false,
+        pairingCode: undefined,
+        lastPropHash: undefined,
+        routingInfo: undefined,
+        additionalData: undefined
+    };
+};
+exports.initAuthCreds = initAuthCreds;
+
+return module.exports;
+})();
+for (const key of Object.keys(__kageModule161)) {
+ if (key !== '__esModule' && !Object.prototype.hasOwnProperty.call(exports,key)) Object.defineProperty(exports,key,{enumerable:true,configurable:true,get:()=>__kageModule161[key]});
+}
+Object.defineProperty(exports, Symbol.for('kage.advanced'), {value:__kageModule161, configurable:true});