@celestial-community/baileys 0.0.1-security → 1.0.0

package/lib/Utils/auth-utils.js

@@ -0,0 +1,210 @@
+'use strict'
+var __importDefault =
+    (this && this.__importDefault) ||
+    function (mod) {
+        return mod && mod.__esModule ? mod : { default: mod }
+    }
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.initAuthCreds =
+    exports.addTransactionCapability =
+    exports.makeCacheableSignalKeyStore =
+        void 0
+const crypto_1 = require('crypto')
+const node_cache_1 = __importDefault(require('node-cache'))
+const uuid_1 = require('uuid')
+const Defaults_1 = require('../Defaults')
+const crypto_2 = require('./crypto')
+const generics_1 = require('./generics')
+/**
+ * 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 node_cache_1.default({
+            stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.SIGNAL_STORE,
+            useClones: false,
+            deleteOnExpire: true
+        })
+    function getUniqueId(type, id) {
+        return `${type}.${id}`
+    }
+    return {
+        async get(type, ids) {
+            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) {
+            let keys = 0
+            for (const type in data) {
+                for (const id in data[type]) {
+                    cache.set(getUniqueId(type, id), data[type][id])
+                    keys += 1
+                }
+            }
+            logger.trace({ keys }, 'updated cache')
+            await store.set(data)
+        },
+        async clear() {
+            var _a
+            cache.flushAll()
+            await ((_a = store.clear) === null || _a === void 0 ? void 0 : _a.call(store))
+        }
+    }
+}
+exports.makeCacheableSignalKeyStore = makeCacheableSignalKeyStore
+/**
+ * Adds DB like transaction capability (https://en.wikipedia.org/wiki/Database_transaction) to the SignalKeyStore,
+ * this allows batch read & write operations & improves the performance of the lib
+ * @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 }) => {
+    // number of queries made to the DB during the transaction
+    // only there for logging purposes
+    let dbQueriesInTransaction = 0
+    let transactionCache = {}
+    let mutations = {}
+    let transactionsInProgress = 0
+    return {
+        get: async (type, ids) => {
+            if (isInTransaction()) {
+                const dict = transactionCache[type]
+                const idsRequiringFetch = dict
+                    ? ids.filter((item) => typeof dict[item] === 'undefined')
+                    : ids
+                // only fetch if there are any items to fetch
+                if (idsRequiringFetch.length) {
+                    dbQueriesInTransaction += 1
+                    const result = await state.get(type, idsRequiringFetch)
+                    transactionCache[type] || (transactionCache[type] = {})
+                    Object.assign(transactionCache[type], result)
+                }
+                return ids.reduce((dict, id) => {
+                    var _a
+                    const value =
+                        (_a = transactionCache[type]) === null || _a === void 0 ? void 0 : _a[id]
+                    if (value) {
+                        dict[id] = value
+                    }
+                    return dict
+                }, {})
+            } else {
+                return state.get(type, ids)
+            }
+        },
+        set: (data) => {
+            if (isInTransaction()) {
+                logger.trace({ types: Object.keys(data) }, 'caching in transaction')
+                for (const key in data) {
+                    transactionCache[key] = transactionCache[key] || {}
+                    Object.assign(transactionCache[key], data[key])
+                    mutations[key] = mutations[key] || {}
+                    Object.assign(mutations[key], data[key])
+                }
+            } else {
+                return state.set(data)
+            }
+        },
+        isInTransaction,
+        async transaction(work) {
+            let result
+            transactionsInProgress += 1
+            if (transactionsInProgress === 1) {
+                logger.trace('entering transaction')
+            }
+            try {
+                result = await work()
+                // commit if this is the outermost transaction
+                if (transactionsInProgress === 1) {
+                    if (Object.keys(mutations).length) {
+                        logger.trace('committing transaction')
+                        // retry mechanism to ensure we've some recovery
+                        // in case a transaction fails in the first attempt
+                        let tries = maxCommitRetries
+                        while (tries) {
+                            tries -= 1
+                            try {
+                                await state.set(mutations)
+                                logger.trace({ dbQueriesInTransaction }, 'committed transaction')
+                                break
+                            } catch (error) {
+                                logger.warn(
+                                    `failed to commit ${Object.keys(mutations).length} mutations, tries left=${tries}`
+                                )
+                                await (0, generics_1.delay)(delayBetweenTriesMs)
+                            }
+                        }
+                    } else {
+                        logger.trace('no mutations in transaction')
+                    }
+                }
+            } finally {
+                transactionsInProgress -= 1
+                if (transactionsInProgress === 0) {
+                    transactionCache = {}
+                    mutations = {}
+                    dbQueriesInTransaction = 0
+                }
+            }
+            return result
+        }
+    }
+    function isInTransaction() {
+        return transactionsInProgress > 0
+    }
+}
+exports.addTransactionCapability = addTransactionCapability
+const initAuthCreds = () => {
+    const identityKey = crypto_2.Curve.generateKeyPair()
+    return {
+        noiseKey: crypto_2.Curve.generateKeyPair(),
+        pairingEphemeralKeyPair: crypto_2.Curve.generateKeyPair(),
+        signedIdentityKey: identityKey,
+        signedPreKey: (0, crypto_2.signedKeyPair)(identityKey, 1),
+        registrationId: (0, generics_1.generateRegistrationId)(),
+        advSecretKey: (0, crypto_1.randomBytes)(32).toString('base64'),
+        processedHistoryMessages: [],
+        nextPreKeyId: 1,
+        firstUnuploadedPreKeyId: 1,
+        accountSyncCounter: 0,
+        accountSettings: {
+            unarchiveChats: false
+        },
+        // mobile creds
+        deviceId: Buffer.from((0, uuid_1.v4)().replace(/-/g, ''), 'hex').toString('base64url'),
+        phoneId: (0, uuid_1.v4)(),
+        identityId: (0, crypto_1.randomBytes)(20),
+        registered: false,
+        backupToken: (0, crypto_1.randomBytes)(20),
+        registration: {},
+        pairingCode: undefined,
+        lastPropHash: undefined,
+        routingInfo: undefined
+    }
+}
+exports.initAuthCreds = initAuthCreds

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

@@ -0,0 +1,66 @@
+'use strict'
+var __importDefault =
+    (this && this.__importDefault) ||
+    function (mod) {
+        return mod && mod.__esModule ? mod : { default: mod }
+    }
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.readAndEmitEventStream = exports.captureEventStream = void 0
+const events_1 = __importDefault(require('events'))
+const fs_1 = require('fs')
+const promises_1 = require('fs/promises')
+const readline_1 = require('readline')
+const generics_1 = require('./generics')
+const make_mutex_1 = require('./make-mutex')
+/**
+ * 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
+    }
+}
+exports.captureEventStream = captureEventStream
+/**
+ * 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()
+    }
+}
+exports.readAndEmitEventStream = readAndEmitEventStream

package/lib/Utils/browser-utils.js

@@ -0,0 +1,52 @@
+const { platform, release } = require('os')
+const { proto } = require('../../WAProto')
+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
+}
+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()
+    ]
+}
+const getPlatformId = (browser) => {
+    const platformType = proto.DeviceProps.PlatformType[browser.toUpperCase()]
+    return platformType ? platformType.toString() : '1' //chrome
+}
+//# sourceMappingURL=browser-utils.js.map

package/lib/Utils/business.js

@@ -0,0 +1,261 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.uploadingNecessaryImages =
+    exports.uploadingNecessaryImagesOfProduct =
+    exports.parseProductNode =
+    exports.toProductNode =
+    exports.parseOrderDetailsNode =
+    exports.parseCollectionsNode =
+    exports.parseCatalogNode =
+        void 0
+const boom_1 = require('@hapi/boom')
+const crypto_1 = require('crypto')
+const WABinary_1 = require('../WABinary')
+const messages_media_1 = require('./messages-media')
+const parseCatalogNode = (node) => {
+    const catalogNode = (0, WABinary_1.getBinaryNodeChild)(node, 'product_catalog')
+    const products = (0, WABinary_1.getBinaryNodeChildren)(catalogNode, 'product').map(
+        exports.parseProductNode
+    )
+    const paging = (0, WABinary_1.getBinaryNodeChild)(catalogNode, 'paging')
+    return {
+        products,
+        nextPageCursor: paging
+            ? (0, WABinary_1.getBinaryNodeChildString)(paging, 'after')
+            : undefined
+    }
+}
+exports.parseCatalogNode = parseCatalogNode
+const parseCollectionsNode = (node) => {
+    const collectionsNode = (0, WABinary_1.getBinaryNodeChild)(node, 'collections')
+    const collections = (0, WABinary_1.getBinaryNodeChildren)(collectionsNode, 'collection').map(
+        (collectionNode) => {
+            const id = (0, WABinary_1.getBinaryNodeChildString)(collectionNode, 'id')
+            const name = (0, WABinary_1.getBinaryNodeChildString)(collectionNode, 'name')
+            const products = (0, WABinary_1.getBinaryNodeChildren)(collectionNode, 'product').map(
+                exports.parseProductNode
+            )
+            return {
+                id,
+                name,
+                products,
+                status: parseStatusInfo(collectionNode)
+            }
+        }
+    )
+    return {
+        collections
+    }
+}
+exports.parseCollectionsNode = parseCollectionsNode
+const parseOrderDetailsNode = (node) => {
+    const orderNode = (0, WABinary_1.getBinaryNodeChild)(node, 'order')
+    const products = (0, WABinary_1.getBinaryNodeChildren)(orderNode, 'product').map(
+        (productNode) => {
+            const imageNode = (0, WABinary_1.getBinaryNodeChild)(productNode, 'image')
+            return {
+                id: (0, WABinary_1.getBinaryNodeChildString)(productNode, 'id'),
+                name: (0, WABinary_1.getBinaryNodeChildString)(productNode, 'name'),
+                imageUrl: (0, WABinary_1.getBinaryNodeChildString)(imageNode, 'url'),
+                price: +(0, WABinary_1.getBinaryNodeChildString)(productNode, 'price'),
+                currency: (0, WABinary_1.getBinaryNodeChildString)(productNode, 'currency'),
+                quantity: +(0, WABinary_1.getBinaryNodeChildString)(productNode, 'quantity')
+            }
+        }
+    )
+    const priceNode = (0, WABinary_1.getBinaryNodeChild)(orderNode, 'price')
+    const orderDetails = {
+        price: {
+            total: +(0, WABinary_1.getBinaryNodeChildString)(priceNode, 'total'),
+            currency: (0, WABinary_1.getBinaryNodeChildString)(priceNode, 'currency')
+        },
+        products
+    }
+    return orderDetails
+}
+exports.parseOrderDetailsNode = parseOrderDetailsNode
+const toProductNode = (productId, product) => {
+    const attrs = {}
+    const content = []
+    if (typeof productId !== 'undefined') {
+        content.push({
+            tag: 'id',
+            attrs: {},
+            content: Buffer.from(productId)
+        })
+    }
+    if (typeof product.name !== 'undefined') {
+        content.push({
+            tag: 'name',
+            attrs: {},
+            content: Buffer.from(product.name)
+        })
+    }
+    if (typeof product.description !== 'undefined') {
+        content.push({
+            tag: 'description',
+            attrs: {},
+            content: Buffer.from(product.description)
+        })
+    }
+    if (typeof product.retailerId !== 'undefined') {
+        content.push({
+            tag: 'retailer_id',
+            attrs: {},
+            content: Buffer.from(product.retailerId)
+        })
+    }
+    if (product.images.length) {
+        content.push({
+            tag: 'media',
+            attrs: {},
+            content: product.images.map((img) => {
+                if (!('url' in img)) {
+                    throw new boom_1.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 (typeof product.price !== 'undefined') {
+        content.push({
+            tag: 'price',
+            attrs: {},
+            content: Buffer.from(product.price.toString())
+        })
+    }
+    if (typeof product.currency !== 'undefined') {
+        content.push({
+            tag: 'currency',
+            attrs: {},
+            content: Buffer.from(product.currency)
+        })
+    }
+    if ('originCountryCode' in product) {
+        if (typeof 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 (typeof product.isHidden !== 'undefined') {
+        attrs['is_hidden'] = product.isHidden.toString()
+    }
+    const node = {
+        tag: 'product',
+        attrs,
+        content
+    }
+    return node
+}
+exports.toProductNode = toProductNode
+const parseProductNode = (productNode) => {
+    const isHidden = productNode.attrs.is_hidden === 'true'
+    const id = (0, WABinary_1.getBinaryNodeChildString)(productNode, 'id')
+    const mediaNode = (0, WABinary_1.getBinaryNodeChild)(productNode, 'media')
+    const statusInfoNode = (0, WABinary_1.getBinaryNodeChild)(productNode, 'status_info')
+    const product = {
+        id,
+        imageUrls: parseImageUrls(mediaNode),
+        reviewStatus: {
+            whatsapp: (0, WABinary_1.getBinaryNodeChildString)(statusInfoNode, 'status')
+        },
+        availability: 'in stock',
+        name: (0, WABinary_1.getBinaryNodeChildString)(productNode, 'name'),
+        retailerId: (0, WABinary_1.getBinaryNodeChildString)(productNode, 'retailer_id'),
+        url: (0, WABinary_1.getBinaryNodeChildString)(productNode, 'url'),
+        description: (0, WABinary_1.getBinaryNodeChildString)(productNode, 'description'),
+        price: +(0, WABinary_1.getBinaryNodeChildString)(productNode, 'price'),
+        currency: (0, WABinary_1.getBinaryNodeChildString)(productNode, 'currency'),
+        isHidden
+    }
+    return product
+}
+exports.parseProductNode = parseProductNode
+/**
+ * Uploads images not already uploaded to WA's servers
+ */
+async function uploadingNecessaryImagesOfProduct(product, waUploadToServer, timeoutMs = 30000) {
+    product = {
+        ...product,
+        images: product.images
+            ? await (0, exports.uploadingNecessaryImages)(
+                  product.images,
+                  waUploadToServer,
+                  timeoutMs
+              )
+            : product.images
+    }
+    return product
+}
+exports.uploadingNecessaryImagesOfProduct = uploadingNecessaryImagesOfProduct
+/**
+ * Uploads images not already uploaded to WA's servers
+ */
+const uploadingNecessaryImages = async (images, waUploadToServer, timeoutMs = 30000) => {
+    const results = await Promise.all(
+        images.map(async (img) => {
+            if ('url' in img) {
+                const url = img.url.toString()
+                if (url.includes('.whatsapp.net')) {
+                    return { url }
+                }
+            }
+            const { stream } = await (0, messages_media_1.getStream)(img)
+            const hasher = (0, crypto_1.createHash)('sha256')
+            const contentBlocks = []
+            for await (const block of stream) {
+                hasher.update(block)
+                contentBlocks.push(block)
+            }
+            const sha = hasher.digest('base64')
+            const { directPath } = await waUploadToServer(
+                (0, messages_media_1.toReadable)(Buffer.concat(contentBlocks)),
+                {
+                    mediaType: 'product-catalog-image',
+                    fileEncSha256B64: sha,
+                    timeoutMs
+                }
+            )
+            return { url: (0, messages_media_1.getUrlFromDirectPath)(directPath) }
+        })
+    )
+    return results
+}
+exports.uploadingNecessaryImages = uploadingNecessaryImages
+const parseImageUrls = (mediaNode) => {
+    const imgNode = (0, WABinary_1.getBinaryNodeChild)(mediaNode, 'image')
+    return {
+        requested: (0, WABinary_1.getBinaryNodeChildString)(imgNode, 'request_image_url'),
+        original: (0, WABinary_1.getBinaryNodeChildString)(imgNode, 'original_image_url')
+    }
+}
+const parseStatusInfo = (mediaNode) => {
+    const node = (0, WABinary_1.getBinaryNodeChild)(mediaNode, 'status_info')
+    return {
+        status: (0, WABinary_1.getBinaryNodeChildString)(node, 'status'),
+        canAppeal: (0, WABinary_1.getBinaryNodeChildString)(node, 'can_appeal') === 'true'
+    }
+}