plogme 1.0.0

package/lib/Socket/ban-checker.js

@@ -0,0 +1,153 @@
+import { randomBytes, randomUUID } from 'crypto';
+import { initAuthCreds } from '../Utils/auth-utils.js';
+import { Curve, md5, signedKeyPair } from '../Utils/crypto.js';
+import {
+    GRAPHQL_ACCESS_TOKEN,
+    GRAPHQL_BAN_STATUS_DOC_ID,
+    GRAPHQL_ENDPOINT,
+    MOBILE_COUNTRY_CODE,
+    MOBILE_REGISTRATION_ENDPOINT,
+    MOBILE_TOKEN,
+    MOBILE_USERAGENT
+} from '../Defaults/ban-checker.js';
+
+const COUNTRY_CODES = [
+    '1', '20', '27', '30', '31', '32', '33', '34', '36', '39', '40', '41', '43', '44', '45', '46', '47', '48', '49',
+    '51', '52', '53', '54', '55', '56', '57', '58', '60', '61', '62', '63', '64', '65', '66', '81', '82', '84', '86',
+    '90', '91', '92', '93', '94', '95', '98', '211', '212', '213', '216', '218', '220', '221', '222', '223', '224', '225',
+    '226', '227', '228', '229', '230', '231', '232', '233', '234', '235', '236', '237', '238', '239', '240', '241', '242',
+    '243', '244', '245', '246', '248', '249', '250', '251', '252', '253', '254', '255', '256', '257', '258', '260', '261',
+    '262', '263', '264', '265', '266', '267', '268', '269', '290', '291', '297', '298', '299', '350', '351', '352', '353',
+    '354', '355', '356', '357', '358', '359', '370', '371', '372', '373', '374', '375', '376', '377', '378', '380', '381',
+    '382', '383', '385', '386', '387', '389', '420', '421', '423', '500', '501', '502', '503', '504', '505', '506', '507',
+    '508', '509', '590', '591', '592', '593', '594', '595', '596', '597', '598', '599', '670', '672', '673', '674', '675',
+    '676', '677', '678', '679', '680', '681', '682', '683', '685', '686', '687', '688', '689', '690', '691', '692', '850',
+    '852', '853', '855', '856', '880', '886', '960', '961', '962', '963', '964', '965', '966', '967', '968', '970', '971',
+    '972', '973', '974', '975', '976', '977', '992', '993', '994', '995', '996', '998'
+].sort((a, b) => b.length - a.length);
+
+const PLACEHOLDER = /^REPLACE_WITH_/;
+
+const cleanNumber = (value) => String(value || '').replace(/[\s().\-/]/g, '').replace(/^00/, '');
+
+const normalizePhone = (value, options = {}) => {
+    const raw = cleanNumber(typeof value === 'object' ? value.number : value).replace(/^\+/, '');
+    if (!/^\d{6,15}$/.test(raw)) throw new TypeError('number must be an international phone number');
+    const requestedCountry = String(options.countryCode || MOBILE_COUNTRY_CODE || '').replace(/\D/g, '');
+    const countryCode = requestedCountry || COUNTRY_CODES.find((code) => raw.startsWith(code));
+    if (!countryCode || !raw.startsWith(countryCode)) throw new TypeError('number must include a recognized country calling code');
+    const nationalNumber = raw.slice(countryCode.length);
+    if (!nationalNumber) throw new TypeError('number is missing its national part');
+    return { countryCode, nationalNumber, e164: `+${raw}` };
+};
+
+const urlEncode = (value) => encodeURIComponent(String(value)).replace(/%25([0-9a-f]{2})/gi, '%$1');
+const urlHex = (buffer) => [...buffer].map((byte) => `%${byte.toString(16).padStart(2, '0')}`).join('');
+
+const makeRegistrationParams = (countryCode, nationalNumber) => {
+    const creds = initAuthCreds();
+    const eRegId = Buffer.alloc(4);
+    eRegId.writeInt32BE(creds.registrationId);
+    const eSkeyId = Buffer.alloc(3);
+    eSkeyId.writeInt16BE(creds.signedPreKey.keyId);
+    return {
+        cc: countryCode,
+        in: nationalNumber,
+        Rc: '0', lg: 'en', lc: 'GB', mistyped: '6',
+        authkey: Buffer.from(creds.noiseKey.public).toString('base64url'),
+        e_regid: eRegId.toString('base64url'),
+        e_keytype: 'BQ',
+        e_ident: Buffer.from(creds.signedIdentityKey.public).toString('base64url'),
+        e_skey_id: eSkeyId.toString('base64url'),
+        e_skey_val: Buffer.from(creds.signedPreKey.keyPair.public).toString('base64url'),
+        e_skey_sig: Buffer.from(creds.signedPreKey.signature).toString('base64url'),
+        fdid: randomUUID(),
+        network_ratio_type: '1', expid: randomUUID(), simnum: '1', hasinrc: '1',
+        pid: String(Math.floor(Math.random() * 1000)),
+        id: urlHex(randomBytes(16)),
+        backup_token: urlHex(randomBytes(32)),
+        token: Buffer.from(md5(Buffer.concat([MOBILE_TOKEN, Buffer.from(nationalNumber)]))).toString('hex')
+    };
+};
+
+const requestJson = async (url, options = {}) => {
+    const response = await fetch(url, { ...options, headers: { 'User-Agent': MOBILE_USERAGENT, ...(options.headers || {}) } });
+    let body = null;
+    try { body = await response.json(); } catch { body = {}; }
+    return { response, body };
+};
+
+const getBanDetails = async (appealToken) => {
+    if (!appealToken || PLACEHOLDER.test(GRAPHQL_ACCESS_TOKEN) || PLACEHOLDER.test(GRAPHQL_BAN_STATUS_DOC_ID)) return null;
+    const { response, body } = await requestJson(GRAPHQL_ENDPOINT, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            variables: JSON.stringify({ app_id: 'dev.app.id', request_token: appealToken }),
+            access_token: GRAPHQL_ACCESS_TOKEN,
+            doc_id: GRAPHQL_BAN_STATUS_DOC_ID,
+            lang: 'en_GB'
+        })
+    });
+    if (!response.ok) return null;
+    return body?.data?.whatsapp_support_ban_appeal_status || null;
+};
+
+const result = (number, status, isBanned = false, isNeedOfficialWa = false, banInfo = null) => ({ number, status, isBanned, isNeedOfficialWa, banInfo });
+
+const getDiagnostic = (response, body) => {
+    const bodyObject = body && typeof body === 'object' && !Array.isArray(body) ? body : {};
+    const nestedData = bodyObject.data && typeof bodyObject.data === 'object' && !Array.isArray(bodyObject.data)
+        ? bodyObject.data
+        : {};
+    const keys = Object.keys(bodyObject).sort();
+    return {
+        httpStatus: Number.isInteger(response?.status) ? response.status : null,
+        ok: response?.ok === true,
+        contentType: response?.headers?.get?.('content-type') || null,
+        bodyKeys: keys,
+        dataKeys: Object.keys(nestedData).sort(),
+        signals: {
+            hasReason: Object.prototype.hasOwnProperty.call(bodyObject, 'reason'),
+            hasError: Object.prototype.hasOwnProperty.call(bodyObject, 'error'),
+            hasStatus: Object.prototype.hasOwnProperty.call(bodyObject, 'status'),
+            hasAppealToken: Boolean(bodyObject.appeal_token || bodyObject.appealToken || nestedData.appeal_token),
+            hasBanFields: Boolean(bodyObject.ban_type || bodyObject.banType || bodyObject.violation_type || bodyObject.violationType)
+        }
+    };
+};
+
+const withDiagnostic = (value, diagnostic) => diagnostic ? { ...value, diagnostics: diagnostic } : value;
+
+export const checkStatusWA = async (number, options = {}) => {
+    const normalized = normalizePhone(number, options);
+    const params = makeRegistrationParams(normalized.countryCode, normalized.nationalNumber);
+    const query = Object.entries(params).map(([key, value]) => `${key}=${urlEncode(value)}`).join('&');
+    const { response, body } = await requestJson(`${MOBILE_REGISTRATION_ENDPOINT}/exist?${query}`);
+    const diagnostic = options.diagnostic === true ? getDiagnostic(response, body) : null;
+    const reason = String(body?.reason || body?.error || body?.status || '').toLowerCase();
+    const appealToken = body?.appeal_token || body?.appealToken || body?.data?.appeal_token;
+
+    if (response.status === 429 || /rate.?limit|too many/.test(reason)) return withDiagnostic(result(normalized.e164, 'rate_limited'), diagnostic);
+    if (/blocked|official/.test(reason) && !appealToken) return withDiagnostic(result(normalized.e164, 'blocked', false, true), diagnostic);
+    if (appealToken || /banned|ban|temporar|perman/.test(reason)) {
+        const details = await getBanDetails(appealToken);
+        const banType = details?.ban_type || details?.banType || body?.ban_type || body?.banType || (reason.includes('perman') ? 'permanent' : 'temporary');
+        return withDiagnostic(result(normalized.e164, 'banned', true, false, {
+            banType,
+            violationType: body?.violation_type || body?.violationType || null,
+            violationReason: body?.violation_reason || body?.violationReason || null,
+            canAppeal: banType !== 'permanent',
+            appealToken: appealToken || null,
+            banTime: details?.ban_time || details?.banTime || null,
+            banDate: details?.ban_date || details?.banDate || null,
+            appealStatus: details?.appeal_status || details?.appealStatus || null,
+            appealCreatedAt: details?.appeal_created_at || details?.appealCreatedAt || null
+        }), diagnostic);
+    }
+    if (response.ok && (!body?.reason || /^(ok|sent|active|registered)$/.test(reason))) return withDiagnostic(result(normalized.e164, 'active'), diagnostic);
+    if (/not.?registered|does.?not.?exist/.test(reason)) return withDiagnostic(result(normalized.e164, 'not_registered'), diagnostic);
+    return withDiagnostic(result(normalized.e164, 'unknown'), diagnostic);
+};
+
+export { getBanDetails, normalizePhone };

package/lib/Socket/business.js

@@ -0,0 +1,407 @@
+import { unlink } from 'node:fs/promises';
+import { getRawMediaUploadData } from '../Utils/index.js';
+import { parseCatalogNode, parseCollectionsNode, parseOrderDetailsNode, parseProductNode, toProductNode, uploadingNecessaryImagesOfProduct } from '../Utils/business.js';
+import { jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js';
+import { getBinaryNodeChild } from '../WABinary/generic-utils.js';
+import { makeMessagesRecvSocket } from './messages-recv.js';
+export const makeBusinessSocket = (config) => {
+    const sock = makeMessagesRecvSocket(config);
+    const { authState, query, waUploadToServer } = sock;
+    const updateBusinessProfile = async (args = {}) => {
+        const node = [];
+        const simpleFields = ['address', 'email', 'description'];
+        node.push(...simpleFields
+            .filter(key => args[key] !== undefined)
+            .map(key => {
+            if (args[key] !== null && typeof args[key] !== 'string') {
+                throw new TypeError(`${key} must be a string or null`);
+            }
+            return {
+                tag: key,
+                attrs: {},
+                content: args[key] ?? ''
+            };
+        }));
+        if (args.websites !== undefined) {
+            if (!Array.isArray(args.websites) || args.websites.some(website => typeof website !== 'string')) {
+                throw new TypeError('websites must be an array of strings');
+            }
+            node.push(...(args.websites.length ? args.websites : ['']).map(website => ({
+                tag: 'website',
+                attrs: {},
+                content: website
+            })));
+        }
+        if (args.hours !== undefined) {
+            if (!args.hours || typeof args.hours.timezone !== 'string' || !Array.isArray(args.hours.days)) {
+                throw new TypeError('hours must contain a timezone string and days array');
+            }
+            node.push({
+                tag: 'business_hours',
+                attrs: { timezone: args.hours.timezone },
+                content: args.hours.days.map(dayConfig => {
+                    if (!dayConfig || typeof dayConfig.day !== 'string' || typeof dayConfig.mode !== 'string') {
+                        throw new TypeError('each business-hours day requires string day and mode values');
+                    }
+                    const base = {
+                        tag: 'business_hours_config',
+                        attrs: {
+                            day_of_week: dayConfig.day,
+                            mode: dayConfig.mode
+                        }
+                    };
+                    if (dayConfig.mode === 'specific_hours') {
+                        const { openTimeInMinutes, closeTimeInMinutes } = dayConfig;
+                        if (!Number.isInteger(openTimeInMinutes) || !Number.isInteger(closeTimeInMinutes)) {
+                            throw new TypeError('specific_hours requires integer openTimeInMinutes and closeTimeInMinutes');
+                        }
+                        return {
+                            ...base,
+                            attrs: {
+                                ...base.attrs,
+                                open_time: String(openTimeInMinutes),
+                                close_time: String(closeTimeInMinutes)
+                            }
+                        };
+                    }
+                    return base;
+                })
+            });
+        }
+        const result = await query({
+            tag: 'iq',
+            attrs: {
+                to: S_WHATSAPP_NET,
+                type: 'set',
+                xmlns: 'w:biz'
+            },
+            content: [
+                {
+                    tag: 'business_profile',
+                    attrs: {
+                        v: '3',
+                        mutation_type: 'delta'
+                    },
+                    content: node
+                }
+            ]
+        });
+        return result;
+    };
+    const updateCoverPhoto = async (photo) => {
+        const { fileSha256, filePath } = await getRawMediaUploadData(photo, 'biz-cover-photo', config.logger);
+        try {
+            const fileSha256B64 = fileSha256.toString('base64');
+            const upload = await waUploadToServer(filePath, {
+                fileEncSha256B64: fileSha256B64,
+                mediaType: 'biz-cover-photo'
+            });
+            const { meta_hmac, fbid, ts } = upload || {};
+            if (fbid === undefined || fbid === null || !meta_hmac || ts === undefined || ts === null) {
+                throw new Error('Business cover photo upload returned incomplete metadata');
+            }
+            await query({
+                tag: 'iq',
+                attrs: {
+                    to: S_WHATSAPP_NET,
+                    type: 'set',
+                    xmlns: 'w:biz'
+                },
+                content: [
+                    {
+                        tag: 'business_profile',
+                        attrs: {
+                            v: '3',
+                            mutation_type: 'delta'
+                        },
+                        content: [
+                            {
+                                tag: 'cover_photo',
+                                attrs: { id: String(fbid), op: 'update', token: String(meta_hmac), ts: String(ts) }
+                            }
+                        ]
+                    }
+                ]
+            });
+            return fbid;
+        }
+        finally {
+            await unlink(filePath).catch(() => undefined);
+        }
+    };
+    const removeCoverPhoto = async (id) => {
+        return await query({
+            tag: 'iq',
+            attrs: {
+                to: S_WHATSAPP_NET,
+                type: 'set',
+                xmlns: 'w:biz'
+            },
+            content: [
+                {
+                    tag: 'business_profile',
+                    attrs: {
+                        v: '3',
+                        mutation_type: 'delta'
+                    },
+                    content: [
+                        {
+                            tag: 'cover_photo',
+                            attrs: { op: 'delete', id }
+                        }
+                    ]
+                }
+            ]
+        });
+    };
+    const getCatalog = async ({ jid, limit, cursor }) => {
+        jid = jid || authState.creds.me?.id;
+        jid = jidNormalizedUser(jid);
+        const queryParamNodes = [
+            {
+                tag: 'limit',
+                attrs: {},
+                content: Buffer.from((limit || 10).toString())
+            },
+            {
+                tag: 'width',
+                attrs: {},
+                content: Buffer.from('100')
+            },
+            {
+                tag: 'height',
+                attrs: {},
+                content: Buffer.from('100')
+            }
+        ];
+        if (cursor) {
+            queryParamNodes.push({
+                tag: 'after',
+                attrs: {},
+                content: cursor
+            });
+        }
+        const result = await query({
+            tag: 'iq',
+            attrs: {
+                to: S_WHATSAPP_NET,
+                type: 'get',
+                xmlns: 'w:biz:catalog'
+            },
+            content: [
+                {
+                    tag: 'product_catalog',
+                    attrs: {
+                        jid,
+                        allow_shop_source: 'true'
+                    },
+                    content: queryParamNodes
+                }
+            ]
+        });
+        return parseCatalogNode(result);
+    };
+    const getCollections = async (jid, limit = 51) => {
+        jid = jid || authState.creds.me?.id;
+        jid = jidNormalizedUser(jid);
+        const result = await query({
+            tag: 'iq',
+            attrs: {
+                to: S_WHATSAPP_NET,
+                type: 'get',
+                xmlns: 'w:biz:catalog',
+                smax_id: '35'
+            },
+            content: [
+                {
+                    tag: 'collections',
+                    attrs: {
+                        biz_jid: jid
+                    },
+                    content: [
+                        {
+                            tag: 'collection_limit',
+                            attrs: {},
+                            content: Buffer.from(limit.toString())
+                        },
+                        {
+                            tag: 'item_limit',
+                            attrs: {},
+                            content: Buffer.from(limit.toString())
+                        },
+                        {
+                            tag: 'width',
+                            attrs: {},
+                            content: Buffer.from('100')
+                        },
+                        {
+                            tag: 'height',
+                            attrs: {},
+                            content: Buffer.from('100')
+                        }
+                    ]
+                }
+            ]
+        });
+        return parseCollectionsNode(result);
+    };
+    const getOrderDetails = async (orderId, tokenBase64) => {
+        const result = await query({
+            tag: 'iq',
+            attrs: {
+                to: S_WHATSAPP_NET,
+                type: 'get',
+                xmlns: 'fb:thrift_iq',
+                smax_id: '5'
+            },
+            content: [
+                {
+                    tag: 'order',
+                    attrs: {
+                        op: 'get',
+                        id: orderId
+                    },
+                    content: [
+                        {
+                            tag: 'image_dimensions',
+                            attrs: {},
+                            content: [
+                                {
+                                    tag: 'width',
+                                    attrs: {},
+                                    content: Buffer.from('100')
+                                },
+                                {
+                                    tag: 'height',
+                                    attrs: {},
+                                    content: Buffer.from('100')
+                                }
+                            ]
+                        },
+                        {
+                            tag: 'token',
+                            attrs: {},
+                            content: Buffer.from(tokenBase64)
+                        }
+                    ]
+                }
+            ]
+        });
+        return parseOrderDetailsNode(result);
+    };
+    const productUpdate = async (productId, update) => {
+        update = await uploadingNecessaryImagesOfProduct(update, waUploadToServer);
+        const editNode = toProductNode(productId, update);
+        const result = await query({
+            tag: 'iq',
+            attrs: {
+                to: S_WHATSAPP_NET,
+                type: 'set',
+                xmlns: 'w:biz:catalog'
+            },
+            content: [
+                {
+                    tag: 'product_catalog_edit',
+                    attrs: { v: '1' },
+                    content: [
+                        editNode,
+                        {
+                            tag: 'width',
+                            attrs: {},
+                            content: '100'
+                        },
+                        {
+                            tag: 'height',
+                            attrs: {},
+                            content: '100'
+                        }
+                    ]
+                }
+            ]
+        });
+        const productCatalogEditNode = getBinaryNodeChild(result, 'product_catalog_edit');
+        const productNode = getBinaryNodeChild(productCatalogEditNode, 'product');
+        return parseProductNode(productNode);
+    };
+    const productCreate = async (create) => {
+        // ensure isHidden is defined
+        create.isHidden = !!create.isHidden;
+        create = await uploadingNecessaryImagesOfProduct(create, waUploadToServer);
+        const createNode = toProductNode(undefined, create);
+        const result = await query({
+            tag: 'iq',
+            attrs: {
+                to: S_WHATSAPP_NET,
+                type: 'set',
+                xmlns: 'w:biz:catalog'
+            },
+            content: [
+                {
+                    tag: 'product_catalog_add',
+                    attrs: { v: '1' },
+                    content: [
+                        createNode,
+                        {
+                            tag: 'width',
+                            attrs: {},
+                            content: '100'
+                        },
+                        {
+                            tag: 'height',
+                            attrs: {},
+                            content: '100'
+                        }
+                    ]
+                }
+            ]
+        });
+        const productCatalogAddNode = getBinaryNodeChild(result, 'product_catalog_add');
+        const productNode = getBinaryNodeChild(productCatalogAddNode, 'product');
+        return parseProductNode(productNode);
+    };
+    const productDelete = async (productIds) => {
+        const result = await query({
+            tag: 'iq',
+            attrs: {
+                to: S_WHATSAPP_NET,
+                type: 'set',
+                xmlns: 'w:biz:catalog'
+            },
+            content: [
+                {
+                    tag: 'product_catalog_delete',
+                    attrs: { v: '1' },
+                    content: productIds.map(id => ({
+                        tag: 'product',
+                        attrs: {},
+                        content: [
+                            {
+                                tag: 'id',
+                                attrs: {},
+                                content: Buffer.from(id)
+                            }
+                        ]
+                    }))
+                }
+            ]
+        });
+        const productCatalogDelNode = getBinaryNodeChild(result, 'product_catalog_delete');
+        return {
+            deleted: +(productCatalogDelNode?.attrs.deleted_count || 0)
+        };
+    };
+    return {
+        ...sock,
+        logger: config.logger,
+        getOrderDetails,
+        getCatalog,
+        getCollections,
+        productCreate,
+        productDelete,
+        productUpdate,
+        updateBussinesProfile: updateBusinessProfile,
+        updateBusinessProfile,
+        updateCoverPhoto,
+        removeCoverPhoto
+    };
+};