@heavstaltech/baileys 2.3.4 → 3.2.4

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

@@ -1,295 +1,119 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useMultiFileAuthState = void 0;
-const async_lock_1 = __importDefault(require("async-lock"));
+const async_mutex_1 = require("async-mutex");
 const promises_1 = require("fs/promises");
 const path_1 = require("path");
 const WAProto_1 = require("../../WAProto");
 const auth_utils_1 = require("./auth-utils");
 const generics_1 = require("./generics");
-const node_cache_1 = __importDefault(require("node-cache"));
-const Defaults_1 = require("../Defaults");
-
-// Enhanced locking mechanism
-const fileLock = new async_lock_1.default({ 
-    maxPending: Infinity,
-    timeout: 5000 // 5s timeout to prevent deadlocks
-});
-const globalAuthLock = new async_lock_1.default(); // Additional global lock
-
-// Debugging utilities
-let AUTH_DEBUG = false;
-function authDebug(...args) {
-    if (AUTH_DEBUG) {
-        console.log('[AUTH DEBUG]', new Date().toISOString(), ...args);
+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;
+};
 /**
- * Enhanced multi-file auth state storage with:
- * - Better error handling
- * - Additional locking
- * - Data validation
- * - Auto-repair mechanisms
- */
-const useMultiFileAuthState = async (folder, options = {}) => {
-    AUTH_DEBUG = options.authDebug ?? false;
-    const cache = options.syncCache ? new node_cache_1.default({
-      stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.SIGNAL_STORE,
-      useClones: false,
-      deleteOnExpire: true,
-      checkperiod: 120
-    }) : null;
-    // Validate and prepare folder
-    const prepareFolder = async () => {
-        try {
-            const folderInfo = await (0, promises_1.stat)(folder).catch(() => null);
-            
-            if (folderInfo) {
-                if (!folderInfo.isDirectory()) {
-                    throw new Error(`Path exists but is not a directory: ${folder}`);
-                }
-            } else {
-                authDebug('Creating auth folder:', folder);
-                await (0, promises_1.mkdir)(folder, { recursive: true });
-            }
-            
-            // Verify folder is writable
-            await testFolderAccess();
-        } catch (error) {
-            authDebug('Folder preparation failed:', error);
-            throw new Error(`Auth folder initialization failed: ${error.message}`);
-        }
-    };
-
-    const testFolderAccess = async () => {
-        const testFile = (0, path_1.join)(folder, '.temp_test');
-        try {
-            await (0, promises_1.writeFile)(testFile, 'test');
-            await (0, promises_1.unlink)(testFile);
-        } catch (error) {
-            throw new Error(`Folder not writable: ${error.message}`);
-        }
-    };
-
-    const fixFileName = (file) => {
-        if (!file) return file;
-        return file.replace(/\//g, '__').replace(/:/g, '-');
-    };
-    
-    function getUniqueId(type, id) {
-        return `${type}.${id}`;
-    }
-
-    // Enhanced write with retries
+ * stores the full authentication state in a single folder.
+ * Far more efficient than singlefileauthstate
+ *
+ * Again, I wouldn't endorse this for any production level use other than perhaps a bot.
+ * Would recommend writing an auth state for use with a proper SQL or No-SQL DB
+ * */
+const useMultiFileAuthState = async (folder) => {
     const writeData = async (data, file) => {
-        return globalAuthLock.acquire('write', async () => {
-            const filePath = (0, path_1.join)(folder, fixFileName(file));
-            let attempts = 0;
-            const maxAttempts = 3;
-            
-            while (attempts < maxAttempts) {
-                attempts++;
-                try {
-                    await fileLock.acquire(filePath, async () => {
-                        const serialized = JSON.stringify(data, generics_1.BufferJSON.replacer);
-                        await (0, promises_1.writeFile)(filePath, serialized);
-                        authDebug('Write successful:', file);
-                    });
-                    return;
-                } catch (error) {
-                    authDebug(`Write attempt ${attempts} failed for ${file}:`, error);
-                    if (attempts >= maxAttempts) {
-                        throw new Error(`Failed to write after ${maxAttempts} attempts: ${error.message}`);
-                    }
-                    await new Promise(resolve => setTimeout(resolve, 100 * attempts));
-                }
+        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();
             }
         });
     };
-
-    // Enhanced read with validation
     const readData = async (file) => {
-        return globalAuthLock.acquire('read', async () => {
+        try {
             const filePath = (0, path_1.join)(folder, fixFileName(file));
-            
-            try {
-                const data = await fileLock.acquire(filePath, async () => {
-                    const content = await (0, promises_1.readFile)(filePath, { encoding: 'utf-8' });
-                    authDebug('Read successful:', file);
-                    return content;
-                });
-                
-                const parsed = JSON.parse(data, generics_1.BufferJSON.reviver);
-                
-                // Basic data validation
-                if (file === 'creds.json' && !parsed.me) {
-                    authDebug('Invalid creds data detected');
-                    return null;
+            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);
                 }
-                
-                return parsed;
-            } catch (error) {
-                if (error.code !== 'ENOENT') { // Ignore "file not found" errors
-                    authDebug('Read error:', file, error);
+                finally {
+                    release();
                 }
-                return null;
-            }
-        });
+            });
+        }
+        catch (error) {
+            return null;
+        }
     };
-
-    // Safe removal
     const removeData = async (file) => {
-        return globalAuthLock.acquire('remove', async () => {
+        try {
             const filePath = (0, path_1.join)(folder, fixFileName(file));
-            
-            try {
-                await fileLock.acquire(filePath, async () => {
+            const mutex = getFileLock(filePath);
+            return mutex.acquire().then(async (release) => {
+                try {
                     await (0, promises_1.unlink)(filePath);
-                    authDebug('Removed:', file);
-                });
-            } catch (error) {
-                if (error.code !== 'ENOENT') { // Ignore "file not found" errors
-                    authDebug('Remove error:', file, error);
                 }
-            }
-        });
-    };
-
-    // Initialize
-    await prepareFolder();
-    
-    // Load or initialize credentials
-    let creds = await readData('creds.json');
-    if (!creds) {
-        authDebug('No existing creds found, initializing new ones');
-        creds = (0, auth_utils_1.initAuthCreds)();
-        await writeData(creds, 'creds.json');
-    }
-    
-    async function warmUpCache() {
-      try {
-        const files = await promises_1.readdir(folder);
-        for (const file of files) {
-          if (file.endsWith('.json') && file !== 'creds.json') {
-            const parts = file.split('-');
-            if (parts.length === 2) {
-              const type = parts[0];
-              const id = parts[1].replace('.json', '');
-              const data = await readData(file);
-              if (data) {
-                cache.set(getUniqueId(type, id), data);
-                authDebug(`Cache warmed: ${type}-${id}`);
-              }
-            }
-          }
+                catch (_a) {
+                }
+                finally {
+                    release();
+                }
+            });
         }
-      } catch (error) {
-        authDebug('Cache warm-up failed:', error);
-      }
-    }
-    
-    if (cache) warmUpCache();
-
-    // Auto-save mechanism
-    let saveTimeout;
-    const scheduleSave = () => {
-       if (saveTimeout) clearTimeout(saveTimeout);
-       saveTimeout = setTimeout(() => {
-           saveCreds().catch(error => {
-               authDebug('Auto-save failed, retrying sooner:', error);
-               setTimeout(scheduleSave, 60000);
-           });
-       }, 180000);
-    };
-    // Enhanced save function
-    const saveCreds = async () => {
-        try {
-            await writeData(creds, 'creds.json');
-            scheduleSave();
-        } catch (error) {
-            authDebug('Critical: Creds save failed:', error);
-            throw error;
+        catch (_a) {
         }
     };
-    
-    process.on('beforeExit', async () => {
-      if (saveTimeout) clearTimeout(saveTimeout);
-      await saveCreds().catch(error => {
-        authDebug('Emergency save failed:', error);
-      });
-    });
-    
-    process.on('uncaughtException', async (error) => {
-      authDebug('Uncaught exception, attempting emergency save:', error);
-      if (saveTimeout) clearTimeout(saveTimeout);
-      await saveCreds().catch(e => {
-        authDebug('Emergency save failed:', e);
-      });
-      process.exit(1);
-    });
-    // Start auto-save loop
-    scheduleSave();
-
+    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) => { var _a; return (_a = file === null || file === void 0 ? void 0 : file.replace(/\//g, '__')) === null || _a === void 0 ? void 0 : _a.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) {
-                            try {
-                                value = WAProto_1.proto.Message.AppStateSyncKeyData.fromObject(value);
-                            } catch (error) {
-                                authDebug('Key conversion failed:', type, id, error);
-                                value = null;
-                            }
+                            value = WAProto_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`;
-                            
-                            if (value) {
-                                tasks.push(writeData(value, file));
-                            } else {
-                                tasks.push(removeData(file));
-                            }
+                            tasks.push(value ? writeData(value, file) : removeData(file));
                         }
                     }
-                    
-                    try {
-                        await Promise.all(tasks);
-                    } catch (error) {
-                        authDebug('Bulk key update failed:', error);
-                        throw error;
-                    }
+                    await Promise.all(tasks);
                 }
             }
         },
-        saveCreds,
-        // Additional maintenance API
-        cleanup: async () => {
-            if (saveTimeout) clearTimeout(saveTimeout);
-            await saveCreds();
-        },
-        cache
+        saveCreds: async () => {
+            return writeData(creds, 'creds.json');
+        }
     };
 };
-exports.useMultiFileAuthState = useMultiFileAuthState;
+exports.useMultiFileAuthState = useMultiFileAuthState;

package/lib/Utils/validate-connection.d.ts

@@ -7,5 +7,5 @@ export declare const generateRegistrationNode: ({ registrationId, signedPreKey,
 export declare const configureSuccessfulPairing: (stanza: BinaryNode, { advSecretKey, signedIdentityKey, signalIdentities }: Pick<AuthenticationCreds, 'advSecretKey' | 'signedIdentityKey' | 'signalIdentities'>) => {
     creds: Partial<AuthenticationCreds>;
     reply: BinaryNode;
-};
+}; 
 export declare const encodeSignedDeviceIdentity: (account: proto.IADVSignedDeviceIdentity, includeSignatureKey: boolean) => Uint8Array;

package/lib/Utils/validate-connection.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.encodeSignedDeviceIdentity = exports.configureSuccessfulPairing = exports.generateRegistrationNode = exports.generateLoginNode = exports.generateMobileNode = void 0;
+exports.encodeSignedDeviceIdentity = exports.configureSuccessfulPairing = exports.generateRegistrationNode = exports.generateLoginNode = void 0;
 const boom_1 = require("@hapi/boom");
 const crypto_1 = require("crypto");
 const WAProto_1 = require("../../WAProto");
@@ -9,106 +9,107 @@ const WABinary_1 = require("../WABinary");
 const crypto_2 = require("./crypto");
 const generics_1 = require("./generics");
 const signal_1 = require("./signal");
+
 const getUserAgent = (config) => {
-    var _a, _b;
-    const osVersion = config.mobile ? '15.3.1' : '0.1';
-    const version = config.mobile ? [2, 24, 6] : config.version;
-    const device = config.mobile ? 'iPhone_7' : 'Desktop';
-    const manufacturer = config.mobile ? 'Apple' : '';
-    const platform = config.mobile ? WAProto_1.proto.ClientPayload.UserAgent.Platform.IOS : WAProto_1.proto.ClientPayload.UserAgent.Platform.WEB;
-    const phoneId = config.mobile ? { phoneId: config.auth.creds.phoneId } : {};
     return {
         appVersion: {
-            primary: version[0],
-            secondary: version[1],
-            tertiary: version[2],
+            primary: config.version[0],
+            secondary: config.version[1],
+            tertiary: config.version[2],
         },
-        platform,
+        platform: WAProto_1.proto.ClientPayload.UserAgent.Platform.WEB,
         releaseChannel: WAProto_1.proto.ClientPayload.UserAgent.ReleaseChannel.RELEASE,
-        mcc: ((_a = config.auth.creds.registration) === null || _a === void 0 ? void 0 : _a.phoneNumberMobileCountryCode) || '000',
-        mnc: ((_b = config.auth.creds.registration) === null || _b === void 0 ? void 0 : _b.phoneNumberMobileNetworkCode) || '000',
-        osVersion: osVersion,
-        manufacturer,
-        device,
-        osBuildNumber: osVersion,
+        osVersion: '0.1',
+        device: 'Desktop',
+        osBuildNumber: '0.1',
         localeLanguageIso6391: 'en',
-        localeCountryIso31661Alpha2: 'US',
-        ...phoneId
+        mnc: '000',
+        mcc: '000',
+        localeCountryIso31661Alpha2: config.countryCode || 'US'
     };
 };
+
 const PLATFORM_MAP = {
     'Mac OS': WAProto_1.proto.ClientPayload.WebInfo.WebSubPlatform.DARWIN,
     'Windows': WAProto_1.proto.ClientPayload.WebInfo.WebSubPlatform.WIN32
 };
+
 const getWebInfo = (config) => {
     let webSubPlatform = WAProto_1.proto.ClientPayload.WebInfo.WebSubPlatform.WEB_BROWSER;
-    if (config.syncFullHistory && PLATFORM_MAP[config.browser[0]]) {
+    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: WAProto_1.proto.ClientPayload.ConnectType.WIFI_UNKNOWN,
         connectReason: WAProto_1.proto.ClientPayload.ConnectReason.USER_ACTIVATED,
         userAgent: getUserAgent(config),
     };
-    if (!config.mobile) {
-        payload.webInfo = getWebInfo(config);
-    }
+    payload.webInfo = getWebInfo(config);
     return payload;
 };
-const generateMobileNode = (config) => {
-    if (!config.auth.creds) {
-        throw new boom_1.Boom('No registration data found', { data: config });
-    }
-    const payload = {
-        ...getClientPayload(config),
-        sessionId: Math.floor(Math.random() * 999999999 + 1),
-        shortConnect: true,
-        connectAttemptCount: 0,
-        device: 0,
-        dnsSource: {
-            appCached: false,
-            dnsMethod: WAProto_1.proto.ClientPayload.DNSSource.DNSResolutionMethod.SYSTEM,
-        },
-        passive: false,
-        pushName: 'test',
-        username: Number(`${config.auth.creds.registration.phoneNumberCountryCode}${config.auth.creds.registration.phoneNumberNationalNumber}`),
-    };
-    return WAProto_1.proto.ClientPayload.fromObject(payload);
-};
-exports.generateMobileNode = generateMobileNode;
+
 const generateLoginNode = (userJid, config) => {
     const { user, device } = (0, WABinary_1.jidDecode)(userJid);
     const payload = {
         ...getClientPayload(config),
         passive: true,
+        pull: true,
         username: +user,
         device: device,
+        lidDbMigrated: false
     };
     return WAProto_1.proto.ClientPayload.fromObject(payload);
 };
 exports.generateLoginNode = generateLoginNode;
+
 const getPlatformType = (platform) => {
     const platformType = platform.toUpperCase();
-    return WAProto_1.proto.DeviceProps.PlatformType[platformType] || WAProto_1.proto.DeviceProps.PlatformType.DESKTOP;
+    return WAProto_1.proto.DeviceProps.PlatformType[platformType] || WAProto_1.proto.DeviceProps.PlatformType.CHROME;
 };
+
 const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentityKey }, config) => {
-    // the app version needs to be md5 hashed
-    // and passed in
     const appVersionBuf = (0, crypto_1.createHash)('md5')
-        .update(config.version.join('.')) // join as string
+        .update(config.version.join('.'))
         .digest();
+
     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 = WAProto_1.proto.DeviceProps.encode(companion).finish();
+
     const registerPayload = {
         ...getClientPayload(config),
         passive: false,
+        pull: false,
         devicePairingData: {
             buildHash: appVersionBuf,
             deviceProps: companionProto,
@@ -123,6 +124,7 @@ const generateRegistrationNode = ({ registrationId, signedPreKey, signedIdentity
     return WAProto_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');
@@ -130,30 +132,52 @@ const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, s
     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 === null || businessNode === void 0 ? void 0 : businessNode.attrs.name;
+
+    const bizName = businessNode?.attrs.name;
     const jid = deviceNode.attrs.jid;
-    const { details, hmac } = WAProto_1.proto.ADVSignedDeviceIdentityHMAC.decode(deviceIdentityNode.content);
-    // check HMAC matches
-    const advSign = (0, crypto_2.hmacSign)(details, Buffer.from(advSecretKey, 'base64'));
+    const lid = deviceNode.attrs.lid;
+
+    const { details, hmac, accountType } = WAProto_1.proto.ADVSignedDeviceIdentityHMAC.decode(deviceIdentityNode.content);
+
+    let hmacPrefix = Buffer.from([]);
+    if (accountType !== undefined && accountType === WAProto_1.proto.ADVEncryptionType.HOSTED) {
+        hmacPrefix = Buffer.from([0x06, 0x05]);
+    }
+
+    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 = WAProto_1.proto.ADVSignedDeviceIdentity.decode(details);
     const { accountSignatureKey, accountSignature, details: deviceDetails } = account;
-    // verify the device signature matches
-    const accountMsg = Buffer.concat([Buffer.from([6, 0]), deviceDetails, signedIdentityKey.public]);
+
+    const deviceIdentity = WAProto_1.proto.ADVDeviceIdentity.decode(deviceDetails);
+
+    const accountSignaturePrefix = deviceIdentity.deviceType === WAProto_1.proto.ADVEncryptionType.HOSTED 
+        ? Buffer.from([0x06, 0x05])
+        : Buffer.from([0x06, 0x00]);
+    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');
     }
-    // sign the details with our identity key
-    const deviceMsg = Buffer.concat([Buffer.from([6, 1]), deviceDetails, signedIdentityKey.public, accountSignatureKey]);
+
+    const deviceMsg = Buffer.concat([
+        Buffer.from([0x06, 0x01]),
+        deviceDetails,
+        signedIdentityKey.public,
+        accountSignatureKey
+    ]);
     account.deviceSignature = crypto_2.Curve.sign(signedIdentityKey.private, deviceMsg);
+
     const identity = (0, signal_1.createSignalIdentity)(jid, accountSignatureKey);
     const accountEnc = (0, exports.encodeSignedDeviceIdentity)(account, false);
-    const deviceIdentity = WAProto_1.proto.ADVDeviceIdentity.decode(account.details);
+
     const reply = {
         tag: 'iq',
         attrs: {
@@ -175,27 +199,27 @@ const configureSuccessfulPairing = (stanza, { advSecretKey, signedIdentityKey, s
             }
         ]
     };
+
     const authUpdate = {
         account,
-        me: { id: jid, name: bizName },
+        me: { id: jid, name: bizName, lid },
         signalIdentities: [
             ...(signalIdentities || []),
             identity
         ],
-        platform: platformNode === null || platformNode === void 0 ? void 0 : platformNode.attrs.name
+        platform: platformNode?.attrs.name
     };
+
     return {
         creds: authUpdate,
         reply
     };
 };
 exports.configureSuccessfulPairing = configureSuccessfulPairing;
+
 const encodeSignedDeviceIdentity = (account, includeSignatureKey) => {
-    var _a;
     account = { ...account };
-    // set to null if we are not to include the signature key
-    // or if we are including the signature key but it is empty
-    if (!includeSignatureKey || !((_a = account.accountSignatureKey) === null || _a === void 0 ? void 0 : _a.length)) {
+    if (!includeSignatureKey || !account.accountSignatureKey?.length) {
         account.accountSignatureKey = null;
     }
     return WAProto_1.proto.ADVSignedDeviceIdentity