sauruspro-bail 0.0.0-stage → 5.0.1

package/lib/Utils/airich-registry.js

@@ -0,0 +1,3 @@
+// Registry kecil untuk memutus siklus import MessageBuilder <-> extras/html-app/metaai.
+// MessageBuilder mengisi `AIRich` saat dimuat; modul lain membacanya secara lazy.
+export const airichRegistry = {};

package/lib/Utils/auth-utils.js

@@ -0,0 +1,302 @@
+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);
+                // 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);
+            }
+        }
+    };
+};
+/**
+ * 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
+    };
+};
+//# sourceMappingURL=auth-utils.js.map

package/lib/Utils/baileys-event-stream.js

@@ -0,0 +1,58 @@
+import events_1_d from 'events';
+import * as fs_1 from 'fs';
+import * as promises_1 from 'fs/promises';
+import * as readline_1 from 'readline';
+import * as generics_1 from './generics.js';
+import * as make_mutex_1 from './make-mutex.js';
+const events_1 = { default: events_1_d };
+/**
+ * Captures events from a baileys event emitter & stores them in a file
+ * @param ev The event emitter to read events from
+ * @param filename File to save to
+ */
+const captureEventStream = (ev, filename) => {
+    const oldEmit = ev.emit;
+    // write mutex so data is appended in order
+    const writeMutex = (0, make_mutex_1.makeMutex)();
+    // monkey patch eventemitter to capture all events
+    ev.emit = function (...args) {
+        const content = JSON.stringify({ timestamp: Date.now(), event: args[0], data: args[1] }) + '\n';
+        const result = oldEmit.apply(ev, args);
+        writeMutex.mutex(async () => {
+            await (0, promises_1.writeFile)(filename, content, { flag: 'a' });
+        });
+        return result;
+    };
+};
+/**
+ * Read event file and emit events from there
+ * @param filename filename containing event data
+ * @param delayIntervalMs delay between each event emit
+ */
+const readAndEmitEventStream = (filename, delayIntervalMs = 0) => {
+    const ev = new events_1.default();
+    const fireEvents = async () => {
+        // from: https://stackoverflow.com/questions/6156501/read-a-file-one-line-at-a-time-in-node-js
+        const fileStream = (0, fs_1.createReadStream)(filename);
+        const rl = (0, readline_1.createInterface)({
+            input: fileStream,
+            crlfDelay: Infinity
+        });
+        // Note: we use the crlfDelay option to recognize all instances of CR LF
+        // ('\r\n') in input.txt as a single line break.
+        for await (const line of rl) {
+            if (line) {
+                const { event, data } = JSON.parse(line);
+                ev.emit(event, data);
+                delayIntervalMs && await (0, generics_1.delay)(delayIntervalMs);
+            }
+        }
+        fileStream.close();
+    };
+    return {
+        ev,
+        task: fireEvents()
+    };
+};
+
+export { captureEventStream, readAndEmitEventStream };

package/lib/Utils/bot-signature.d.ts

@@ -0,0 +1,22 @@
+export declare const BOT_SIGNATURE_VERSION: '1';
+export declare const BOT_SIGNATURE_USE_CASE_WA_BOT_MSG: 1;
+export declare const BOT_SIGNATURE_ROOT_VERSION: string;
+export declare const BOT_SIGNATURE_ROOT_CERTIFICATE: string;
+
+export declare function loadBotSignatureRoot(): import('crypto').X509Certificate;
+
+export declare function constructSignaturePayload(options: {
+    botFbid: string;
+    messageDigest: Buffer | Uint8Array;
+    version?: string;
+}): Buffer;
+
+export declare function verifyBotSignature(options: {
+    botJid?: string;
+    unifiedResponseBytes?: Buffer | Uint8Array;
+    proof?: any;
+    at?: number;
+    root?: import('crypto').X509Certificate;
+}): { status: 'passed' | 'failed'; reason?: string };
+
+export declare function isParsableCertificateChain(chain?: unknown): boolean;

package/lib/Utils/bot-signature.js

@@ -0,0 +1,124 @@
+import { X509Certificate, verify as cryptoVerify } from 'crypto';
+/* Elaina Baileys maintained distribution. Upstream notices and license are preserved in LICENSE and NOTICE.md. */
+
+export const BOT_SIGNATURE_VERSION = '1'
+export const BOT_SIGNATURE_USE_CASE_WA_BOT_MSG = 1
+export const BOT_SIGNATURE_ROOT_VERSION = '2025-10'
+
+export const BOT_SIGNATURE_ROOT_CERTIFICATE = `-----BEGIN CERTIFICATE-----
+MIIC7TCCApOgAwIBAgIUAtu5QuxmVhfGT8LPkjfm40mSl0AwCgYIKoZIzj0EAwIw
+dzEgMB4GA1UEAwwXTWV0YSBXQSBGZWF0dXJlIFJvb3QgQ0ExCzAJBgNVBAYTAlVT
+MRMwEQYDVQQIDApDYWxpZm9ybmlhMRMwEQYDVQQHDApNZW5sbyBQYXJrMRwwGgYD
+VQQKDBNNZXRhIFBsYXRmb3JtcyBJbmMuMCAXDTI1MDkwNDE3MzEyNFoYDzIwNjUw
+OTA0MTczMTI0WjB3MSAwHgYDVQQDDBdNZXRhIFdBIEZlYXR1cmUgUm9vdCBDQTEL
+MAkGA1UEBhMCVVMxEzARBgNVBAgMCkNhbGlmb3JuaWExEzARBgNVBAcMCk1lbmxv
+IFBhcmsxHDAaBgNVBAoME01ldGEgUGxhdGZvcm1zIEluYy4wWTATBgcqhkjOPQIB
+BggqhkjOPQMBBwNCAAT60blw90ebreMkw8+Wpcs0ETAkr1VQjoZoyi7PSSQbsoiP
+qYRnzfRrR+xiahaXbYU83qXiTHjVUiOU9wDxI83qo4H6MIH3MA8GA1UdEwEB/wQF
+MAMBAf8wHQYDVR0OBBYEFNO7KMTVSYUxkL6VS3LyWJw7m76zMIG0BgNVHSMEgaww
+gamAFNO7KMTVSYUxkL6VS3LyWJw7m76zoXukeTB3MSAwHgYDVQQDDBdNZXRhIFdB
+IEZlYXR1cmUgUm9vdCBDQTELMAkGA1UEBhMCVVMxEzARBgNVBAgMCkNhbGlmb3Ju
+aWExEzARBgNVBAcMCk1lbmxvIFBhcmsxHDAaBgNVBAoME01ldGEgUGxhdGZvcm1z
+IEluYy6CFALbuULsZlYXxk/Cz5I35uNJkpdAMA4GA1UdDwEB/wQEAwIBhjAKBggq
+hkjOPQQDAgNIADBFAiAINhjk9DbP416vx/WjqdUfexgic08aQsxnpDDsNE5M0gIh
+ANorq7KwCQVMtS2or5uKJAQsx1FxCHyDafq2GCk9t0AN
+-----END CERTIFICATE-----`
+
+let rootCertificate = null
+
+export const loadBotSignatureRoot = () => {
+    if (!rootCertificate) {
+        rootCertificate = new X509Certificate(BOT_SIGNATURE_ROOT_CERTIFICATE)
+    }
+    return rootCertificate
+}
+
+export const constructSignaturePayload = ({ botFbid, messageDigest, version = BOT_SIGNATURE_VERSION }) =>
+    Buffer.concat([Buffer.from(version, 'utf8'), Buffer.from(String(botFbid), 'utf8'), Buffer.from(messageDigest)])
+
+export const isParsableCertificateChain = (chain) => {
+    if (!Array.isArray(chain) || !chain.length) {
+        return false
+    }
+    try {
+        for (const entry of chain) {
+            new X509Certificate(Buffer.from(entry))
+        }
+        return true
+    }
+    catch {
+        return false
+    }
+}
+
+const failed = reason => ({ status: 'failed', reason })
+
+const validAt = (certificate, at) => {
+    const from = Date.parse(certificate.validFrom)
+    const to = Date.parse(certificate.validTo)
+    return Number.isFinite(from) && Number.isFinite(to) && at >= from && at <= to
+}
+
+export const verifyBotSignature = ({ botJid, unifiedResponseBytes, proof, at = Date.now(), root = loadBotSignatureRoot() } = {}) => {
+    if (!proof) {
+        return failed('no WA_BOT_MSG proof')
+    }
+    if (Number(proof.version) !== 1) {
+        return failed(`unsupported signature version ${proof.version}`)
+    }
+    if (!proof.signature?.length) {
+        return failed('proof carries no signature')
+    }
+    if (!proof.certificateChain?.length) {
+        return failed('empty certificate chain')
+    }
+    if (!unifiedResponseBytes?.length) {
+        return failed('no unified response bytes to verify')
+    }
+    const botFbid = String(botJid ?? '').split('@')[0]
+    if (!botFbid) {
+        return failed('no bot jid, the fbid is part of the signed payload')
+    }
+
+    let chain
+    try {
+        chain = proof.certificateChain.map(entry => new X509Certificate(Buffer.from(entry)))
+    }
+    catch (error) {
+        return failed(`certificate did not parse: ${error.message}`)
+    }
+
+    const [leaf] = chain
+    if (!validAt(leaf, at)) {
+        return failed('leaf certificate is outside its validity window')
+    }
+
+    const full = [...chain, root]
+    for (let index = 0; index < full.length - 1; index += 1) {
+        const issuer = full[index + 1]
+        if (!validAt(issuer, at)) {
+            return failed(`issuer at position ${index + 1} is outside its validity window`)
+        }
+        let ok = false
+        try {
+            ok = full[index].verify(issuer.publicKey)
+        }
+        catch (error) {
+            return failed(`chain verification threw at position ${index}: ${error.message}`)
+        }
+        if (!ok) {
+            return failed(`chain broken at position ${index}`)
+        }
+    }
+
+    const payload = constructSignaturePayload({ botFbid, messageDigest: unifiedResponseBytes })
+    let ok = false
+    try {
+        ok = cryptoVerify(null, payload, leaf.publicKey, Buffer.from(proof.signature))
+    }
+    catch (error) {
+        return failed(`signature verification threw: ${error.message}`)
+    }
+    return ok ? { status: 'passed' } : failed('signature does not match the unified response bytes')
+}
+

package/lib/Utils/browser-utils.js

@@ -0,0 +1,48 @@
+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: 'Linux',
+    haiku: undefined,
+    cygwin: undefined,
+    netbsd: undefined
+};
+const BROWSER_MAP = {
+    safari: 'Safari',
+    chrome: 'Chrome',
+    edge: 'Edge',
+    firefox: 'Firefox',
+    opera: 'Opera',
+    brave: 'Brave',
+    samsung: 'Samsung Internet'
+};
+const getBrowserN = (bros) => {
+    const brosN = BROWSER_MAP[bros] || bros;
+    return brosN;
+};
+export const Browsers = {
+    ubuntu: browser => ['Ubuntu', getBrowserN(browser), '22.04.4'],
+    macOS: browser => ['Mac OS', getBrowserN(browser), '14.4.1'],
+    baileys: browser => ['Baileys', getBrowserN(browser), '6.5.0'],
+    windows: browser => ['Windows', getBrowserN(browser), '10.0.22631'],
+    iOS: browser => ['iOS', getBrowserN(browser), '18.2'],
+    android: browser => ['Android', getBrowserN(browser), '14.0.0'],
+    safari: browser => ['Safari', getBrowserN(browser), '26.5'],
+    custom: (platform, browser, ver) => {
+        let platformN = PLATFORM_MAP[platform].toLowerCase() || platform;
+        return [platformN, getBrowserN(browser), ver];
+    },
+    /** The appropriate browser based on your OS & release */
+    appropriate: browser => [PLATFORM_MAP[platform()] || 'Ubuntu', getBrowserN(browser), release()]
+};
+export const getPlatformId = (browser) => {
+    const platformType = proto.DeviceProps.PlatformType[browser.toUpperCase()];
+    return platformType ? platformType.toString() : '1'; //chrome
+};
+//# sourceMappingURL=browser-utils.js.map