@vanzxy/baileys 1.4.0 → 1.4.2

package/cjs/lib/Utils/use-single-file-auth-state.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSingleFileAuthState = void 0;
+const promises_1 = require("fs/promises");
+const index_js_1 = require("../Defaults/index.js");
+const index_js_2 = require("../../WAProto/index.js");
+const auth_utils_js_1 = require("./auth-utils.js");
+const generics_js_1 = require("./generics.js");
+const lru_cache_1 = require("lru-cache");
+const async_mutex_1 = require("async-mutex");
+const logger_js_1 = __importDefault(require("./logger.js"));
+// Lia@Changes 25-03-26 --- Add useSingleFileAuthState with integrated cache
+const FLUSH_TIMEOUT_MS = 3000;
+// Lia@Changes 22-04-26 --- Enhanced useSingleFileAuthState with LRUCache
+const useSingleFileAuthState = async (fileName) => {
+    const cache = new lru_cache_1.LRUCache({
+        max: 20000,
+        ttl: 1000 * index_js_1.DEFAULT_CACHE_TTLS.SIGNAL_STORE,
+        updateAgeOnGet: false,
+        updateAgeOnHas: false,
+        ttlAutopurge: true
+    });
+    // Lia@Changes 26-04-26 --- Add mutex for prevent race condition
+    const mutex = new async_mutex_1.Mutex();
+    let fileData = {};
+    let isLoaded = false;
+    let flushTimeout = null;
+    const loadKey = async () => {
+        return await mutex.runExclusive(async () => {
+            if (isLoaded)
+                return;
+            try {
+                const data = JSON.parse(await (0, promises_1.readFile)(fileName, 'utf-8'), generics_js_1.BufferJSON.reviver);
+                fileData = data || {};
+                for (const [keyName, value] of Object.entries(fileData)) {
+                    cache.set(keyName, value);
+                }
+            }
+            catch {
+                fileData = {};
+            }
+            isLoaded = true;
+        });
+    };
+    const flushKey = () => {
+        if (flushTimeout)
+            return;
+        flushTimeout = setTimeout(async () => {
+            flushTimeout = null;
+            await mutex.runExclusive(async () => {
+                try {
+                    const tempFile = fileName + '.temp';
+                    await (0, promises_1.writeFile)(tempFile, JSON.stringify(fileData, generics_js_1.BufferJSON.replacer));
+                    await (0, promises_1.rename)(tempFile, fileName);
+                }
+                catch (err) {
+                    // Vanz@Fix (bug 58): was silently swallowed — auth session could fail
+                    // to persist (disk full, permission error, etc.) with zero trace.
+                    logger_js_1.default.error({ err, fileName }, 'failed to flush auth state to disk');
+                }
+            });
+        }, FLUSH_TIMEOUT_MS);
+    };
+    const writeKey = (keyName, value) => {
+        cache.set(keyName, value);
+        fileData[keyName] = value;
+        flushKey();
+    };
+    const removeKey = (keyName) => {
+        cache.delete(keyName);
+        delete fileData[keyName];
+        flushKey();
+    };
+    const fileInfo = await (0, promises_1.stat)(fileName).catch(() => null);
+    if (!fileInfo) {
+        await (0, promises_1.writeFile)(fileName, '{}');
+    }
+    else if (!fileInfo.isFile()) {
+        throw new Error(`found something that is not a file at ${fileName}, either delete it or specify a different location`);
+    }
+    await loadKey();
+    const creds = fileData['creds'] || (0, auth_utils_js_1.initAuthCreds)();
+    return {
+        state: {
+            creds,
+            keys: {
+                get: (type, ids) => {
+                    const data = {};
+                    for (const id of ids) {
+                        const keyName = type + id;
+                        let value = cache.get(keyName);
+                        if (value === undefined && fileData[keyName] !== undefined) {
+                            value = fileData[keyName];
+                            cache.set(keyName, value);
+                        }
+                        if (type === 'app-state-sync-key' && value) {
+                            value = index_js_2.proto.Message.AppStateSyncKeyData.fromObject(value);
+                        }
+                        data[id] = value;
+                    }
+                    return data;
+                },
+                set: (data) => {
+                    for (const category in data) {
+                        for (const id in data[category]) {
+                            const keyName = category + id;
+                            const value = data[category][id];
+                            value ? writeKey(keyName, value) : removeKey(keyName);
+                        }
+                    }
+                }
+            }
+        },
+        saveCreds: () => writeKey('creds', creds)
+    };
+};
+exports.useSingleFileAuthState = useSingleFileAuthState;
+//# sourceMappingURL=use-single-file-auth-state.js.map

package/cjs/lib/Utils/use-sqlite-auth-state.js

@@ -0,0 +1,182 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSqliteAuthState = useSqliteAuthState;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const index_js_1 = require("../../WAProto/index.js");
+const auth_utils_js_1 = require("./auth-utils.js");
+const generics_js_1 = require("./generics.js");
+async function loadBetterSqlite3() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const mod = (await Promise.resolve().then(() => __importStar(require('better-sqlite3'))));
+        return mod.default ?? mod;
+    }
+    catch (err) {
+        const helpful = new Error('`better-sqlite3` is required for `useSqliteAuthState`. Install it as a peer dependency: `npm install better-sqlite3` (or `yarn add better-sqlite3`).');
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        helpful.cause = err;
+        throw helpful;
+    }
+}
+const CREDS_ROW_KEY = '__creds__';
+const CREATE_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS creds (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS signal_keys (
+  type TEXT NOT NULL,
+  id TEXT NOT NULL,
+  value TEXT NOT NULL,
+  PRIMARY KEY (type, id)
+);
+CREATE INDEX IF NOT EXISTS signal_keys_type_idx ON signal_keys(type);
+`;
+async function useSqliteAuthState(opts) {
+    let db;
+    if (opts.database) {
+        db = opts.database;
+    }
+    else {
+        const Database = await loadBetterSqlite3();
+        db = new Database(opts.dbPath);
+    }
+    // WAL mode allows concurrent reads alongside a single writer; matches
+    // what SQLite recommends for read-heavy workloads with sporadic writes.
+    db.pragma('journal_mode = WAL');
+    db.pragma('synchronous = NORMAL');
+    db.exec(CREATE_SCHEMA_SQL);
+    // Vanz@Fix (bug 8): periodic WAL checkpoint + cleanup old signal keys to prevent DB bloat.
+    // Runs every 30 minutes. WAL checkpoint reclaims WAL file space; key cleanup removes stale session entries.
+    const _walCleanupInterval = setInterval(() => {
+        try {
+            db.pragma('wal_checkpoint(PASSIVE)');
+            // Remove signal keys older than 30 days (pre-keys, session keys that have expired)
+            // Only removes types that are safe to prune (not creds or app-state-sync-key)
+            const pruneTypes = ['pre-key', 'session'];
+            for (const type of pruneTypes) {
+                try {
+                    // Keep last 500 per type to avoid breaking active sessions
+                    db.prepare(`
+                        DELETE FROM signal_keys WHERE type = ? AND id NOT IN (
+                            SELECT id FROM signal_keys WHERE type = ? ORDER BY rowid DESC LIMIT 500
+                        )
+                    `).run(type, type);
+                }
+                catch { /* ignore per-type errors */ }
+            }
+        }
+        catch { /* ignore checkpoint errors — non-fatal */ }
+    }, 30 * 60 * 1000);
+    // Allow Node process to exit even if interval is still running
+    if (_walCleanupInterval.unref)
+        _walCleanupInterval.unref();
+    const stmts = {
+        credsSelect: db.prepare('SELECT value FROM creds WHERE key = ?'),
+        credsUpsert: db.prepare('INSERT INTO creds (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value'),
+        keySelect: db.prepare('SELECT value FROM signal_keys WHERE type = ? AND id = ?'),
+        keyUpsert: db.prepare('INSERT INTO signal_keys (type, id, value) VALUES (?, ?, ?) ON CONFLICT(type, id) DO UPDATE SET value = excluded.value'),
+        keyDelete: db.prepare('DELETE FROM signal_keys WHERE type = ? AND id = ?'),
+        keyListIds: db.prepare('SELECT id FROM signal_keys WHERE type = ?'),
+        keyList: db.prepare('SELECT id, value FROM signal_keys WHERE type = ?'),
+        clearKeys: db.prepare('DELETE FROM signal_keys')
+    };
+    const loadCreds = () => {
+        const row = stmts.credsSelect.get(CREDS_ROW_KEY);
+        if (!row)
+            return (0, auth_utils_js_1.initAuthCreds)();
+        return JSON.parse(row.value, generics_js_1.BufferJSON.reviver);
+    };
+    const persistCreds = (creds) => {
+        stmts.credsUpsert.run(CREDS_ROW_KEY, JSON.stringify(creds, generics_js_1.BufferJSON.replacer));
+    };
+    const creds = loadCreds();
+    return {
+        state: {
+            creds,
+            keys: {
+                get: async (type, ids) => {
+                    const data = {};
+                    for (const id of ids) {
+                        const row = stmts.keySelect.get(type, id);
+                        if (row) {
+                            let value = JSON.parse(row.value, generics_js_1.BufferJSON.reviver);
+                            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 writeTx = db.transaction(() => {
+                        for (const category in data) {
+                            for (const id in data[category]) {
+                                const value = data[category][id];
+                                if (value) {
+                                    const stringified = JSON.stringify(value, generics_js_1.BufferJSON.replacer);
+                                    stmts.keyUpsert.run(category, id, stringified);
+                                }
+                                else {
+                                    stmts.keyDelete.run(category, id);
+                                }
+                            }
+                        }
+                    });
+                    writeTx();
+                }
+            }
+        },
+        saveCreds: async () => {
+            persistCreds(creds);
+        },
+        // Vanz@Fix: release the WAL cleanup interval and (if we opened it ourselves)
+        // the underlying db handle. Without this, every useSqliteAuthState() call
+        // (e.g. re-pairing / rotating sessions) leaked a timer + open sqlite fd forever.
+        close: async () => {
+            clearInterval(_walCleanupInterval);
+            if (!opts.database) {
+                try {
+                    db.close();
+                }
+                catch { /* already closed */ }
+            }
+        }
+    };
+}
+//# sourceMappingURL=use-sqlite-auth-state.js.map

package/cjs/lib/Utils/validate-connection.js

@@ -0,0 +1,210 @@
+"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 index_js_1 = require("../../WAProto/index.js");
+const index_js_2 = require("../Defaults/index.js");
+const index_js_3 = require("../WABinary/index.js");
+const crypto_js_1 = require("./crypto.js");
+const generics_js_1 = require("./generics.js");
+const signal_js_1 = require("./signal.js");
+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);
+    if (config.pushName) {
+        payload.pushName = config.pushName;
+    }
+    return payload;
+};
+const generateLoginNode = (userJid, config) => {
+    const { user, device } = (0, index_js_3.jidDecode)(userJid);
+    const payload = {
+        ...getClientPayload(config),
+        passive: true,
+        pull: true,
+        username: +user,
+        device: device,
+        // Vanz@Fix (bug 49): was hardcoded false — now reads from config.lidDbMigrated (default false until investigated)
+        lidDbMigrated: config.lidDbMigrated ?? false
+    };
+    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) => {
+    // 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
+        .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 = index_js_1.proto.DeviceProps.encode(companion).finish();
+    const registerPayload = {
+        ...getClientPayload(config),
+        passive: false,
+        pull: false,
+        devicePairingData: {
+            buildHash: appVersionBuf,
+            deviceProps: companionProto,
+            eRegid: (0, generics_js_1.encodeBigEndian)(registrationId),
+            eKeytype: index_js_2.KEY_BUNDLE_TYPE,
+            eIdent: signedIdentityKey.public,
+            eSkeyId: (0, generics_js_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, index_js_3.getBinaryNodeChild)(stanza, 'pair-success');
+    const deviceIdentityNode = (0, index_js_3.getBinaryNodeChild)(pairSuccessNode, 'device-identity');
+    const platformNode = (0, index_js_3.getBinaryNodeChild)(pairSuccessNode, 'platform');
+    const deviceNode = (0, index_js_3.getBinaryNodeChild)(pairSuccessNode, 'device');
+    const businessNode = (0, index_js_3.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 = index_js_2.WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX;
+    }
+    const advSign = (0, crypto_js_1.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
+        ? index_js_2.WA_ADV_HOSTED_ACCOUNT_SIG_PREFIX
+        : index_js_2.WA_ADV_ACCOUNT_SIG_PREFIX;
+    const accountMsg = Buffer.concat([accountSignaturePrefix, deviceDetails, signedIdentityKey.public]);
+    if (!crypto_js_1.Curve.verify(accountSignatureKey, accountMsg, accountSignature)) {
+        throw new boom_1.Boom('Failed to verify account signature');
+    }
+    const deviceMsg = Buffer.concat([
+        index_js_2.WA_ADV_DEVICE_SIG_PREFIX,
+        deviceDetails,
+        signedIdentityKey.public,
+        accountSignatureKey
+    ]);
+    account.deviceSignature = crypto_js_1.Curve.sign(signedIdentityKey.private, deviceMsg);
+    const identity = (0, signal_js_1.createSignalIdentity)(lid, accountSignatureKey);
+    const accountEnc = (0, exports.encodeSignedDeviceIdentity)(account, false);
+    const reply = {
+        tag: 'iq',
+        attrs: {
+            to: index_js_3.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 };
+    // 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 || !account.accountSignatureKey?.length) {
+        account.accountSignatureKey = null;
+    }
+    return index_js_1.proto.ADVSignedDeviceIdentity.encode(account).finish();
+};
+exports.encodeSignedDeviceIdentity = encodeSignedDeviceIdentity;
+//# sourceMappingURL=validate-connection.js.map