@leonoremods/baileys 0.0.0-stage → 1.2.9

package/src/Utils/use-multi-file-auth-state.js

@@ -0,0 +1,111 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.useMultiFileAuthState = void 0;
+const async_mutex_1 = require('async-mutex');
+const promises_1 = require('fs/promises');
+const path_1 = require('path');
+const index_js_1 = require('../../WAProto/index.js');
+const auth_utils_1 = require('./auth-utils');
+const generics_1 = require('./generics');
+const fileLocks = new Map();
+const getFileLock = path => {
+    let mutex = fileLocks.get(path);
+    if (!mutex) {
+        mutex = new async_mutex_1.Mutex();
+        fileLocks.set(path, mutex);
+    }
+    return mutex;
+};
+const useMultiFileAuthState = async (folder) => {
+    const writeData = async (data, file) => {
+        const filePath = (0, path_1.join)(folder, fixFileName(file));
+        const mutex = getFileLock(filePath);
+        return mutex.acquire().then(async (release) => {
+            try {
+                await (0, promises_1.writeFile)(filePath, JSON.stringify(data, generics_1.BufferJSON.replacer));
+            }
+            finally {
+                release();
+            }
+        });
+    };
+    const readData = async (file) => {
+        try {
+            const filePath = (0, path_1.join)(folder, fixFileName(file));
+            const mutex = getFileLock(filePath);
+            return await mutex.acquire().then(async (release) => {
+                try {
+                    const data = await (0, promises_1.readFile)(filePath, { encoding: 'utf-8' });
+                    return JSON.parse(data, generics_1.BufferJSON.reviver);
+                }
+                finally {
+                    release();
+                }
+            });
+        }
+        catch (error) {
+            return null;
+        }
+    };
+    const removeData = async (file) => {
+        try {
+            const filePath = (0, path_1.join)(folder, fixFileName(file));
+            const mutex = getFileLock(filePath);
+            return mutex.acquire().then(async (release) => {
+                try {
+                    await (0, promises_1.unlink)(filePath);
+                }
+                catch {
+                }
+                finally {
+                    release();
+                }
+            });
+        }
+        catch { }
+    };
+    const folderInfo = await (0, promises_1.stat)(folder).catch(() => { });
+    if (folderInfo) {
+        if (!folderInfo.isDirectory()) {
+            throw new Error(`found something that is not a directory at ${folder}, either delete it or specify a different location`);
+        }
+    }
+    else {
+        await (0, promises_1.mkdir)(folder, { recursive: true });
+    }
+    const fixFileName = file => file?.replace(/\//g, '__')?.replace(/:/g, '-');
+    const creds = (await readData('creds.json')) || (0, auth_utils_1.initAuthCreds)();
+    return {
+        state: {
+            creds,
+            keys: {
+                get: async (type, ids) => {
+                    const data = {};
+                    await Promise.all(ids.map(async (id) => {
+                        let value = await readData(`${type}-${id}.json`);
+                        if (type === 'app-state-sync-key' && value) {
+                            value = index_js_1.proto.Message.AppStateSyncKeyData.fromObject(value);
+                        }
+                        data[id] = value;
+                    }));
+                    return data;
+                },
+                set: async (data) => {
+                    const tasks = [];
+                    for (const category in data) {
+                        for (const id in data[category]) {
+                            const value = data[category][id];
+                            const file = `${category}-${id}.json`;
+                            tasks.push(value ? writeData(value, file) : removeData(file));
+                        }
+                    }
+                    await Promise.all(tasks);
+                }
+            }
+        },
+        saveCreds: async () => {
+            return writeData(creds, 'creds.json');
+        }
+    };
+};
+exports.useMultiFileAuthState = useMultiFileAuthState;

package/src/Utils/validate-connection.js

@@ -0,0 +1,209 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.encodeSignedDeviceIdentity =
+    exports.configureSuccessfulPairing =
+        exports.generateRegistrationNode =
+            exports.generateLoginNode =
+                void 0;
+const boom_1 = require('@hapi/boom');
+const crypto_1 = require('crypto');
+const Crypto_1 = require('./crypto');
+const index_js_1 = require('../../WAProto/index.js');
+const Defaults_1 = require('../Defaults');
+const WABinary_1 = require('../WABinary');
+const crypto_2 = require('./crypto');
+const generics_1 = require('./generics');
+const signal_1 = require('./signal');
+const getUserAgent = config => {
+    return {
+        appVersion: {
+            primary: config.version[0],
+            secondary: config.version[1],
+            tertiary: config.version[2]
+        },
+        platform: index_js_1.proto.ClientPayload.UserAgent.Platform.WEB,
+        releaseChannel: index_js_1.proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
+        osVersion: '0.1',
+        device: 'Desktop',
+        osBuildNumber: '0.1',
+        localeLanguageIso6391: 'en',
+        mnc: '000',
+        mcc: '000',
+        localeCountryIso31661Alpha2: config.countryCode
+    };
+};
+const PLATFORM_MAP = {
+    'Mac OS': index_js_1.proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
+    Windows: index_js_1.proto.ClientPayload.WebInfo.WebSubPlatform.WIN32
+};
+const getWebInfo = config => {
+    let webSubPlatform = index_js_1.proto.ClientPayload.WebInfo.WebSubPlatform.WEB_BROWSER;
+    if (config.syncFullHistory && PLATFORM_MAP[config.browser[0]] && config.browser[1] === 'Desktop') {
+        webSubPlatform = PLATFORM_MAP[config.browser[0]];
+    }
+    return { webSubPlatform };
+};
+const getClientPayload = config => {
+    const payload = {
+        connectType: index_js_1.proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
+        connectReason: index_js_1.proto.ClientPayload.ConnectReason.USER_ACTIVATED,
+        userAgent: getUserAgent(config)
+    };
+    payload.webInfo = getWebInfo(config);
+    return payload;
+};
+const generateLoginNode = (userJid, config, creds) => {
+    const { user, device } = (0, WABinary_1.jidDecode)(userJid);
+    const effectiveDevice = config.masqueradeAsPrimary ? 0 : device;
+    const payload = {
+        ...getClientPayload(config),
+        passive: !config.masqueradeAsPrimary,
+        pull: !config.masqueradeAsPrimary,
+        username: +user,
+        device: effectiveDevice,
+        lidDbMigrated: false
+    };
+    if (creds?.interopData?.accountId) {
+        payload.interopData = {
+            accountId: creds.interopData.accountId,
+            token: creds.interopData.token,
+            enableReadReceipts: creds.interopData.enableReadReceipts ?? true
+        };
+    }
+    return index_js_1.proto.ClientPayload.fromObject(payload);
+};
+exports.generateLoginNode = generateLoginNode;
+const getPlatformType = platform => {
+    const platformType = platform.toUpperCase();
+    return index_js_1.proto.DeviceProps.PlatformType[platformType] || index_js_1.proto.DeviceProps.PlatformType.CHROME;
+};
+const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentityKey }, config) => {
+    const appVersionBuf = Buffer.from(Crypto_1.md5(Buffer.from(config.version.join('.'))));
+    const companion = {
+        os: config.browser[0],
+        platformType: getPlatformType(config.browser[1]),
+        requireFullSync: config.syncFullHistory,
+        historySyncConfig: {
+            storageQuotaMb: 10240,
+            inlineInitialPayloadInE2EeMsg: true,
+            recentSyncDaysLimit: undefined,
+            supportCallLogHistory: false,
+            supportBotUserAgentChatHistory: true,
+            supportCagReactionsAndPolls: true,
+            supportBizHostedMsg: true,
+            supportRecentSyncChunkMessageCountTuning: true,
+            supportHostedGroupMsg: true,
+            supportFbidBotChatHistory: true,
+            supportAddOnHistorySyncMigration: undefined,
+            supportMessageAssociation: true,
+            supportGroupHistory: false,
+            onDemandReady: undefined,
+            supportGuestChat: undefined
+        },
+        version: {
+            primary: 10,
+            secondary: 15,
+            tertiary: 7
+        }
+    };
+    const companionProto = index_js_1.proto.DeviceProps.encode(companion).finish();
+    const registerPayload = {
+        ...getClientPayload(config),
+        passive: false,
+        pull: false,
+        devicePairingData: {
+            buildHash: appVersionBuf,
+            deviceProps: companionProto,
+            eRegid: (0, generics_1.encodeBigEndian)(registrationId),
+            eKeytype: Defaults_1.KEY_BUNDLE_TYPE,
+            eIdent: signedIdentityKey.public,
+            eSkeyId: (0, generics_1.encodeBigEndian)(signedPreKey.keyId, 3),
+            eSkeyVal: signedPreKey.keyPair.public,
+            eSkeySig: signedPreKey.signature
+        }
+    };
+    return index_js_1.proto.ClientPayload.fromObject(registerPayload);
+};
+exports.generateRegistrationNode = generateRegistrationNode;
+const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, signalIdentities }) => {
+    const msgId = stanza.attrs.id;
+    const pairSuccessNode = (0, WABinary_1.getBinaryNodeChild)(stanza, 'pair-success');
+    const deviceIdentityNode = (0, WABinary_1.getBinaryNodeChild)(pairSuccessNode, 'device-identity');
+    const platformNode = (0, WABinary_1.getBinaryNodeChild)(pairSuccessNode, 'platform');
+    const deviceNode = (0, WABinary_1.getBinaryNodeChild)(pairSuccessNode, 'device');
+    const businessNode = (0, WABinary_1.getBinaryNodeChild)(pairSuccessNode, 'biz');
+    if (!deviceIdentityNode || !deviceNode) {
+        throw new boom_1.Boom('Missing device-identity or device in pair success node', { data: stanza });
+    }
+    const bizName = businessNode?.attrs.name;
+    const jid = deviceNode.attrs.jid;
+    const lid = deviceNode.attrs.lid;
+    const { details, hmac, accountType } = index_js_1.proto.ADVSignedDeviceIdentityHMAC.decode(deviceIdentityNode.content);
+    let hmacPrefix = Buffer.from([]);
+    if (accountType !== undefined && accountType === index_js_1.proto.ADVEncryptionType.HOSTED) {
+        hmacPrefix = Defaults_1.WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX;
+    }
+    const advSign = (0, crypto_2.hmacSign)(Buffer.concat([hmacPrefix, details]), Buffer.from(advSecretKey, 'base64'));
+    if (Buffer.compare(hmac, advSign) !== 0) {
+        throw new boom_1.Boom('Invalid account signature');
+    }
+    const account = index_js_1.proto.ADVSignedDeviceIdentity.decode(details);
+    const { accountSignatureKey, accountSignature, details: deviceDetails } = account;
+    const deviceIdentity = index_js_1.proto.ADVDeviceIdentity.decode(deviceDetails);
+    const accountSignaturePrefix = deviceIdentity.deviceType === index_js_1.proto.ADVEncryptionType.HOSTED
+        ? Defaults_1.WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX
+        : Defaults_1.WA_ADV_ACCOUNT_SIG_PREFIX;
+    const accountMsg = Buffer.concat([accountSignaturePrefix, deviceDetails, signedIdentityKey.public]);
+    if (!crypto_2.Curve.verify(accountSignatureKey, accountMsg, accountSignature)) {
+        throw new boom_1.Boom('Failed to verify account signature');
+    }
+    const deviceMsg = Buffer.concat([
+        Defaults_1.WA_ADV_DEVICE_SIG_PREFIX,
+        deviceDetails,
+        signedIdentityKey.public,
+        accountSignatureKey
+    ]);
+    account.deviceSignature = crypto_2.Curve.sign(signedIdentityKey.private, deviceMsg);
+    const identity = (0, signal_1.createSignalIdentity)(lid, accountSignatureKey);
+    const accountEnc = (0, exports.encodeSignedDeviceIdentity)(account, false);
+    const reply = {
+        tag: 'iq',
+        attrs: {
+            to: WABinary_1.S_WHATSAPP_NET,
+            type: 'result',
+            id: msgId
+        },
+        content: [
+            {
+                tag: 'pair-device-sign',
+                attrs: {},
+                content: [
+                    {
+                        tag: 'device-identity',
+                        attrs: { 'key-index': deviceIdentity.keyIndex.toString() },
+                        content: accountEnc
+                    }
+                ]
+            }
+        ]
+    };
+    const authUpdate = {
+        account,
+        me: { id: jid, name: bizName, lid },
+        signalIdentities: [...(signalIdentities || []), identity],
+        platform: platformNode?.attrs.name
+    };
+    return {
+        creds: authUpdate,
+        reply
+    };
+};
+exports.configureSuccessfulPairing = configureSuccessfulPairing;
+const encodeSignedDeviceIdentity = (account, includeSignatureKey) => {
+    account = { ...account };
+    if (!includeSignatureKey || !account.accountSignatureKey?.length) {
+        account.accountSignatureKey = null;
+    }
+    return index_js_1.proto.ADVSignedDeviceIdentity.encode(account).finish();
+};
+exports.encodeSignedDeviceIdentity = encodeSignedDeviceIdentity;

package/src/Utils/view-once-cache.d.ts

@@ -0,0 +1,12 @@
+export interface AutoCacheViewOnceOptions {
+    cacheDir?: string;
+    logger?: any;
+    onCached?: (info: {
+        id: string;
+        jid: string;
+        filePath: string;
+        type: string;
+    }) => void;
+}
+export function getViewOnceContent(message: any): Record<string, any> | null;
+export function autoCacheViewOnceMedia(sock: any, options?: AutoCacheViewOnceOptions): () => void;

package/src/Utils/view-once-cache.js

@@ -0,0 +1,63 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.autoCacheViewOnceMedia = void 0;
+const path = require('path');
+const fs = require('fs');
+const Messages_1 = require('./messages');
+const MessagesMedia_1 = require('./messages-media');
+const VIEW_ONCE_WRAPPER_KEYS = ['viewOnceMessage', 'viewOnceMessageV2', 'viewOnceMessageV2Extension'];
+const VIEW_ONCE_INNER_KEYS = ['imageMessage', 'videoMessage', 'audioMessage'];
+const getViewOnceContent = message => {
+    if (!message)
+        return null;
+    const content = (0, Messages_1.extractMessageContent)(message);
+    if (!content)
+        return null;
+    for (const wrapperKey of VIEW_ONCE_WRAPPER_KEYS) {
+        const wrapper = content[wrapperKey];
+        if (wrapper?.message) {
+            const inner = (0, Messages_1.extractMessageContent)(wrapper.message);
+            if (inner)
+                return inner;
+        }
+    }
+    for (const key of VIEW_ONCE_INNER_KEYS) {
+        if (content[key]?.viewOnce) {
+            return { [key]: content[key] };
+        }
+    }
+    return null;
+};
+const autoCacheViewOnceMedia = (sock, options = {}) => {
+    const cacheDir = options.cacheDir || './viewonce-cache';
+    const logger = options.logger || sock.logger;
+    if (!fs.existsSync(cacheDir)) {
+        fs.mkdirSync(cacheDir, { recursive: true });
+    }
+    const handler = async ({ messages, type }) => {
+        if (type !== 'notify' && type !== 'append')
+            return;
+        for (const msg of messages) {
+            try {
+                const viewOnceContent = getViewOnceContent(msg.message);
+                if (!viewOnceContent)
+                    continue;
+                const mediaType = Object.keys(viewOnceContent)[0];
+                const buffer = await (0, Messages_1.downloadMediaMessage)(msg, 'buffer', {}, { logger, reuploadRequest: sock.updateMediaMessage });
+                const extension = (0, MessagesMedia_1.extensionForMediaMessage)(viewOnceContent) || 'bin';
+                const fileName = `${msg.key.id}.${extension}`;
+                const filePath = path.join(cacheDir, fileName);
+                fs.writeFileSync(filePath, buffer);
+                logger?.debug?.({ id: msg.key.id, filePath, mediaType }, 'cached view-once media');
+                options.onCached?.({ id: msg.key.id, jid: msg.key.remoteJid, filePath, type: mediaType });
+            }
+            catch (error) {
+                logger?.warn?.({ error, id: msg.key?.id }, 'failed to cache view-once media');
+            }
+        }
+    };
+    sock.ev.on('messages.upsert', handler);
+    return () => sock.ev.off('messages.upsert', handler);
+};
+exports.autoCacheViewOnceMedia = autoCacheViewOnceMedia;
+exports.getViewOnceContent = getViewOnceContent;

package/src/Utils/voip-rekey.js

@@ -0,0 +1,22 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.decodeE2eRekeyPayload = void 0;
+const index_js_1 = require('../../WAProto/index.js');
+const REKEY_TYPE_NAMES = {
+    [index_js_1.proto.RekeyKeyType.REKEY_KEY_AUDIO]: 'REKEY_KEY_AUDIO',
+    [index_js_1.proto.RekeyKeyType.REKEY_KEY_VIDEO]: 'REKEY_KEY_VIDEO',
+    [index_js_1.proto.RekeyKeyType.REKEY_KEY_APPDATA]: 'REKEY_KEY_APPDATA'
+};
+const decodeE2eRekeyPayload = buffer => {
+    if (!Buffer.isBuffer(buffer) && !(buffer instanceof Uint8Array)) {
+        throw new TypeError('decodeE2eRekeyPayload: buffer must be Buffer or Uint8Array');
+    }
+    const decoded = index_js_1.proto.E2eRekeyPayload.decode(buffer);
+    return {
+        keys: (decoded.keys || []).map(entry => ({
+            type: REKEY_TYPE_NAMES[entry.type] ?? entry.type,
+            key: entry.key ? Buffer.from(entry.key) : Buffer.alloc(0)
+        }))
+    };
+};
+exports.decodeE2eRekeyPayload = decodeE2eRekeyPayload;