@zervonex/baileys 0.0.0-stage → 3.0.2

package/lib/Types/Newsletter.js

@@ -0,0 +1,100 @@
+export var XWAPaths;
+(function (XWAPaths) {
+  XWAPaths["xwa2_newsletter_create"] = "xwa2_newsletter_create";
+  XWAPaths["xwa2_newsletter_subscribed"] = "xwa2_newsletter_subscribed";
+  XWAPaths["xwa2_newsletter_metadata"] = "xwa2_newsletter";
+  XWAPaths["xwa2_newsletter_admin_count"] = "xwa2_newsletter_admin";
+  XWAPaths["xwa2_newsletter_admin_info"] = "xwa2_newsletter_admin";
+  XWAPaths["xwa2_newsletter_admin_capabilities"] = "xwa2_newsletter_admin";
+  XWAPaths["admin_profile"] = "xwa2_newsletter_admin";
+  XWAPaths["pending_admin_invites"] = "xwa2_newsletter_admin";
+  XWAPaths["xwa2_channel_enforcements"] = "xwa2_channel_enforcements";
+  XWAPaths["xwa2_channels_reports"] = "xwa2_channels_reports";
+  XWAPaths["xwa2_create_channel_report_appeal_v2"] = "xwa2_create_channel_report_appeal_v2";
+  XWAPaths["xwa2_newsletter_update_user_setting"] = "xwa2_newsletter_update_user_setting";
+  XWAPaths["xwa2_newsletter_join_v2"] = "xwa2_newsletter_join_v2";
+  XWAPaths["xwa2_newsletter_leave_v2"] = "xwa2_newsletter_leave_v2";
+  XWAPaths["xwa2_newsletter_change_owner"] = "xwa2_newsletter_change_owner";
+  XWAPaths["xwa2_newsletter_demote"] = "xwa2_newsletter_admin_demote";
+  XWAPaths["xwa2_newsletter_delete_v2"] = "xwa2_newsletter_delete_v2";
+  XWAPaths["xwa2_newsletter_followers"] = "xwa2_newsletter_followers";
+  XWAPaths["xwa2_newsletter_mute_v2"] = "xwa2_newsletter_mute_v2";
+  XWAPaths["xwa2_newsletter_unmute_v2"] = "xwa2_newsletter_unmute_v2";
+  XWAPaths["xwa2_newsletter_admin_insights"] = "xwa2_newsletter_admin_insights";
+  XWAPaths["xwa2_newsletter_pin_messages"] = "xwa2_newsletter_pin_messages";
+  XWAPaths["xwa2_newsletter_unpin_messages"] = "xwa2_newsletter_unpin_messages";
+  XWAPaths["xwa2_newsletter_label_ai_content"] = "xwa2_newsletter_label_ai_content";
+  XWAPaths["xwa2_newsletter_label_paid_partnership"] = "xwa2_newsletter_label_paid_partnership";
+  XWAPaths["xwa2_newsletter_admin_invite_create"] = "xwa2_newsletter_admin_invite_create";
+  XWAPaths["xwa2_newsletter_admin_invite_revoke"] = "xwa2_newsletter_admin_invite_revoke";
+  XWAPaths["xwa2_newsletter_admin_invite_accept"] = "xwa2_newsletter_admin_invite_accept";
+  XWAPaths["xwa2_newsletter_link_preview"] = "xwa2_newsletter_link_preview";
+  XWAPaths["xwa2_newsletter_question_response_state_update"] = "xwa2_newsletter_question_response_state_update";
+  XWAPaths["voter_list"] = "voter_list";
+  XWAPaths["xwa2_newsletters_reaction_sender_list"] = "xwa2_newsletters_reaction_sender_list";
+  XWAPaths["xwa2_newsletters_recommended"] = "xwa2_newsletters_recommended";
+  XWAPaths["xwa2_newsletters_similar"] = "xwa2_newsletters_similar";
+  XWAPaths["xwa2_newsletters_directory_list"] = "xwa2_newsletters_directory_list";
+  XWAPaths["xwa2_newsletters_directory_search"] = "xwa2_newsletters_directory_search";
+  XWAPaths["xwa2_newsletters_directory_category_preview"] = "xwa2_newsletters_directory_category_preview";
+  XWAPaths["xwa2_fetch_account_reachout_timelock"] = "xwa2_fetch_account_reachout_timelock";
+  XWAPaths["xwa2_message_capping_info"] = "xwa2_message_capping_info";
+  XWAPaths["xwa2_username_get"] = "xwa2_username_get";
+  XWAPaths["xwa2_username_set"] = "xwa2_username_set";
+  XWAPaths["xwa2_username_pin_set"] = "xwa2_username_pin_set";
+  XWAPaths["xwa2_username_check"] = "xwa2_username_check";
+  XWAPaths["xwa2_update_text_status"] = "xwa2_update_text_status";
+  XWAPaths["xwa2_text_status_list"] = "xwa2_text_status_list";
+  XWAPaths["xwa2_users_updates_since"] = "xwa2_users_updates_since";
+})(XWAPaths || (XWAPaths = {}));
+
+export var QueryIds;
+(function (QueryIds) {
+  QueryIds["CREATE"] = "25149874324715067";
+  QueryIds["UPDATE_METADATA"] = "24250201037901610";
+  QueryIds["METADATA"] = "27456920720571478";
+  QueryIds["SUBSCRIBERS"] = "9783111038412085";
+  QueryIds["SUBSCRIBED"] = "25399611239711790";
+  QueryIds["FOLLOW"] = "24404358912487870";
+  QueryIds["UNFOLLOW"] = "9767147403369991";
+  QueryIds["ENFORCEMENTS"] = "27835373536068060";
+  QueryIds["CHANNEL_REPORTS"] = "35936238352686172";
+  QueryIds["CREATE_REPORT_APPEAL"] = "27103316329328467";
+  QueryIds["UPDATE_USER_SETTING"] = "31938993655691868";
+  QueryIds["ADMIN_COUNT"] = "26278439461859188";
+  QueryIds["ADMIN_INFO"] = "26278439461859188";
+  QueryIds["ADMIN_CAPABILITIES"] = "9801384413216421";
+  QueryIds["CHANGE_OWNER"] = "9546742745432473";
+  QueryIds["DEMOTE"] = "9880997548630971";
+  QueryIds["DELETE"] = "30062808666639665";
+  QueryIds["FOLLOWERS"] = "27472091235714801";
+  QueryIds["MUTE"] = "29766401636284406";
+  QueryIds["UNMUTE"] = "9864994326891137";
+  QueryIds["INSIGHTS"] = "9853618868050977";
+  QueryIds["PIN_MESSAGES"] = "27165709459706559";
+  QueryIds["UNPIN_MESSAGES"] = "28007176042216937";
+  QueryIds["LABEL_AI_CONTENT"] = "27909718265289596";
+  QueryIds["PAID_PARTNERSHIP_LABEL"] = "26102375079404865";
+  QueryIds["CREATE_ADMIN_INVITE"] = "9387141988078609";
+  QueryIds["REVOKE_ADMIN_INVITE"] = "9656078347839416";
+  QueryIds["ACCEPT_ADMIN_INVITE"] = "9580828702035549";
+  QueryIds["POLL_VOTERS"] = "9407762219322536";
+  QueryIds["REACTION_SENDER_LIST"] = "29575462448733991";
+  QueryIds["RECOMMENDED"] = "25806748772361516";
+  QueryIds["SIMILAR"] = "26217043484590756";
+  QueryIds["DIRECTORY_LIST"] = "26125047313831973";
+  QueryIds["DIRECTORY_SEARCH"] = "26301059626252132";
+  QueryIds["DIRECTORY_CATEGORIES"] = "35266481849605779";
+  QueryIds["PENDING_ADMIN_INVITES"] = "9783111038412085";
+  QueryIds["QUESTION_RESPONSE_STATE"] = "24636260219323456";
+  QueryIds["REACHOUT_TIMELOCK"] = "23983697327930364";
+  QueryIds["MESSAGE_CAPPING_INFO"] = "27910975521856601";
+  QueryIds["PLAINTEXT_LINK_PREVIEW"] = "9101130456653613";
+  QueryIds["USERNAME_GET"] = "25347099718279209";
+  QueryIds["USERNAME_SET"] = "25757341163897635";
+  QueryIds["USERNAME_PIN_SET"] = "9749436995157074";
+  QueryIds["USERNAME_CHECK"] = "26122779627399568";
+  QueryIds["UPDATE_TEXT_STATUS"] = "9152604461510864";
+  QueryIds["TEXT_STATUS_LIST"] = "24072923595647473";
+  QueryIds["ABOUT_STATUS"] = "24535500086059408";
+})(QueryIds || (QueryIds = {}));

package/lib/Types/Product.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Product.js.map

package/lib/Types/Signal.js

@@ -0,0 +1,2 @@
+import { proto } from '../../WAProto/index.js';
+//# sourceMappingURL=Signal.js.map

package/lib/Types/Socket.js

@@ -0,0 +1,14 @@
+import { proto } from '../../WAProto/index.js';
+import {} from './Message.js';
+//# sourceMappingURL=Socket.js.map
+export const AIProvenanceType = Object.freeze({
+    NONE: 0,
+    CREATED_WITH_GEN_AI: 1,
+    EDITED_WITH_GEN_AI: 2,
+})
+
+export const DeviceCapabilityLevel = Object.freeze({
+    NONE: 0,
+    INFRA: 1,
+    FULL: 2,
+})

package/lib/Types/State.js

@@ -0,0 +1,26 @@
+export const SyncState = Object.freeze({ Connecting: 0, AwaitingInitialSync: 1, Syncing: 2, Online: 3 })
+
+export const ReachoutTimelockEnforcementType = Object.freeze({
+    BIZ_COMMERCE_VIOLATION_ALCOHOL: 'BIZ_COMMERCE_VIOLATION_ALCOHOL',
+    BIZ_COMMERCE_VIOLATION_ADULT: 'BIZ_COMMERCE_VIOLATION_ADULT',
+    BIZ_COMMERCE_VIOLATION_ANIMALS: 'BIZ_COMMERCE_VIOLATION_ANIMALS',
+    BIZ_COMMERCE_VIOLATION_BODY_PARTS_FLUIDS: 'BIZ_COMMERCE_VIOLATION_BODY_PARTS_FLUIDS',
+    BIZ_COMMERCE_VIOLATION_DATING: 'BIZ_COMMERCE_VIOLATION_DATING',
+    BIZ_COMMERCE_VIOLATION_DIGITAL_SERVICES_PRODUCTS: 'BIZ_COMMERCE_VIOLATION_DIGITAL_SERVICES_PRODUCTS',
+    BIZ_COMMERCE_VIOLATION_DRUGS: 'BIZ_COMMERCE_VIOLATION_DRUGS',
+    BIZ_COMMERCE_VIOLATION_DRUGS_ONLY_OTC: 'BIZ_COMMERCE_VIOLATION_DRUGS_ONLY_OTC',
+    BIZ_COMMERCE_VIOLATION_GAMBLING: 'BIZ_COMMERCE_VIOLATION_GAMBLING',
+    BIZ_COMMERCE_VIOLATION_HEALTHCARE: 'BIZ_COMMERCE_VIOLATION_HEALTHCARE',
+    BIZ_COMMERCE_VIOLATION_REAL_FAKE_CURRENCY: 'BIZ_COMMERCE_VIOLATION_REAL_FAKE_CURRENCY',
+    BIZ_COMMERCE_VIOLATION_SUPPLEMENTS: 'BIZ_COMMERCE_VIOLATION_SUPPLEMENTS',
+    BIZ_COMMERCE_VIOLATION_TOBACCO: 'BIZ_COMMERCE_VIOLATION_TOBACCO',
+    BIZ_COMMERCE_VIOLATION_VIOLENT_CONTENT: 'BIZ_COMMERCE_VIOLATION_VIOLENT_CONTENT',
+    BIZ_COMMERCE_VIOLATION_WEAPONS: 'BIZ_COMMERCE_VIOLATION_WEAPONS',
+    BIZ_QUALITY: 'BIZ_QUALITY',
+    DEFAULT: 'DEFAULT',
+    WEB_COMPANION_ONLY: 'WEB_COMPANION_ONLY',
+})
+
+export const NewChatMessageCappingStatusType = Object.freeze({ NONE:'NONE', FIRST_WARNING:'FIRST_WARNING', SECOND_WARNING:'SECOND_WARNING', CAPPED:'CAPPED' })
+export const NewChatMessageCappingMVStatusType = Object.freeze({ NOT_ELIGIBLE:'NOT_ELIGIBLE', NOT_ACTIVE:'NOT_ACTIVE', ACTIVE:'ACTIVE', ACTIVE_UPGRADE_AVAILABLE:'ACTIVE_UPGRADE_AVAILABLE' })
+export const NewChatMessageCappingOTEStatusType = Object.freeze({ NOT_ELIGIBLE:'NOT_ELIGIBLE', ELIGIBLE:'ELIGIBLE', ACTIVE_IN_CURRENT_CYCLE:'ACTIVE_IN_CURRENT_CYCLE', EXHAUSTED:'EXHAUSTED' })

package/lib/Types/USync.js

@@ -0,0 +1,2 @@
+import { USyncUser } from '../WAUSync/index.js';
+//# sourceMappingURL=USync.js.map

package/lib/Types/index.js

@@ -0,0 +1,30 @@
+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 * from './Label.js'
+export * from './LabelAssociation.js'
+export * from './USync.js'
+
+export const DisconnectReason = Object.freeze({
+    connectionClosed: 428,
+    connectionLost: 408,
+    connectionReplaced: 440,
+    timedOut: 408,
+    loggedOut: 401,
+    badSession: 500,
+    restartRequired: 515,
+    multideviceMismatch: 411,
+    forbidden: 403,
+    unavailableService: 503,
+})
+
+

package/lib/Utils/auth-utils.js

@@ -0,0 +1,142 @@
+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 { v4 } from 'uuid'
+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'
+
+export function makeCacheableSignalKeyStore(store, logger, _cache) {
+    const cache = _cache || new NodeCache({ stdTTL: DEFAULT_CACHE_TTLS.SIGNAL_STORE, useClones: false, deleteOnExpire: true })
+    const cacheMutex = new Mutex()
+    const uid = (type, id) => `${type}.${id}`
+    return {
+        async get(type, ids) {
+            return cacheMutex.runExclusive(async () => {
+                const data = {}, missing = []
+                for (const id of ids) { const item = await cache.get(uid(type, id)); if (typeof item !== 'undefined') data[id] = item; else missing.push(id) }
+                if (missing.length) { logger?.trace({ items: missing.length }, 'loading from store'); const fetched = await store.get(type, missing); for (const id of missing) { if (fetched[id]) { data[id] = fetched[id]; cache.set(uid(type, id), fetched[id]) } } }
+                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(uid(type, id), data[type][id]); keys++ } }
+                logger?.trace({ keys }, 'updated cache')
+                await store.set(data)
+            })
+        },
+        async clear() { await cache.flushAll(); await store.clear?.() }
+    }
+}
+
+export const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetweenTriesMs }) => {
+    const txStorage = new AsyncLocalStorage()
+    const keyQueues = new Map()
+    const txMutexes = new Map()
+    const preKeyManager = new PreKeyManager(state, logger)
+
+    const getQueue = key => { if (!keyQueues.has(key)) keyQueues.set(key, new PQueue({ concurrency: 1 })); return keyQueues.get(key) }
+    const getTxMutex = key => { if (!txMutexes.has(key)) txMutexes.set(key, new Mutex()); return txMutexes.get(key) }
+    const isInTransaction = () => !!txStorage.getStore()
+
+    const EXPECTED_ERRORS = ['InvalidPreKeyId', 'SessionNotFound', 'InvalidMessage', 'no sender key state', 'memory access out of bounds', 'old counter', 'DuplicatedMessage', 'BadMac', 'Connection Closed']
+    const isExpectedError = msg => EXPECTED_ERRORS.some(e => msg.includes(e))
+
+    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 msg = error?.message || (typeof error === 'string' ? error : '') || ''
+                if (isExpectedError(msg)) { logger?.debug?.({ error: msg }, 'transaction skipped — expected decrypt error'); return }
+                if (attempt < maxCommitRetries - 1) { await delay(delayBetweenTriesMs); continue }
+                logger?.error?.({ error: msg || error }, 'transaction failed after retries')
+                throw error
+            }
+        }
+    }
+
+    return {
+        get: async (type, ids) => {
+            const ctx = txStorage.getStore()
+            if (!ctx) return state.get(type, ids)
+            const cached = ctx.cache[type] || {}
+            const missing = ids.filter(id => !(id in cached))
+            if (missing.length) { ctx.dbQueries++; logger.trace({ type, count: missing.length }, 'fetching missing keys in transaction'); const fetched = await getTxMutex(type).runExclusive(() => state.get(type, missing)); ctx.cache[type] = ctx.cache[type] || {}; Object.assign(ctx.cache[type], fetched) }
+            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) {
+                const types = Object.keys(data)
+                for (const type of types) { if (type === 'pre-key') await preKeyManager.validateDeletions(data, type) }
+                await Promise.all(types.map(type => getQueue(type).add(async () => state.set({ [type]: data[type] }))))
+                return
+            }
+            logger.trace({ types: Object.keys(data) }, 'caching in transaction')
+            for (const key in data) {
+                ctx.cache[key] = ctx.cache[key] || {}
+                ctx.mutations[key] = ctx.mutations[key] || {}
+                if (key === 'pre-key') await preKeyManager.processOperations(data, key, ctx.cache, ctx.mutations, true)
+                else { Object.assign(ctx.cache[key], data[key]); Object.assign(ctx.mutations[key], data[key]) }
+            }
+        },
+        isInTransaction,
+        transaction: async (work, key) => {
+            const existing = txStorage.getStore()
+            if (existing) { logger.trace('reusing existing transaction context'); return work() }
+            return getTxMutex(key).runExclusive(async () => {
+                const ctx = { cache: {}, mutations: {}, dbQueries: 0 }
+                logger.trace('entering transaction')
+                try {
+                    const result = await txStorage.run(ctx, work)
+                    await commitWithRetry(ctx.mutations)
+                    logger.trace({ dbQueries: ctx.dbQueries }, 'transaction completed')
+                    return result
+                } catch (error) {
+                    const msg = error?.message || (typeof error === 'string' ? error : '') || ''
+                        ; (isExpectedError(msg) ? logger?.debug?.bind(logger) : logger?.error?.bind(logger))?.({ error: msg || error }, 'transaction failed, rolling back')
+                    throw error
+                }
+            })
+        }
+    }
+}
+
+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 },
+        deviceId: Buffer.from(v4().replace(/-/g, ''), 'hex').toString('base64url'),
+        phoneId: v4(),
+        identityId: randomBytes(20),
+        registered: false,
+        backupToken: randomBytes(20),
+        registration: {},
+        pairingCode: undefined,
+        lastPropHash: undefined,
+        routingInfo: undefined,
+        additionalData: undefined
+    }
+}

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

@@ -0,0 +1,33 @@
+import EventEmitter from 'events'
+import { createReadStream } from 'fs'
+import { writeFile } from 'fs/promises'
+import { createInterface } from 'readline'
+import { delay } from './generics.js'
+import { makeMutex } from './make-mutex.js'
+
+export const captureEventStream = (ev, filename) => {
+    const oldEmit = ev.emit.bind(ev)
+    const writeMutex = makeMutex()
+    ev.emit = (...args) => {
+        const content = JSON.stringify({ timestamp: Date.now(), event: args[0], data: args[1] }) + '\n'
+        const result = oldEmit(...args)
+        writeMutex.mutex(() => writeFile(filename, content, { flag: 'a' }))
+        return result
+    }
+}
+
+export const readAndEmitEventStream = (filename, delayIntervalMs = 0) => {
+    const ev = new EventEmitter()
+    const fireEvents = async () => {
+        const fileStream = createReadStream(filename)
+        const rl = createInterface({ input: fileStream, crlfDelay: Infinity })
+        for await (const line of rl) {
+            if (!line) continue
+            const { event, data } = JSON.parse(line)
+            ev.emit(event, data)
+            if (delayIntervalMs) await delay(delayIntervalMs)
+        }
+        fileStream.destroy()
+    }
+    return { ev, task: fireEvents() }
+}

package/lib/Utils/bot-capabilities.js

@@ -0,0 +1,40 @@
+import { proto } from '../../WAProto/index.js'
+import { BOT_RENDERING_CONFIG_METADATA } from '../Defaults/index.js'
+
+export const BotCapabilityType = proto.BotCapabilityMetadata.BotCapabilityType
+
+const capabilityNames = new Set(Object.keys(BotCapabilityType).filter(n => Number.isNaN(Number(n))))
+
+export const normalizeBotCapabilities = (capabilities = []) => {
+    if (!Array.isArray(capabilities)) throw new TypeError('capabilities must be an array')
+    const values = capabilities.map(c => {
+        if (typeof c === 'string') { if (!capabilityNames.has(c)) throw new TypeError(`Unknown bot capability: ${c}`); return BotCapabilityType[c] }
+        if (Number.isInteger(c) && BotCapabilityType[c] !== undefined) return c
+        throw new TypeError(`Invalid bot capability: ${String(c)}`)
+    })
+    return [...new Set(values)]
+}
+
+export const buildBotCapabilityMetadata = (capabilities = []) => ({ capabilities: normalizeBotCapabilities(capabilities) })
+
+// Use AIRich builder for complex multi-section responses
+export const buildBotRichResponse = ({ text, submessages, capabilities = [], botMetadata = {}, botJid = '867051314767696@bot', richResponse = {} } = {}) => {
+    const resolved = submessages || (text == null ? [] : [{ messageType: proto.AIRichResponseSubMessageType.AI_RICH_RESPONSE_TEXT, messageText: String(text) }])
+    return {
+        messageContextInfo: {
+            botMetadata: { ...botMetadata, capabilityMetadata: buildBotCapabilityMetadata(capabilities), botRenderingConfigMetadata: BOT_RENDERING_CONFIG_METADATA }
+        },
+        botForwardedMessage: {
+            message: {
+                richResponseMessage: {
+                    messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
+                    submessages: resolved,
+                    ...richResponse,
+                    contextInfo: { isForwarded: true, forwardingScore: 1, forwardedAiBotMessageInfo: { botJid }, forwardOrigin: 4, ...(richResponse.contextInfo || {}) }
+                }
+            }
+        }
+    }
+}
+
+export const capability = name => { if (!capabilityNames.has(name)) throw new TypeError(`Unknown bot capability: ${name}`); return BotCapabilityType[name] }

package/lib/Utils/bot-planning-replay.js

@@ -0,0 +1,44 @@
+import { buildPlainPlaceholder, PlanningStepStatus } from './meta-compositing.js'
+import { delay } from './generics.js'
+
+// Live planning animation: shows pending steps, edits each to DONE one-by-one,
+// deletes placeholder, then sends the final message. Works on all WA clients.
+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 must have at least one entry')
+
+    let aborted = false
+    if (abortOnDisconnect) sock.ev?.once?.('connection.update', ({ connection }) => { if (connection === 'close') aborted = true })
+
+    await sock.sendPresenceUpdate('composing', jid)
+
+    const initial = steps.map(s => ({ ...s, status: PlanningStepStatus.IN_PROGRESS }))
+    const placeholder = await sock.sendMessage(jid, buildPlainPlaceholder(description, initial, placeholderText))
+    const key = placeholder?.key
+
+    try {
+        const current = [...initial]
+        for (let i = 0; i < current.length; i++) {
+            if (aborted) break
+            await delay(stepDelayMs)
+            if (aborted) break
+            current[i] = { ...current[i], status: PlanningStepStatus.DONE }
+            if (key) await sock.sendMessage(jid, { edit: key, ...buildPlainPlaceholder(description, current, placeholderText) })
+        }
+        if (!aborted && finalPauseMs > 0) await delay(finalPauseMs)
+        if (key && !aborted) await sock.sendMessage(jid, { delete: key })
+    } catch (_) {
+        try { if (key) await sock.sendMessage(jid, { delete: key }) } catch (__) { }
+    }
+
+    await sock.sendPresenceUpdate('paused', jid)
+    if (sendOptions._skipFinalSend) return placeholder
+    return sock.sendMessage(jid, finalContent, sendOptions)
+}
+
+// Animation without a final message
+export const replayPlanningOnly = (sock, jid, steps, options = {}) =>
+    replayPlanning(sock, jid, steps, null, { ...options, sendOptions: { ...options.sendOptions, _skipFinalSend: true } })
+
+export const buildReasoningSteps = titles => titles.map(title => ({ title, isReasoning: true }))
+export const buildSearchSteps = titles => titles.map(title => ({ title, isEnhancedSearch: true }))
+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,26 @@
+import { platform, release } from 'os'
+import { proto } from '../../WAProto/index.js'
+
+const PLATFORM_MAP = {
+    aix: 'AIX', darwin: 'Mac OS', win32: 'Windows', android: 'Android',
+    freebsd: 'FreeBSD', openbsd: 'OpenBSD', sunos: 'Solaris',
+    linux: undefined, haiku: undefined, cygwin: undefined, netbsd: undefined
+}
+
+export const Browsers = {
+    ubuntu: browser => ['Ubuntu', browser, '24.04.2'],
+    macOS: browser => ['Mac OS', browser, '15.4.1'],
+    baileys: browser => ['Baileys', browser, '6.5.0'],
+    windows: browser => ['Windows', browser, '10.0.26100'],
+    android: browser => [browser, 'Android', ''],
+    appropriate: browser => [PLATFORM_MAP[platform()] || 'Ubuntu', browser, release()]
+}
+
+export const getPlatformId = browser => {
+    const upper = browser.toUpperCase()
+    if (upper === 'ANDROID') return proto.DeviceProps.PlatformType.ANDROID_PHONE.toString()
+    const type = proto.DeviceProps.PlatformType[upper]
+    return (type ?? proto.DeviceProps.PlatformType.CHROME).toString()
+}
+
+export const isAndroidBrowser = browser => browser[1]?.toUpperCase() === 'ANDROID'

package/lib/Utils/business.js

@@ -0,0 +1,75 @@
+import { Boom } from '@hapi/boom'
+import { createHash } from 'crypto'
+import { getBinaryNodeChild, getBinaryNodeChildren, getBinaryNodeChildString } from '../WABinary/index.js'
+import { getStream, getUrlFromDirectPath, toReadable } from './messages-media.js'
+
+export const parseCatalogNode = node => {
+    const catalogNode = getBinaryNodeChild(node, 'product_catalog')
+    const paging = getBinaryNodeChild(catalogNode, 'paging')
+    return { products: getBinaryNodeChildren(catalogNode, 'product').map(parseProductNode), nextPageCursor: paging ? getBinaryNodeChildString(paging, 'after') : undefined }
+}
+
+export const parseCollectionsNode = node => {
+    const collectionsNode = getBinaryNodeChild(node, 'collections')
+    return { collections: getBinaryNodeChildren(collectionsNode, 'collection').map(collectionNode => ({ id: getBinaryNodeChildString(collectionNode, 'id'), name: getBinaryNodeChildString(collectionNode, 'name'), products: getBinaryNodeChildren(collectionNode, 'product').map(parseProductNode), status: parseStatusInfo(collectionNode) })) }
+}
+
+export const parseOrderDetailsNode = node => {
+    const orderNode = getBinaryNodeChild(node, 'order')
+    const priceNode = getBinaryNodeChild(orderNode, 'price')
+    const products = getBinaryNodeChildren(orderNode, 'product').map(productNode => {
+        const imageNode = getBinaryNodeChild(productNode, 'image')
+        return { id: getBinaryNodeChildString(productNode, 'id'), name: getBinaryNodeChildString(productNode, 'name'), imageUrl: getBinaryNodeChildString(imageNode, 'url'), price: +getBinaryNodeChildString(productNode, 'price'), currency: getBinaryNodeChildString(productNode, 'currency'), quantity: +getBinaryNodeChildString(productNode, 'quantity') }
+    })
+    return { price: { total: +getBinaryNodeChildString(priceNode, 'total'), currency: getBinaryNodeChildString(priceNode, 'currency') }, products }
+}
+
+export const toProductNode = (productId, product) => {
+    const attrs = {}
+    const content = []
+    const push = (tag, value) => content.push({ tag, attrs: {}, content: Buffer.from(value) })
+    if (productId !== undefined) push('id', productId)
+    if (product.name !== undefined) push('name', product.name)
+    if (product.description !== undefined) push('description', product.description)
+    if (product.retailerId !== undefined) push('retailer_id', product.retailerId)
+    if (product.images?.length) {
+        content.push({
+            tag: 'media', attrs: {}, content: product.images.map(img => {
+                if (!('url' in img)) throw new Boom('Expected img for product to already be uploaded', { statusCode: 400 })
+                return { tag: 'image', attrs: {}, content: [{ tag: 'url', attrs: {}, content: Buffer.from(img.url.toString()) }] }
+            })
+        })
+    }
+    if (product.price !== undefined) push('price', product.price.toString())
+    if (product.currency !== undefined) push('currency', product.currency)
+    if ('originCountryCode' in product) {
+        if (product.originCountryCode === undefined) attrs['compliance_category'] = 'COUNTRY_ORIGIN_EXEMPT'
+        else content.push({ tag: 'compliance_info', attrs: {}, content: [{ tag: 'country_code_origin', attrs: {}, content: Buffer.from(product.originCountryCode) }] })
+    }
+    if (product.isHidden !== undefined) attrs['is_hidden'] = product.isHidden.toString()
+    return { tag: 'product', attrs, content }
+}
+
+export const parseProductNode = productNode => {
+    const mediaNode = getBinaryNodeChild(productNode, 'media')
+    const statusInfoNode = getBinaryNodeChild(productNode, 'status_info')
+    return { id: getBinaryNodeChildString(productNode, 'id'), imageUrls: parseImageUrls(mediaNode), reviewStatus: { whatsapp: getBinaryNodeChildString(statusInfoNode, 'status') }, availability: 'in stock', name: getBinaryNodeChildString(productNode, 'name'), retailerId: getBinaryNodeChildString(productNode, 'retailer_id'), url: getBinaryNodeChildString(productNode, 'url'), description: getBinaryNodeChildString(productNode, 'description'), price: +getBinaryNodeChildString(productNode, 'price'), currency: getBinaryNodeChildString(productNode, 'currency'), isHidden: productNode.attrs.is_hidden === 'true' }
+}
+
+export const uploadingNecessaryImagesOfProduct = async (product, waUploadToServer, timeoutMs = 30000) =>
+    ({ ...product, images: product.images ? await uploadingNecessaryImages(product.images, waUploadToServer, timeoutMs) : product.images })
+
+export const uploadingNecessaryImages = (images, waUploadToServer, timeoutMs = 30000) =>
+    Promise.all(images.map(async img => {
+        if ('url' in img && img.url.toString().includes('.whatsapp.net')) return { url: img.url.toString() }
+        const { stream } = await getStream(img)
+        const hasher = createHash('sha256')
+        const blocks = []
+        for await (const block of stream) { hasher.update(block); blocks.push(block) }
+        const sha = hasher.digest('base64')
+        const { directPath } = await waUploadToServer(toReadable(Buffer.concat(blocks)), { mediaType: 'product-catalog-image', fileEncSha256B64: sha, timeoutMs })
+        return { url: getUrlFromDirectPath(directPath) }
+    }))
+
+const parseImageUrls = mediaNode => { const imgNode = getBinaryNodeChild(mediaNode, 'image'); return { requested: getBinaryNodeChildString(imgNode, 'request_image_url'), original: getBinaryNodeChildString(imgNode, 'original_image_url') } }
+const parseStatusInfo = mediaNode => { const node = getBinaryNodeChild(mediaNode, 'status_info'); return { status: getBinaryNodeChildString(node, 'status'), canAppeal: getBinaryNodeChildString(node, 'can_appeal') === 'true' } }