@fhynella/baileys 1.2.1

package/lib/Types/LabelAssociation.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LabelAssociationType = void 0;
+/** Association type */
+var LabelAssociationType;
+(function (LabelAssociationType) {
+    LabelAssociationType["Chat"] = "label_jid";
+    LabelAssociationType["Message"] = "label_message";
+})(LabelAssociationType || (exports.LabelAssociationType = LabelAssociationType = {}));

package/lib/Types/Message.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WAMessageStatus = exports.WAMessageStubType = exports.WAProto = void 0;
+const WAProto_1 = require("../../WAProto");
+Object.defineProperty(exports, "WAProto", { enumerable: true, get: function () { return WAProto_1.proto; } });
+exports.WAMessageStubType = WAProto_1.proto.WebMessageInfo.StubType;
+exports.WAMessageStatus = WAProto_1.proto.WebMessageInfo.Status;

package/lib/Types/Newsletter.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XWAPaths = exports.MexOperations = void 0;
+var MexOperations;
+(function (MexOperations) {
+    MexOperations["PROMOTE"] = "NotificationNewsletterAdminPromote";
+    MexOperations["DEMOTE"] = "NotificationNewsletterAdminDemote";
+    MexOperations["UPDATE"] = "NotificationNewsletterUpdate";
+})(MexOperations || (exports.MexOperations = MexOperations = {}));
+var XWAPaths;
+(function (XWAPaths) {
+    XWAPaths["PROMOTE"] = "xwa2_notify_newsletter_admin_promote";
+    XWAPaths["DEMOTE"] = "xwa2_notify_newsletter_admin_demote";
+    XWAPaths["ADMIN_COUNT"] = "xwa2_newsletter_admin";
+    XWAPaths["CREATE"] = "xwa2_newsletter_create";
+    XWAPaths["NEWSLETTER"] = "xwa2_newsletter";
+    XWAPaths["METADATA_UPDATE"] = "xwa2_notify_newsletter_on_metadata_update";
+})(XWAPaths || (exports.XWAPaths = XWAPaths = {}));

package/lib/Types/Product.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/Types/Signal.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/Types/Socket.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/Types/State.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/Types/USync.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/Types/index.js

@@ -0,0 +1,42 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DisconnectReason = void 0;
+__exportStar(require("./Auth"), exports);
+__exportStar(require("./GroupMetadata"), exports);
+__exportStar(require("./Newsletter"), exports);
+__exportStar(require("./Chat"), exports);
+__exportStar(require("./Contact"), exports);
+__exportStar(require("./State"), exports);
+__exportStar(require("./Message"), exports);
+__exportStar(require("./Socket"), exports);
+__exportStar(require("./Events"), exports);
+__exportStar(require("./Product"), exports);
+__exportStar(require("./Call"), exports);
+__exportStar(require("./Signal"), exports);
+var DisconnectReason;
+(function (DisconnectReason) {
+    DisconnectReason[DisconnectReason["connectionClosed"] = 428] = "connectionClosed";
+    DisconnectReason[DisconnectReason["connectionLost"] = 408] = "connectionLost";
+    DisconnectReason[DisconnectReason["connectionReplaced"] = 440] = "connectionReplaced";
+    DisconnectReason[DisconnectReason["timedOut"] = 408] = "timedOut";
+    DisconnectReason[DisconnectReason["loggedOut"] = 401] = "loggedOut";
+    DisconnectReason[DisconnectReason["badSession"] = 500] = "badSession";
+    DisconnectReason[DisconnectReason["restartRequired"] = 515] = "restartRequired";
+    DisconnectReason[DisconnectReason["multideviceMismatch"] = 411] = "multideviceMismatch";
+    DisconnectReason[DisconnectReason["forbidden"] = 403] = "forbidden";
+    DisconnectReason[DisconnectReason["unavailableService"] = 503] = "unavailableService";
+})(DisconnectReason || (exports.DisconnectReason = DisconnectReason = {}));

package/lib/Utils/auth-utils.js

@@ -0,0 +1,199 @@
+"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 = void 0;
+exports.makeCacheableSignalKeyStore = makeCacheableSignalKeyStore;
+const crypto_1 = require("crypto");
+const node_cache_1 = __importDefault(require("@cacheable/node-cache"));
+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, // 5 minutes
+        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 === null || logger === void 0 ? void 0 : 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 === null || logger === void 0 ? void 0 : 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));
+        }
+    };
+}
+/**
+ * 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
+        },
+        registered: false,
+        pairingCode: undefined,
+        lastPropHash: undefined,
+        routingInfo: undefined,
+    };
+};
+exports.initAuthCreds = initAuthCreds;

package/lib/Utils/browser-utils.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPlatformId = exports.Browsers = void 0;
+
+const os = require("os");
+const { proto } = require("../../WAProto/index.js"); 
+
+const PLATFORM_MAP = {
+    'aix': 'AIX',
+    'darwin': 'Mac OS',
+    'win32': 'Windows',
+    'android': 'Android',
+    'freebsd': 'FreeBSD',
+    'openbsd': 'OpenBSD',
+    'sunos': 'Solaris',
+    'linux': undefined,  // Default ke Ubuntu untuk Linux
+    'haiku': undefined,
+    'cygwin': undefined,
+    'netbsd': undefined
+};
+
+// Fixed: Browsers sekarang fungsi yang return array [platform, browser, version]
+// Ini kompatibel dengan pemanggilan Browsers('Chrome') di Defaults/index.js
+exports.Browsers = (browser) => {
+    const osName = PLATFORM_MAP[os.platform()] || 'Ubuntu';  // Default Ubuntu kalau undefined
+    const osRelease = os.release();  // Ambil versi OS real-time
+    return [osName, browser, osRelease];
+};
+
+const getPlatformId = (browser) => {
+    const platformType = proto.DeviceProps.PlatformType[browser.toUpperCase()];
+    return platformType ? platformType.toString() : '1'; // Default Chrome
+};
+
+exports.getPlatformId = getPlatformId;

package/lib/Utils/business.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadingNecessaryImages = exports.parseProductNode = exports.toProductNode = exports.parseOrderDetailsNode = exports.parseCollectionsNode = exports.parseCatalogNode = void 0;
+exports.uploadingNecessaryImagesOfProduct = uploadingNecessaryImagesOfProduct;
+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;
+}
+/**
+ * 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',
+    };
+};